diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3f25f26..11e65a0 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -71,42 +71,71 @@ jobs: run: dotnet restore - name: Build AffinityPluginLoader - run: dotnet build AffinityPluginLoader/AffinityPluginLoader.csproj -c Release + run: dotnet build AffinityPluginLoader/AffinityPluginLoader.csproj -c Debug - name: Build WineFix - run: dotnet build WineFix/WineFix.csproj -c Release + run: dotnet build WineFix/WineFix.csproj -c Debug - name: Build AffinityHook - run: dotnet build AffinityHook/AffinityHook.csproj -c Release + run: dotnet build AffinityHook/AffinityHook.csproj -c Debug - name: Upload AffinityPluginLoader artifacts uses: actions/upload-artifact@v4 with: name: AffinityPluginLoader path: | - AffinityPluginLoader/bin/Release/net48/win-x64/AffinityPluginLoader.dll - AffinityPluginLoader/bin/Release/net48/win-x64/0Harmony.dll + AffinityPluginLoader/bin/Debug/net48/win-x64/AffinityPluginLoader.dll + AffinityPluginLoader/bin/Debug/net48/win-x64/0Harmony.dll if-no-files-found: error - name: Upload AffinityHook artifacts uses: actions/upload-artifact@v4 with: name: AffinityHook - path: AffinityHook/bin/Release/net48/win-x64/AffinityHook.exe + path: AffinityHook/bin/Debug/net48/win-x64/AffinityHook.exe if-no-files-found: error - name: Upload WineFix artifacts uses: actions/upload-artifact@v4 with: name: WineFix - path: WineFix/bin/Release/net48/win-x64/WineFix.dll + path: WineFix/bin/Debug/net48/win-x64/WineFix.dll + if-no-files-found: error + + # Build d2d1.dll for Wine (x86_64-unix) + build-d2d1: + name: Build d2d1.dll (Wine Native) + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Install Wine development tools + run: | + sudo dpkg --add-architecture i386 + sudo mkdir -pm755 /etc/apt/keyrings + sudo wget -O /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key + sudo wget -NP /etc/apt/sources.list.d/ https://dl.winehq.org/wine-builds/ubuntu/dists/jammy/winehq-jammy.sources + sudo apt update + sudo apt install -y --install-recommends wine64-tools + + - name: Build d2d1.dll for x86_64-unix + working-directory: WineFix/lib/d2d1 + run: make TARGET=x86_64-unix + + - name: Upload d2d1 artifact + uses: actions/upload-artifact@v4 + with: + name: d2d1 + path: WineFix/lib/d2d1/build/x86_64-unix/d2d1.dll.so if-no-files-found: error # Package all artifacts into release archives package: name: Package Release Artifacts runs-on: ubuntu-latest - needs: [build-bootstrap, build-csharp] + needs: [build-bootstrap, build-csharp, build-d2d1] steps: - name: Checkout code @@ -114,7 +143,7 @@ jobs: - name: Get short commit hash id: commit - run: echo "short_sha=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT + run: echo "short_sha=$(echo ${{ github.event.pull_request.head.sha }} | cut -c1-7)" >> $GITHUB_OUTPUT - name: Download AffinityBootstrap artifact uses: actions/download-artifact@v4 @@ -140,6 +169,12 @@ jobs: name: WineFix path: build/winefix + - name: Download d2d1 artifact + uses: actions/download-artifact@v4 + with: + name: d2d1 + path: build/d2d1 + - name: Create affinitypluginloader package structure run: | mkdir -p package/affinitypluginloader @@ -155,6 +190,7 @@ jobs: mkdir -p package/winefix/plugins cp build/winefix/WineFix.dll package/winefix/plugins/ cp WineFix/LICENSE package/winefix/plugins/LICENSE + cp build/d2d1/d2d1.dll.so package/winefix/d2d1.dll - name: Create combined package structure run: | @@ -164,6 +200,7 @@ jobs: cp build/pluginloader/AffinityPluginLoader.dll package/combined/ cp build/pluginloader/0Harmony.dll package/combined/ cp build/winefix/WineFix.dll package/combined/plugins/ + cp build/d2d1/d2d1.dll.so package/combined/d2d1.dll - name: Create release archives run: | diff --git a/.github/workflows/pr-comment-complete.yml b/.github/workflows/pr-comment-complete.yml index a1a2549..311fb90 100644 --- a/.github/workflows/pr-comment-complete.yml +++ b/.github/workflows/pr-comment-complete.yml @@ -30,10 +30,16 @@ jobs: PR_NUMBER=$(gh pr view "$PR_BRANCH" --repo ${{ github.repository }} --json number --jq '.number') echo "number=$PR_NUMBER" >> $GITHUB_OUTPUT + - name: Download commit SHA artifact + uses: actions/download-artifact@v4 + with: + name: commit_sha + run-id: ${{ github.event.workflow_run.id }} + - name: Get commit and run info id: run-info run: | - echo "short_sha=$(echo ${{ github.event.workflow_run.head_sha }} | cut -c1-7)" >> $GITHUB_OUTPUT + echo "short_sha=$(cat commit_sha.txt | cut -c1-7)" >> $GITHUB_OUTPUT echo "run_id=${{ github.event.workflow_run.id }}" >> $GITHUB_OUTPUT echo "conclusion=${{ github.event.workflow_run.conclusion }}" >> $GITHUB_OUTPUT diff --git a/WineFix/README.md b/WineFix/README.md index 72b479b..dd96a8e 100644 --- a/WineFix/README.md +++ b/WineFix/README.md @@ -27,11 +27,16 @@ especially if the bug needs to be patched in native code. ## Licensing -WineFix is licensed under the terms of the GPLv2 except for the exemption noted below. You can find a copy of the license in the LICENSE file. +WineFix is licensed under the terms of the GPLv2 except for the exclusion and exemption noted below. You can find a copy of the license in the LICENSE file. + +### License Exclusion + +WineFix includes source code from the Wine project for d2d1.dll under `/WineFix/lib/d2d1`. In accordance with the original project, the code in this directory are instead licensed under the LGPLv2.1. A copy of this license can be found at `/WineFix/lib/d2d1/LICENSE`. Changes have been applied to the d2d1 source code to implement a recursive cubic bezier subdivision algorithm to correct cubic bezier rendering in Affinity, and to allow building d2d1.dll standalone from the full Wine source code repository. ### License Exemption -[Canva](https://github.com/canva) and it's subsidiaries are exempt from MIT licensing and may (at its option) instead license any source code authored for the WineFix project under the Zero-Clause BSD license. +[Canva](https://github.com/canva) and it's subsidiaries are exempt from GPLv2 licensing and may (at its option) instead license any source code authored for the WineFix project under the Zero-Clause BSD license. +- Due to requirements of the upstream Wine licensing, this exemption **does not apply** to the d2d1.dll implementation source code, ie. all code under `WineFix/lib/d2d1/` is excluded from this exemption. # Credits diff --git a/WineFix/lib/d2d1/.gitignore b/WineFix/lib/d2d1/.gitignore new file mode 100644 index 0000000..26f4e87 --- /dev/null +++ b/WineFix/lib/d2d1/.gitignore @@ -0,0 +1,55 @@ +# Build directories +build/ +build-*/ + +# Object files +*.o +*.obj +*.lo + +# Libraries +*.lib +*.a +*.la + +# Shared objects (DLLs) +*.dll +*.dll.so +*.so +*.dylib + +# Executables +*.exe +*.out +*.app + +# Generated files +*.res +*.rc.tmp +*_processed.rc + +# IDL generated headers +include/generated/ + +# CMake +CMakeCache.txt +CMakeFiles/ +cmake_install.cmake +install_manifest.txt + +# IDE files +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS files +.DS_Store +Thumbs.db + +# Dependency files +*.d + +# Log files +*.log diff --git a/WineFix/lib/d2d1/CMakeLists.txt b/WineFix/lib/d2d1/CMakeLists.txt new file mode 100644 index 0000000..24c4374 --- /dev/null +++ b/WineFix/lib/d2d1/CMakeLists.txt @@ -0,0 +1,134 @@ +cmake_minimum_required(VERSION 3.16) +project(d2d1 VERSION 10.18 LANGUAGES C) + +# Options for build configuration +option(BUILD_FOR_UNIX "Build Unix PE format (requires winegcc)" OFF) +option(BUILD_SYSWOW64 "Build for SysWoW64 mode" OFF) +set(TARGET_ARCH "x86_64" CACHE STRING "Target architecture (x86_64 or i386)") + +# Set compiler based on architecture +if(TARGET_ARCH STREQUAL "i386") + set(CMAKE_C_COMPILER i686-w64-mingw32-gcc) + set(CMAKE_RC_COMPILER i686-w64-mingw32-windres) + set(ARCH_FLAGS -m32 -D__i386__) +else() + set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc) + set(CMAKE_RC_COMPILER x86_64-w64-mingw32-windres) + set(ARCH_FLAGS -m64 -D__x86_64__) +endif() + +# Source files +set(D2D1_SOURCES + src/bitmap.c + src/bitmap_render_target.c + src/brush.c + src/command_list.c + src/dc_render_target.c + src/device.c + src/effect.c + src/factory.c + src/geometry.c + src/hwnd_render_target.c + src/layer.c + src/mesh.c + src/state_block.c + src/stroke.c + src/wic_render_target.c +) + +# IDL files to process +file(GLOB IDL_FILES "include/windows/*.idl") + +# Create custom command to process IDL files +set(IDL_HEADERS "") +foreach(IDL_FILE ${IDL_FILES}) + get_filename_component(IDL_NAME ${IDL_FILE} NAME_WE) + set(IDL_HEADER "${CMAKE_BINARY_DIR}/include/${IDL_NAME}.h") + add_custom_command( + OUTPUT ${IDL_HEADER} + COMMAND widl -I${CMAKE_SOURCE_DIR}/include/windows -h -o ${IDL_HEADER} ${IDL_FILE} + DEPENDS ${IDL_FILE} + COMMENT "Processing IDL: ${IDL_NAME}.idl" + ) + list(APPEND IDL_HEADERS ${IDL_HEADER}) +endforeach() + +# Create a custom target for IDL headers +add_custom_target(idl_headers DEPENDS ${IDL_HEADERS}) + +# Create the DLL +add_library(d2d1 SHARED ${D2D1_SOURCES}) + +# Make sure IDL headers are generated before compiling +add_dependencies(d2d1 idl_headers) + +# Include directories +target_include_directories(d2d1 PRIVATE + ${CMAKE_SOURCE_DIR}/include/wine + ${CMAKE_SOURCE_DIR}/include/windows + ${CMAKE_BINARY_DIR}/include + ${CMAKE_SOURCE_DIR}/src +) + +# Compiler definitions +target_compile_definitions(d2d1 PRIVATE + __WINE__ + _REENTRANT + WINE_UNICODE_NATIVE + $<$:__unix__> + $<$:__WINE_SYSWOW64__> +) + +# Compiler flags +target_compile_options(d2d1 PRIVATE + ${ARCH_FLAGS} + -Wall + -O2 +) + +# Linker flags +target_link_options(d2d1 PRIVATE + ${ARCH_FLAGS} + $<$>:-shared> +) + +# Link libraries +target_link_libraries(d2d1 PRIVATE + d3d11 + dxgi + d3d10_1 + d3dcompiler + dwrite + gdi32 + user32 + advapi32 + ole32 + xmllite + uuid +) + +# Set output name +set_target_properties(d2d1 PROPERTIES + OUTPUT_NAME "d2d1" + PREFIX "" + SUFFIX ".dll" +) + +# Resource file handling +if(EXISTS "${CMAKE_SOURCE_DIR}/src/version.rc") + target_sources(d2d1 PRIVATE src/version.rc) +endif() + +# Install rules +install(TARGETS d2d1 + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib +) + +# Print configuration +message(STATUS "D2D1 Build Configuration:") +message(STATUS " Architecture: ${TARGET_ARCH}") +message(STATUS " Build for Unix PE: ${BUILD_FOR_UNIX}") +message(STATUS " SysWoW64 mode: ${BUILD_SYSWOW64}") +message(STATUS " Compiler: ${CMAKE_C_COMPILER}") diff --git a/WineFix/lib/d2d1/LICENSE b/WineFix/lib/d2d1/LICENSE new file mode 100644 index 0000000..bd48d7c --- /dev/null +++ b/WineFix/lib/d2d1/LICENSE @@ -0,0 +1,37 @@ +GNU LESSER GENERAL PUBLIC LICENSE +Version 2.1, February 1999 + +Copyright (C) 1991, 1999 Free Software Foundation, Inc. +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +Everyone is permitted to copy and distribute verbatim copies +of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts +as the successor of the GNU Library Public License, version 2, hence +the version number 2.1.] + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +--- + +This code is extracted from Wine 10.18 +Copyright (c) 1993-2025 the Wine project authors + +For a complete list of Wine authors, see: +https://www.winehq.org/ + +The Wine project is licensed under the LGPL 2.1. +For the full license text, see: +https://www.winehq.org/license diff --git a/WineFix/lib/d2d1/Makefile b/WineFix/lib/d2d1/Makefile new file mode 100644 index 0000000..bb12479 --- /dev/null +++ b/WineFix/lib/d2d1/Makefile @@ -0,0 +1,200 @@ +# D2D1.DLL Standalone Makefile +# Supports: x86_64-unix, x86_64-windows, i386-windows, and SysWoW64 mode + +.PHONY: all clean help x86_64-unix x86_64-windows i386-windows syswow64 + +# Build target (can be overridden: make TARGET=x86_64-windows) +TARGET ?= x86_64-unix + +# Directories +SRCDIR := src +INCDIR := include +BUILDDIR := build +OUTDIR := $(BUILDDIR)/$(TARGET) + +# Source files +ALL_SOURCES := $(wildcard $(SRCDIR)/*.c) +# For Unix builds, exclude guids.c (GUIDs are defined in factory.c via D2D1_INIT_GUID) +SOURCES := $(ALL_SOURCES) +OBJECTS := $(patsubst $(SRCDIR)/%.c,$(OUTDIR)/%.o,$(SOURCES)) +SPEC_FILE := $(SRCDIR)/d2d1.spec +RC_FILE := $(SRCDIR)/version.rc + +# IDL files that need to be processed +IDL_FILES := $(wildcard $(INCDIR)/windows/*.idl) +IDL_HEADERS := $(patsubst $(INCDIR)/windows/%.idl,$(OUTDIR)/include/%.h,$(IDL_FILES)) + +# Common flags +CFLAGS := -I$(INCDIR) -I$(INCDIR)/windows -I$(OUTDIR)/include -I$(SRCDIR) +CFLAGS += -Wall -O2 -D__WINE__ -D_REENTRANT -DWINE_UNICODE_NATIVE +LDFLAGS := + +# Target-specific configuration +ifeq ($(TARGET),x86_64-unix) + CC := winegcc + WIDL := widl + WINEBUILD := winebuild + WINEGCC := winegcc + CFLAGS += -m64 -D__x86_64__ -D__unix__ + LDFLAGS += -m64 + DLL_EXT := .dll.so + BUILD_MODE := unix + ARCH := x86_64 + LIBS := -ld3d11 -ldxgi -ld3d10_1 -ld3dcompiler -ldwrite -lxmllite -ldxguid -lgdi32 -luser32 -ladvapi32 -lole32 -luuid + # Exclude guids.c for Unix builds (GUIDs defined in factory.c with D2D1_INIT_GUID) + SOURCES := $(filter-out $(SRCDIR)/guids.c,$(ALL_SOURCES)) + OBJECTS := $(patsubst $(SRCDIR)/%.c,$(OUTDIR)/%.o,$(SOURCES)) +endif + +ifeq ($(TARGET),x86_64-windows) + CC := x86_64-w64-mingw32-gcc + WIDL := widl + WINEBUILD := winebuild + CFLAGS += -m64 -D__x86_64__ + LDFLAGS += -m64 -shared + DLL_EXT := .dll + BUILD_MODE := windows + ARCH := x86_64 + # Try to use Wine's d3d10_1 if available for x86_64 + ifeq ($(wildcard /usr/lib/wine/x86_64-windows/libd3d10_1.a),) + D3D10_LIB := -ld3d10 + else + D3D10_LIB := -L/usr/lib/wine/x86_64-windows -ld3d10_1 + endif + LIBS := -ld3d11 -ldxgi $(D3D10_LIB) -ld3dcompiler -ldwrite -lgdi32 -luser32 -ladvapi32 -lole32 -lxmllite -luuid -lmsvcrt +endif + +ifeq ($(TARGET),i386-windows) + CC := i686-w64-mingw32-gcc + WIDL := widl + WINEBUILD := winebuild + CFLAGS += -m32 -D__i386__ + LDFLAGS += -m32 -shared + DLL_EXT := .dll + BUILD_MODE := windows + ARCH := i386 + # Try to use Wine's d3d10_1 if available for i386 + ifeq ($(wildcard /usr/lib/wine/i386-windows/libd3d10_1.a),) + D3D10_LIB := -ld3d10 + else + D3D10_LIB := -L/usr/lib/wine/i386-windows -ld3d10_1 + endif + LIBS := -ld3d11 -ldxgi $(D3D10_LIB) -ld3dcompiler -ldwrite -lgdi32 -luser32 -ladvapi32 -lole32 -lxmllite -luuid -lmsvcrt +endif + +ifeq ($(TARGET),syswow64) + CC := i686-w64-mingw32-gcc + WIDL := widl + WINEBUILD := winebuild + CFLAGS += -m32 -D__i386__ -D__WINE_SYSWOW64__ + LDFLAGS += -m32 -shared + DLL_EXT := .dll + BUILD_MODE := syswow64 + ARCH := i386 + # Try to use Wine's d3d10_1 if available for syswow64 + ifeq ($(wildcard /usr/lib/wine/i386-windows/libd3d10_1.a),) + D3D10_LIB := -ld3d10 + else + D3D10_LIB := -L/usr/lib/wine/i386-windows -ld3d10_1 + endif + LIBS := -ld3d11 -ldxgi $(D3D10_LIB) -ld3dcompiler -ldwrite -lgdi32 -luser32 -ladvapi32 -lole32 -lxmllite -luuid -lmsvcrt +endif + +# Output DLL +OUTPUT_DLL := $(OUTDIR)/d2d1$(DLL_EXT) + +# Default target +all: $(TARGET) + +# Help target +help: + @echo "D2D1.DLL Standalone Build System" + @echo "" + @echo "Available targets:" + @echo " make x86_64-unix - Build for x86_64 Unix (Wine PE)" + @echo " make x86_64-windows - Build for x86_64 Windows" + @echo " make i386-windows - Build for i386 Windows" + @echo " make syswow64 - Build for SysWoW64 mode" + @echo " make clean - Clean build artifacts" + @echo "" + @echo "Or set TARGET variable:" + @echo " make TARGET=x86_64-windows" + +# Build targets +x86_64-unix: + @$(MAKE) TARGET=x86_64-unix build + +x86_64-windows: + @$(MAKE) TARGET=x86_64-windows build + +i386-windows: + @$(MAKE) TARGET=i386-windows build + +syswow64: + @$(MAKE) TARGET=syswow64 build + +# Main build rule +build: $(OUTPUT_DLL) + @echo "Build complete: $(OUTPUT_DLL)" + +# Create output directories +$(OUTDIR): + @mkdir -p $(OUTDIR) + @mkdir -p $(OUTDIR)/include + +# Process IDL files +$(OUTDIR)/include/%.h: $(INCDIR)/windows/%.idl | $(OUTDIR) + @echo "IDL: $<" + @$(WIDL) -I$(INCDIR)/windows -h -o $@ $< + +# Compile C files +$(OUTDIR)/%.o: $(SRCDIR)/%.c $(IDL_HEADERS) | $(OUTDIR) + @echo "CC: $<" + @$(CC) $(CFLAGS) -c -o $@ $< + +# Compile resource file +$(OUTDIR)/version.o: $(RC_FILE) | $(OUTDIR) + @echo "RC: $<" +ifeq ($(ARCH),i386) + @i686-w64-mingw32-windres -i $< -o $@ +else + @x86_64-w64-mingw32-windres -i $< -o $@ +endif + +# Link DLL (Windows mode) +ifeq ($(BUILD_MODE),windows) +$(OUTPUT_DLL): $(OBJECTS) $(OUTDIR)/version.o | $(OUTDIR) + @echo "LINK: $@" + @$(CC) $(LDFLAGS) -o $@ $(OBJECTS) $(OUTDIR)/version.o $(LIBS) \ + -Wl,--out-implib,$(OUTDIR)/libd2d1.a +endif + +# Link DLL (Unix mode - requires winegcc) +ifeq ($(BUILD_MODE),unix) +$(OUTPUT_DLL): $(OBJECTS) $(SPEC_FILE) | $(OUTDIR) + @echo "LINK (Unix PE): $@" + @$(WINEGCC) -m64 -shared $(SPEC_FILE) $(OBJECTS) -o $@ $(LIBS) +endif + +# Link DLL (SysWoW64 mode) +ifeq ($(BUILD_MODE),syswow64) +$(OUTPUT_DLL): $(OBJECTS) $(OUTDIR)/version.o | $(OUTDIR) + @echo "LINK (SysWoW64): $@" + @$(CC) $(LDFLAGS) -o $@ $(OBJECTS) $(OUTDIR)/version.o $(LIBS) \ + -Wl,--out-implib,$(OUTDIR)/libd2d1.a +endif + +# Clean +clean: + @echo "Cleaning build artifacts..." + @rm -rf $(BUILDDIR) + +# Show configuration +config: + @echo "Build Configuration:" + @echo " TARGET: $(TARGET)" + @echo " CC: $(CC)" + @echo " WIDL: $(WIDL)" + @echo " BUILD_MODE: $(BUILD_MODE)" + @echo " ARCH: $(ARCH)" + @echo " OUTPUT: $(OUTPUT_DLL)" diff --git a/WineFix/lib/d2d1/README.md b/WineFix/lib/d2d1/README.md new file mode 100644 index 0000000..f3d5a29 --- /dev/null +++ b/WineFix/lib/d2d1/README.md @@ -0,0 +1,53 @@ +# D2D1.DLL Standalone Build + +This repository contains a standalone build system for `d2d1.dll` extracted from Wine 10.18 with changes applied for the WineFix plugin project. This standalone source is provided to allow building the Direct2D implementation without requiring the full Wine source. + +This source includes modifications compared to upstream Wine: +- **geometry.c**: implement support for drawing cubic beziers using a subdivision algorithm to approximate cubic beziers using multiple quadratic beziers + +The native Unix output is distributed with WineFix. + +## Supported Targets + +- **x86_64-unix**: 64-bit Unix PE format (for Wine) +- **x86_64-windows**: 64-bit native Windows +- **i386-windows**: 32-bit native Windows +- **syswow64**: 32-bit for SysWoW64 mode (64-bit Windows running 32-bit apps) + +## License + +Code extracted from Wine and all modifications to the code as described above are licensed under the GNU Lesser General Public License (LGPL) version 2.1 or later. A copy of the license is provided in the LICENSE file. + +## Source + +Original source of Wine 10.18: + +The relevant files are under `dlls/d2d1/` in each repository. + +## Build System Details + +### Makefile Targets + +- `all` - Build default target (x86_64-unix) +- `x86_64-unix` - Build 64-bit Unix PE +- `x86_64-windows` - Build 64-bit Windows +- `i386-windows` - Build 32-bit Windows +- `syswow64` - Build SysWoW64 mode +- `clean` - Clean all build artifacts +- `config` - Show current build configuration +- `help` - Show help message + +### Environment Variables + +You can customize the build by setting these variables: + +```bash +# Use a different compiler +make CC=clang TARGET=x86_64-windows + +# Add custom flags +make CFLAGS="-O3 -march=native" TARGET=x86_64-windows + +# Use custom Wine tools +make WIDL=/custom/path/widl WINEGCC=/custom/path/winegcc TARGET=x86_64-unix +``` diff --git a/WineFix/lib/d2d1/VERSION b/WineFix/lib/d2d1/VERSION new file mode 100644 index 0000000..ee34e05 --- /dev/null +++ b/WineFix/lib/d2d1/VERSION @@ -0,0 +1 @@ +Wine Version: 10.18 diff --git a/WineFix/lib/d2d1/build-all.sh b/WineFix/lib/d2d1/build-all.sh new file mode 100755 index 0000000..541e882 --- /dev/null +++ b/WineFix/lib/d2d1/build-all.sh @@ -0,0 +1,84 @@ +#!/bin/bash +# Build d2d1.dll for all supported targets + +set -e + +echo "======================================" +echo "D2D1.DLL - Build All Targets" +echo "======================================" +echo "" + +# Function to build a target +build_target() { + local target=$1 + echo "Building for: $target" + echo "--------------------------------------" + make TARGET=$target + echo "" +} + +# Check for required tools +check_tools() { + echo "Checking for required tools..." + local missing_tools=() + + for tool in x86_64-w64-mingw32-gcc i686-w64-mingw32-gcc widl; do + if ! command -v $tool &> /dev/null; then + missing_tools+=($tool) + fi + done + + if [ ${#missing_tools[@]} -ne 0 ]; then + echo "ERROR: Missing required tools:" + for tool in "${missing_tools[@]}"; do + echo " - $tool" + done + echo "" + echo "Please install:" + echo " - mingw-w64 toolchain (for cross-compilation)" + echo " - wine-devel or wine-tools (for widl)" + exit 1 + fi + + echo "All required tools found!" + echo "" +} + +# Check tools first +check_tools + +# Clean all build artifacts first +echo "Cleaning all build artifacts..." +make clean +echo "" + +# Build all targets +build_target "x86_64-windows" +build_target "i386-windows" + +# Try to build Unix PE if winegcc is available +if command -v winegcc &> /dev/null; then + echo "Building for: x86_64-unix" + echo "--------------------------------------" + if make TARGET=x86_64-unix; then + echo "" + else + echo "Warning: x86_64-unix build failed (this is optional)" + echo "" + fi +else + echo "Skipping x86_64-unix: winegcc not found" + echo "Install wine-devel to build Unix PE format" + echo "" +fi + +# Build SysWoW64 +build_target "syswow64" + +echo "======================================" +echo "Build Summary" +echo "======================================" +echo "Built DLLs:" +find build -name "*.dll*" -type f +echo "" +echo "All builds complete!" diff --git a/WineFix/lib/d2d1/build-cmake.sh b/WineFix/lib/d2d1/build-cmake.sh new file mode 100755 index 0000000..fb00741 --- /dev/null +++ b/WineFix/lib/d2d1/build-cmake.sh @@ -0,0 +1,36 @@ +#!/bin/bash +# Build d2d1.dll using CMake + +set -e + +TARGET_ARCH="${1:-x86_64}" +BUILD_TYPE="${2:-Release}" + +echo "======================================" +echo "D2D1.DLL - CMake Build" +echo "======================================" +echo "Architecture: $TARGET_ARCH" +echo "Build Type: $BUILD_TYPE" +echo "" + +# Create build directory +BUILD_DIR="build-cmake-${TARGET_ARCH}" +mkdir -p "$BUILD_DIR" +cd "$BUILD_DIR" + +# Configure with CMake +echo "Configuring..." +cmake .. \ + -DCMAKE_BUILD_TYPE=$BUILD_TYPE \ + -DTARGET_ARCH=$TARGET_ARCH + +# Build +echo "" +echo "Building..." +cmake --build . -- -j$(nproc) + +echo "" +echo "======================================" +echo "Build complete!" +echo "Output: $BUILD_DIR/d2d1.dll" +echo "======================================" diff --git a/WineFix/lib/d2d1/include/windows/d2d1.idl b/WineFix/lib/d2d1/include/windows/d2d1.idl new file mode 100644 index 0000000..dcc1a53 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1.idl @@ -0,0 +1,1259 @@ +/* + * Copyright 2013 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "unknwn.idl"; +import "dcommon.idl"; +import "d3d10_1.idl"; +import "d2derr.h"; + +cpp_quote("#ifdef WINE_NO_UNICODE_MACROS") +cpp_quote("#undef DrawText") +cpp_quote("#endif") + +interface ID2D1Factory; +interface ID2D1RenderTarget; +interface ID2D1BitmapRenderTarget; +interface ID2D1Geometry; +interface ID2D1Brush; +interface IDWriteRenderingParams; +interface IDWriteTextFormat; +interface IDWriteTextLayout; +interface IWICBitmapSource; +interface IWICBitmap; + +cpp_quote("#ifndef __dwrite_h__") +/* already defined in dwrite.h but needed for WIDL */ +typedef struct DWRITE_GLYPH_RUN DWRITE_GLYPH_RUN; +cpp_quote("#endif /* __dwrite_h__ */") + +typedef D2D_MATRIX_3X2_F D2D1_MATRIX_3X2_F; +typedef D2D_RECT_F D2D1_RECT_F; +typedef D2D_SIZE_F D2D1_SIZE_F; +typedef UINT64 D2D1_TAG; +typedef D2D_POINT_2U D2D1_POINT_2U; +typedef D2D_RECT_U D2D1_RECT_U; +typedef D2D_COLOR_F D2D1_COLOR_F; + +cpp_quote("#define D2D1_DEFAULT_FLATTENING_TOLERANCE (0.25f)") + +enum +{ + D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR = 0, + D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR = 1, + D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC = 2, + D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR = 3, + D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC = 4, + D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC = 5, + D2D1_INTERPOLATION_MODE_DEFINITION_FANT = 6, + D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR = 7, +}; + +typedef enum D2D1_DEBUG_LEVEL +{ + D2D1_DEBUG_LEVEL_NONE = 0, + D2D1_DEBUG_LEVEL_ERROR = 1, + D2D1_DEBUG_LEVEL_WARNING = 2, + D2D1_DEBUG_LEVEL_INFORMATION = 3, + D2D1_DEBUG_LEVEL_FORCE_DWORD = 0xffffffff, +} D2D1_DEBUG_LEVEL; + +typedef enum D2D1_FACTORY_TYPE +{ + D2D1_FACTORY_TYPE_SINGLE_THREADED = 0, + D2D1_FACTORY_TYPE_MULTI_THREADED = 1, + D2D1_FACTORY_TYPE_FORCE_DWORD = 0xfffffff, +} D2D1_FACTORY_TYPE; + +typedef enum D2D1_FILL_MODE +{ + D2D1_FILL_MODE_ALTERNATE = 0, + D2D1_FILL_MODE_WINDING = 1, + D2D1_FILL_MODE_FORCE_DWORD = 0xffffffff +} D2D1_FILL_MODE; + +typedef enum D2D1_PATH_SEGMENT +{ + D2D1_PATH_SEGMENT_NONE = 0, + D2D1_PATH_SEGMENT_FORCE_UNSTROKED = 1, + D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN = 2, + D2D1_PATH_SEGMENT_FORCE_DWORD = 0xffffffff +} D2D1_PATH_SEGMENT; + +typedef enum D2D1_FIGURE_BEGIN +{ + D2D1_FIGURE_BEGIN_FILLED = 0, + D2D1_FIGURE_BEGIN_HOLLOW = 1, + D2D1_FIGURE_BEGIN_FORCE_DWORD = 0xffffffff +} D2D1_FIGURE_BEGIN; + +typedef enum D2D1_FIGURE_END +{ + D2D1_FIGURE_END_OPEN = 0, + D2D1_FIGURE_END_CLOSED = 1, + D2D1_FIGURE_END_FORCE_DWORD = 0xffffffff +} D2D1_FIGURE_END; + +typedef enum D2D1_CAP_STYLE +{ + D2D1_CAP_STYLE_FLAT = 0, + D2D1_CAP_STYLE_SQUARE = 1, + D2D1_CAP_STYLE_ROUND = 2, + D2D1_CAP_STYLE_TRIANGLE = 3, + D2D1_CAP_STYLE_FORCE_DWORD = 0xffffffff, +} D2D1_CAP_STYLE; + +typedef enum D2D1_LINE_JOIN +{ + D2D1_LINE_JOIN_MITER = 0, + D2D1_LINE_JOIN_BEVEL = 1, + D2D1_LINE_JOIN_ROUND = 2, + D2D1_LINE_JOIN_MITER_OR_BEVEL = 3, + D2D1_LINE_JOIN_FORCE_DWORD = 0xffffffff, +} D2D1_LINE_JOIN; + +typedef enum D2D1_DASH_STYLE +{ + D2D1_DASH_STYLE_SOLID = 0, + D2D1_DASH_STYLE_DASH = 1, + D2D1_DASH_STYLE_DOT = 2, + D2D1_DASH_STYLE_DASH_DOT = 3, + D2D1_DASH_STYLE_DASH_DOT_DOT = 4, + D2D1_DASH_STYLE_CUSTOM = 5, + D2D1_DASH_STYLE_FORCE_DWORD = 0xffffffff, +} D2D1_DASH_STYLE; + +typedef enum D2D1_GEOMETRY_RELATION +{ + D2D1_GEOMETRY_RELATION_UNKNOWN = 0, + D2D1_GEOMETRY_RELATION_DISJOINT = 1, + D2D1_GEOMETRY_RELATION_IS_CONTAINED = 2, + D2D1_GEOMETRY_RELATION_CONTAINS = 3, + D2D1_GEOMETRY_RELATION_OVERLAP = 4, + D2D1_GEOMETRY_RELATION_FORCE_DWORD = 0xffffffff, +} D2D1_GEOMETRY_RELATION; + +typedef enum D2D1_GEOMETRY_SIMPLIFICATION_OPTION +{ + D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES = 0, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES = 1, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION_FORCE_DWORD = 0xffffffff, +} D2D1_GEOMETRY_SIMPLIFICATION_OPTION; + +typedef enum D2D1_COMBINE_MODE +{ + D2D1_COMBINE_MODE_UNION = 0, + D2D1_COMBINE_MODE_INTERSECT = 1, + D2D1_COMBINE_MODE_XOR = 2, + D2D1_COMBINE_MODE_EXCLUDE = 3, + D2D1_COMBINE_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COMBINE_MODE; + +typedef enum D2D1_SWEEP_DIRECTION +{ + D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE = 0, + D2D1_SWEEP_DIRECTION_CLOCKWISE = 1, + D2D1_SWEEP_DIRECTION_FORCE_DWORD = 0xffffffff, +} D2D1_SWEEP_DIRECTION; + +typedef enum D2D1_ARC_SIZE +{ + D2D1_ARC_SIZE_SMALL = 0, + D2D1_ARC_SIZE_LARGE = 1, + D2D1_ARC_SIZE_FORCE_DWORD = 0xffffffff, +} D2D1_ARC_SIZE; + +typedef enum D2D1_ANTIALIAS_MODE +{ + D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = 0, + D2D1_ANTIALIAS_MODE_ALIASED = 1, + D2D1_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_ANTIALIAS_MODE; + +typedef enum D2D1_TEXT_ANTIALIAS_MODE +{ + D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = 0, + D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = 1, + D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = 2, + D2D1_TEXT_ANTIALIAS_MODE_ALIASED = 3, + D2D1_TEXT_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_TEXT_ANTIALIAS_MODE; + +typedef enum D2D1_EXTEND_MODE +{ + D2D1_EXTEND_MODE_CLAMP = 0, + D2D1_EXTEND_MODE_WRAP = 1, + D2D1_EXTEND_MODE_MIRROR = 2, + D2D1_EXTEND_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_EXTEND_MODE; + +typedef enum D2D1_BITMAP_INTERPOLATION_MODE +{ + D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR, + D2D1_BITMAP_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR, + D2D1_BITMAP_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_BITMAP_INTERPOLATION_MODE; + +typedef enum D2D1_GAMMA +{ + D2D1_GAMMA_2_2 = 0, + D2D1_GAMMA_1_0 = 1, + D2D1_GAMMA_FORCE_DWORD = 0xffffffff, +} D2D1_GAMMA; + +typedef enum D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS +{ + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE = 0x00000000, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE = 0x00000001, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS; + +typedef enum D2D1_OPACITY_MASK_CONTENT +{ + D2D1_OPACITY_MASK_CONTENT_GRAPHICS = 0, + D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL = 1, + D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE = 2, + D2D1_OPACITY_MASK_CONTENT_FORCE_DWORD = 0xffffffff, +} D2D1_OPACITY_MASK_CONTENT; + +typedef enum D2D1_DRAW_TEXT_OPTIONS +{ + D2D1_DRAW_TEXT_OPTIONS_NO_SNAP = 0x00000001, + D2D1_DRAW_TEXT_OPTIONS_CLIP = 0x00000002, + D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT = 0x00000004, + D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING = 0x00000008, + D2D1_DRAW_TEXT_OPTIONS_NONE = 0x00000000, + D2D1_DRAW_TEXT_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_DRAW_TEXT_OPTIONS; + +typedef enum D2D1_LAYER_OPTIONS +{ + D2D1_LAYER_OPTIONS_NONE = 0x00000000, + D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE = 0x00000001, + D2D1_LAYER_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_LAYER_OPTIONS; + +typedef enum D2D1_RENDER_TARGET_TYPE +{ + D2D1_RENDER_TARGET_TYPE_DEFAULT = 0, + D2D1_RENDER_TARGET_TYPE_SOFTWARE = 1, + D2D1_RENDER_TARGET_TYPE_HARDWARE = 2, + D2D1_RENDER_TARGET_TYPE_FORCE_DWORD = 0xffffffff, +} D2D1_RENDER_TARGET_TYPE; + +typedef enum D2D1_RENDER_TARGET_USAGE +{ + D2D1_RENDER_TARGET_USAGE_NONE = 0x00000000, + D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING = 0x00000001, + D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE = 0x00000002, + D2D1_RENDER_TARGET_USAGE_FORCE_DWORD = 0xffffffff, +} D2D1_RENDER_TARGET_USAGE; + +typedef enum D2D1_FEATURE_LEVEL +{ + D2D1_FEATURE_LEVEL_DEFAULT = 0, + D2D1_FEATURE_LEVEL_9 = D3D_FEATURE_LEVEL_9_1, + D2D1_FEATURE_LEVEL_10 = D3D_FEATURE_LEVEL_10_0, + D2D1_FEATURE_LEVEL_FORCE_DWORD = 0xffffffff, +} D2D1_FEATURE_LEVEL; + +typedef enum D2D1_WINDOW_STATE +{ + D2D1_WINDOW_STATE_NONE = 0, + D2D1_WINDOW_STATE_OCCLUDED = 1, + D2D1_WINDOW_STATE_FORCE_DWORD = 0xffffffff, +} D2D1_WINDOW_STATE; + +typedef enum D2D1_DC_INITIALIZE_MODE +{ + D2D1_DC_INITIALIZE_MODE_COPY = 0, + D2D1_DC_INITIALIZE_MODE_CLEAR = 1, + D2D1_DC_INITIALIZE_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_DC_INITIALIZE_MODE; + +typedef enum D2D1_PRESENT_OPTIONS +{ + D2D1_PRESENT_OPTIONS_NONE = 0x00000000, + D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS = 0x00000001, + D2D1_PRESENT_OPTIONS_IMMEDIATELY = 0x00000002, + D2D1_PRESENT_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_PRESENT_OPTIONS; + +typedef struct D2D1_BEZIER_SEGMENT +{ + D2D1_POINT_2F point1; + D2D1_POINT_2F point2; + D2D1_POINT_2F point3; +} D2D1_BEZIER_SEGMENT; + +typedef struct D2D1_FACTORY_OPTIONS +{ + D2D1_DEBUG_LEVEL debugLevel; +} D2D1_FACTORY_OPTIONS; + +typedef struct D2D1_TRIANGLE +{ + D2D1_POINT_2F point1; + D2D1_POINT_2F point2; + D2D1_POINT_2F point3; +} D2D1_TRIANGLE; + +typedef struct D2D1_ROUNDED_RECT +{ + D2D1_RECT_F rect; + float radiusX; + float radiusY; +} D2D1_ROUNDED_RECT; + +typedef struct D2D1_ELLIPSE +{ + D2D1_POINT_2F point; + float radiusX; + float radiusY; +} D2D1_ELLIPSE; + +typedef struct D2D1_QUADRATIC_BEZIER_SEGMENT +{ + D2D1_POINT_2F point1; + D2D1_POINT_2F point2; +} D2D1_QUADRATIC_BEZIER_SEGMENT; + +typedef struct D2D1_ARC_SEGMENT +{ + D2D1_POINT_2F point; + D2D1_SIZE_F size; + float rotationAngle; + D2D1_SWEEP_DIRECTION sweepDirection; + D2D1_ARC_SIZE arcSize; +} D2D1_ARC_SEGMENT; + +typedef struct D2D1_DRAWING_STATE_DESCRIPTION +{ + D2D1_ANTIALIAS_MODE antialiasMode; + D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode; + D2D1_TAG tag1; + D2D1_TAG tag2; + D2D1_MATRIX_3X2_F transform; +} D2D1_DRAWING_STATE_DESCRIPTION; + +typedef struct D2D1_GRADIENT_STOP +{ + float position; + D2D1_COLOR_F color; +} D2D1_GRADIENT_STOP; + +typedef struct D2D1_BITMAP_PROPERTIES +{ + D2D1_PIXEL_FORMAT pixelFormat; + float dpiX; + float dpiY; +} D2D1_BITMAP_PROPERTIES; + +typedef struct D2D1_BITMAP_BRUSH_PROPERTIES +{ + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_BITMAP_INTERPOLATION_MODE interpolationMode; +} D2D1_BITMAP_BRUSH_PROPERTIES; + +typedef struct D2D1_BRUSH_PROPERTIES +{ + float opacity; + D2D1_MATRIX_3X2_F transform; +} D2D1_BRUSH_PROPERTIES; + +typedef struct D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES +{ + D2D1_POINT_2F startPoint; + D2D1_POINT_2F endPoint; +} D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES; + +typedef struct D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES +{ + D2D1_POINT_2F center; + D2D1_POINT_2F gradientOriginOffset; + float radiusX; + float radiusY; +} D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES; + +typedef struct D2D1_LAYER_PARAMETERS +{ + D2D1_RECT_F contentBounds; + ID2D1Geometry *geometricMask; + D2D1_ANTIALIAS_MODE maskAntialiasMode; + D2D1_MATRIX_3X2_F maskTransform; + float opacity; + ID2D1Brush *opacityBrush; + D2D1_LAYER_OPTIONS layerOptions; +} D2D1_LAYER_PARAMETERS; + +typedef struct D2D1_RENDER_TARGET_PROPERTIES +{ + D2D1_RENDER_TARGET_TYPE type; + D2D1_PIXEL_FORMAT pixelFormat; + float dpiX; + float dpiY; + D2D1_RENDER_TARGET_USAGE usage; + D2D1_FEATURE_LEVEL minLevel; +} D2D1_RENDER_TARGET_PROPERTIES; + +typedef struct D2D1_STROKE_STYLE_PROPERTIES +{ + D2D1_CAP_STYLE startCap; + D2D1_CAP_STYLE endCap; + D2D1_CAP_STYLE dashCap; + D2D1_LINE_JOIN lineJoin; + float miterLimit; + D2D1_DASH_STYLE dashStyle; + float dashOffset; +} D2D1_STROKE_STYLE_PROPERTIES; + +typedef struct D2D1_HWND_RENDER_TARGET_PROPERTIES +{ + HWND hwnd; + D2D1_SIZE_U pixelSize; + D2D1_PRESENT_OPTIONS presentOptions; +} D2D1_HWND_RENDER_TARGET_PROPERTIES; + +[ + local, + object, + uuid(2cd90691-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1Resource : IUnknown +{ + void GetFactory( + [out] ID2D1Factory **factory + ); +} + +[ + local, + object, + uuid(2cd9069d-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1StrokeStyle : ID2D1Resource +{ + D2D1_CAP_STYLE GetStartCap(); + D2D1_CAP_STYLE GetEndCap(); + D2D1_CAP_STYLE GetDashCap(); + float GetMiterLimit(); + D2D1_LINE_JOIN GetLineJoin(); + float GetDashOffset(); + D2D1_DASH_STYLE GetDashStyle(); + UINT32 GetDashesCount(); + void GetDashes( + [out, size_is(count)] float *dashes, + [in] UINT32 count + ); +} + +[ + local, + object, + uuid(2cd9069e-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1SimplifiedGeometrySink : IUnknown +{ + void SetFillMode(D2D1_FILL_MODE mode); + void SetSegmentFlags(D2D1_PATH_SEGMENT vertexFlags); + void BeginFigure(D2D1_POINT_2F startPoint, D2D1_FIGURE_BEGIN figureBegin); + void AddLines(const D2D1_POINT_2F *points, UINT32 count); + void AddBeziers(const D2D1_BEZIER_SEGMENT *beziers, UINT32 count); + void EndFigure(D2D1_FIGURE_END figureEnd); + HRESULT Close(); +} + +[ + local, + object, + uuid(2cd906c1-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1TessellationSink : IUnknown +{ + void AddTriangles( + [in, size_is(count)] const D2D1_TRIANGLE *triangles, + [in] UINT32 count + ); + HRESULT Close(); +} + +[ + local, + object, + uuid(2cd906a1-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1Geometry : ID2D1Resource +{ + HRESULT GetBounds( + [in] const D2D1_MATRIX_3X2_F *transform, + [out] D2D1_RECT_F *bounds + ); + HRESULT GetWidenedBounds( + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] D2D1_RECT_F *bounds + ); + HRESULT StrokeContainsPoint( + [in] D2D1_POINT_2F point, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] BOOL *contains + ); + HRESULT FillContainsPoint( + [in] D2D1_POINT_2F point, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] BOOL *contains + ); + HRESULT CompareWithGeometry( + [in] ID2D1Geometry *geometry, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] D2D1_GEOMETRY_RELATION *relation + ); + HRESULT Simplify( + [in] D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [in] ID2D1SimplifiedGeometrySink *sink + ); + HRESULT Tessellate( + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [in] ID2D1TessellationSink *sink + ); + HRESULT CombineWithGeometry( + [in] ID2D1Geometry *geometry, + [in] D2D1_COMBINE_MODE combine_mode, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [in] ID2D1SimplifiedGeometrySink *sink + ); + HRESULT Outline( + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [in] ID2D1SimplifiedGeometrySink *sink + ); + HRESULT ComputeArea( + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] float *area + ); + HRESULT ComputeLength( + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] float *length + ); + HRESULT ComputePointAtLength( + [in] float length, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] D2D1_POINT_2F *point, + [out] D2D1_POINT_2F *tangent + ); + HRESULT Widen( + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style, + [in] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [in] ID2D1SimplifiedGeometrySink *sink + ); +} + +[ + local, + object, + uuid(2cd906a2-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1RectangleGeometry : ID2D1Geometry +{ + void GetRect( + [out] D2D1_RECT_F *rect + ); +} + +[ + local, + object, + uuid(2cd906a3-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1RoundedRectangleGeometry : ID2D1Geometry +{ + void GetRoundedRect( + [out] D2D1_ROUNDED_RECT *rect + ); +} + +[ + local, + object, + uuid(2cd906a4-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1EllipseGeometry : ID2D1Geometry +{ + void GetEllipse( + [out] D2D1_ELLIPSE *ellipse + ); +} + +[ + local, + object, + uuid(2cd906a6-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1GeometryGroup : ID2D1Geometry +{ + D2D1_FILL_MODE GetFillMode(); + UINT32 GetSourceGeometryCount(); + void GetSourceGeometries( + [out, size_is(geometry_count)] ID2D1Geometry **geometry, + [in] UINT32 geometry_count + ); +} + +[ + local, + object, + uuid(2cd906bb-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1TransformedGeometry : ID2D1Geometry +{ + void GetSourceGeometry( + [out] ID2D1Geometry **geometry + ); + void GetTransform( + [out] D2D1_MATRIX_3X2_F *transform + ); +} + +[ + local, + object, + uuid(2cd9069f-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1GeometrySink : ID2D1SimplifiedGeometrySink +{ + void AddLine( + [in] D2D1_POINT_2F point + ); + void AddBezier( + [in] const D2D1_BEZIER_SEGMENT *bezier + ); + void AddQuadraticBezier( + [in] const D2D1_QUADRATIC_BEZIER_SEGMENT *bezier + ); + void AddQuadraticBeziers( + [in, size_is(bezier_count)] const D2D1_QUADRATIC_BEZIER_SEGMENT *beziers, + [in] UINT32 bezier_count + ); + void AddArc( + [in] const D2D1_ARC_SEGMENT *arc + ); +} + +[ + local, + object, + uuid(2cd906a5-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1PathGeometry : ID2D1Geometry +{ + HRESULT Open( + [out] ID2D1GeometrySink **sink + ); + HRESULT Stream( + [in] ID2D1GeometrySink *sink + ); + HRESULT GetSegmentCount( + [out] UINT32 *count + ); + HRESULT GetFigureCount( + [out] UINT32 *count + ); +} + +[ + local, + object, + uuid(28506e39-ebf6-46a1-bb47-fd85565ab957) +] +interface ID2D1DrawingStateBlock : ID2D1Resource +{ + void GetDescription( + [out] D2D1_DRAWING_STATE_DESCRIPTION *desc + ); + void SetDescription( + [in] const D2D1_DRAWING_STATE_DESCRIPTION *desc + ); + void SetTextRenderingParams( + [in] IDWriteRenderingParams *text_rendering_params + ); + void GetTextRenderingParams( + [out] IDWriteRenderingParams **text_rendering_params + ); +} + +[ + local, + object, + uuid(65019f75-8da2-497c-b32c-dfa34e48ede6) +] +interface ID2D1Image : ID2D1Resource +{ +} + +[ + local, + object, + uuid(a2296057-ea42-4099-983b-539fb6505426) +] +interface ID2D1Bitmap : ID2D1Image +{ + D2D1_SIZE_F GetSize(); + D2D1_SIZE_U GetPixelSize(); + D2D1_PIXEL_FORMAT GetPixelFormat(); + void GetDpi( + [out] float *dpi_x, + [out] float *dpi_y + ); + HRESULT CopyFromBitmap( + [in] const D2D1_POINT_2U *dst_point, + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_U *src_rect + ); + HRESULT CopyFromRenderTarget( + [in] const D2D1_POINT_2U *dst_point, + [in] ID2D1RenderTarget *render_target, + [in] const D2D1_RECT_U *src_rect + ); + HRESULT CopyFromMemory( + [in] const D2D1_RECT_U *dst_rect, + [in] const void *src_data, + [in] UINT32 pitch + ); +} + +[ + local, + object, + uuid(2cd906a8-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1Brush : ID2D1Resource +{ + void SetOpacity( + [in] float opacity + ); + void SetTransform( + [in] const D2D1_MATRIX_3X2_F *transform + ); + float GetOpacity(); + void GetTransform( + [out] D2D1_MATRIX_3X2_F *transform + ); +} + +[ + local, + object, + uuid(2cd906aa-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1BitmapBrush : ID2D1Brush +{ + void SetExtendModeX( + [in] D2D1_EXTEND_MODE mode + ); + void SetExtendModeY( + [in] D2D1_EXTEND_MODE mode + ); + void SetInterpolationMode( + [in] D2D1_BITMAP_INTERPOLATION_MODE mode + ); + void SetBitmap( + [in] ID2D1Bitmap *bitmap + ); + D2D1_EXTEND_MODE GetExtendModeX(); + D2D1_EXTEND_MODE GetExtendModeY(); + D2D1_BITMAP_INTERPOLATION_MODE GetInterpolationMode(); + void GetBitmap( + [out] ID2D1Bitmap **bitmap + ); +} + +[ + local, + object, + uuid(2cd906a9-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1SolidColorBrush : ID2D1Brush +{ + void SetColor( + [in] const D2D1_COLOR_F *color + ); + D2D1_COLOR_F GetColor(); +} + +[ + local, + object, + uuid(2cd906a7-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1GradientStopCollection : ID2D1Resource +{ + UINT32 GetGradientStopCount(); + void GetGradientStops( + [out] D2D1_GRADIENT_STOP *stops, + [in] UINT32 stop_count + ); + D2D1_GAMMA GetColorInterpolationGamma(); + D2D1_EXTEND_MODE GetExtendMode(); +} + +[ + local, + object, + uuid(2cd906ab-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1LinearGradientBrush : ID2D1Brush +{ + void SetStartPoint( + [in] D2D1_POINT_2F start_point + ); + void SetEndPoint( + [in] D2D1_POINT_2F end_point + ); + D2D1_POINT_2F GetStartPoint(); + D2D1_POINT_2F GetEndPoint(); + void GetGradientStopCollection( + [out] ID2D1GradientStopCollection **gradient + ); +} + +[ + local, + object, + uuid(2cd906ac-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1RadialGradientBrush : ID2D1Brush +{ + void SetCenter( + [in] D2D1_POINT_2F center + ); + void SetGradientOriginOffset( + [in] D2D1_POINT_2F offset + ); + void SetRadiusX( + [in] float radius + ); + void SetRadiusY( + [in] float radius + ); + D2D1_POINT_2F GetCenter(); + D2D1_POINT_2F GetGradientOriginOffset(); + float GetRadiusX(); + float GetRadiusY(); + void GetGradientStopCollection( + [out] ID2D1GradientStopCollection **gradient + ); +} + +[ + local, + object, + uuid(2cd9069b-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1Layer : ID2D1Resource +{ + D2D1_SIZE_F GetSize(); +} + +[ + local, + object, + uuid(2cd906c2-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1Mesh : ID2D1Resource +{ + HRESULT Open( + [out] ID2D1TessellationSink **sink + ); +} + +[ + local, + object, + uuid(2cd90694-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1RenderTarget : ID2D1Resource +{ + HRESULT CreateBitmap( + [in] D2D1_SIZE_U size, + [in] const void *src_data, + [in] UINT32 pitch, + [in] const D2D1_BITMAP_PROPERTIES *desc, + [out] ID2D1Bitmap **bitmap + ); + HRESULT CreateBitmapFromWicBitmap( + [in] IWICBitmapSource *bitmap_source, + [in] const D2D1_BITMAP_PROPERTIES *desc, + [out] ID2D1Bitmap **bitmap + ); + HRESULT CreateSharedBitmap( + [in] REFIID iid, + [in, out] void *data, + [in] const D2D1_BITMAP_PROPERTIES *desc, + [out] ID2D1Bitmap **bitmap + ); + HRESULT CreateBitmapBrush( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1BitmapBrush **brush + ); + HRESULT CreateSolidColorBrush( + [in] const D2D1_COLOR_F *color, + [in] const D2D1_BRUSH_PROPERTIES *desc, + [out] ID2D1SolidColorBrush **brush + ); + HRESULT CreateGradientStopCollection( + [in, size_is(stop_count)] const D2D1_GRADIENT_STOP *stops, + [in] UINT32 stop_count, + [in] D2D1_GAMMA gamma, + [in] D2D1_EXTEND_MODE extend_mode, + [out] ID2D1GradientStopCollection **gradient + ); + HRESULT CreateLinearGradientBrush( + [in] const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [in] ID2D1GradientStopCollection *gradient, + [out] ID2D1LinearGradientBrush **brush + ); + HRESULT CreateRadialGradientBrush( + [in] const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [in] ID2D1GradientStopCollection *gradient, + [out] ID2D1RadialGradientBrush **brush + ); + HRESULT CreateCompatibleRenderTarget( + [in] const D2D1_SIZE_F *size, + [in] const D2D1_SIZE_U *pixel_size, + [in] const D2D1_PIXEL_FORMAT *format, + [in] D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, + [out] ID2D1BitmapRenderTarget **render_target + ); + HRESULT CreateLayer( + [in] const D2D1_SIZE_F *size, + [out] ID2D1Layer **layer + ); + HRESULT CreateMesh( + [out] ID2D1Mesh **mesh + ); + void DrawLine( + [in] D2D1_POINT_2F p0, + [in] D2D1_POINT_2F p1, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + void DrawRectangle( + [in] const D2D1_RECT_F *rect, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + void FillRectangle( + [in] const D2D1_RECT_F *rect, + [in] ID2D1Brush *brush + ); + void DrawRoundedRectangle( + [in] const D2D1_ROUNDED_RECT *rect, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + void FillRoundedRectangle( + [in] const D2D1_ROUNDED_RECT *rect, + [in] ID2D1Brush *brush + ); + void DrawEllipse( + [in] const D2D1_ELLIPSE *ellipse, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + void FillEllipse( + [in] const D2D1_ELLIPSE *ellipse, + [in] ID2D1Brush *brush + ); + void DrawGeometry( + [in] ID2D1Geometry *geometry, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + void FillGeometry( + [in] ID2D1Geometry *geometry, + [in] ID2D1Brush *brush, + [in] ID2D1Brush *opacity_brush + ); + void FillMesh( + [in] ID2D1Mesh *mesh, + [in] ID2D1Brush *brush + ); + void FillOpacityMask( + [in] ID2D1Bitmap *mask, + [in] ID2D1Brush *brush, + [in] D2D1_OPACITY_MASK_CONTENT content, + [in] const D2D1_RECT_F *dst_rect, + [in] const D2D1_RECT_F *src_rect + ); + void DrawBitmap( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_F *dst_rect, + [in] float opacity, + [in] D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, + [in] const D2D1_RECT_F *src_rect + ); + void DrawText( + [in, size_is(string_len)] const WCHAR *string, + [in] UINT32 string_len, + [in] IDWriteTextFormat *text_format, + [in] const D2D1_RECT_F *layout_rect, + [in] ID2D1Brush *brush, + [in] D2D1_DRAW_TEXT_OPTIONS options, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + void DrawTextLayout( + [in] D2D1_POINT_2F origin, + [in] IDWriteTextLayout *layout, + [in] ID2D1Brush *brush, + [in] D2D1_DRAW_TEXT_OPTIONS options + ); + void DrawGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] ID2D1Brush *brush, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + void SetTransform( + [in] const D2D1_MATRIX_3X2_F *transform + ); + void GetTransform( + [out] D2D1_MATRIX_3X2_F *transform + ); + void SetAntialiasMode( + [in] D2D1_ANTIALIAS_MODE antialias_mode + ); + D2D1_ANTIALIAS_MODE GetAntialiasMode(); + void SetTextAntialiasMode( + [in] D2D1_TEXT_ANTIALIAS_MODE antialias_mode + ); + D2D1_TEXT_ANTIALIAS_MODE GetTextAntialiasMode(); + void SetTextRenderingParams( + [in] IDWriteRenderingParams *text_rendering_params + ); + void GetTextRenderingParams( + [out] IDWriteRenderingParams **text_rendering_params + ); + void SetTags( + [in] D2D1_TAG tag1, + [in] D2D1_TAG tag2 + ); + void GetTags( + [out] D2D1_TAG *tag1, + [out] D2D1_TAG *tag2 + ); + void PushLayer( + [in] const D2D1_LAYER_PARAMETERS *layer_parameters, + [in] ID2D1Layer *layer + ); + void PopLayer(); + HRESULT Flush( + [out] D2D1_TAG *tag1, + [out] D2D1_TAG *tag2 + ); + void SaveDrawingState( + [in, out] ID2D1DrawingStateBlock *state_block + ); + void RestoreDrawingState( + [in] ID2D1DrawingStateBlock *state_block + ); + void PushAxisAlignedClip( + [in] const D2D1_RECT_F *clip_rect, + [in] D2D1_ANTIALIAS_MODE antialias_mode + ); + void PopAxisAlignedClip(); + void Clear( + [in] const D2D1_COLOR_F *color + ); + void BeginDraw(); + HRESULT EndDraw( + [out] D2D1_TAG *tag1, + [out] D2D1_TAG *tag2 + ); + D2D1_PIXEL_FORMAT GetPixelFormat(); + void SetDpi( + [in] float dpi_x, + [in] float dpi_y + ); + void GetDpi( + [out] float *dpi_x, + [out] float *dpi_y + ); + D2D1_SIZE_F GetSize(); + D2D1_SIZE_U GetPixelSize(); + UINT32 GetMaximumBitmapSize(); + BOOL IsSupported( + [in] const D2D1_RENDER_TARGET_PROPERTIES *desc + ); +} + +[ + local, + object, + uuid(2cd90695-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1BitmapRenderTarget : ID2D1RenderTarget +{ + HRESULT GetBitmap( + [out] ID2D1Bitmap **bitmap + ); +} + +[ + local, + object, + uuid(2cd90698-12e2-11dc-9fed-001143a055f9) +] +interface ID2D1HwndRenderTarget : ID2D1RenderTarget +{ + D2D1_WINDOW_STATE CheckWindowState(); + HRESULT Resize( + [in] const D2D1_SIZE_U *size + ); + HWND GetHwnd(); +} + +[ + local, + object, + uuid(1c51bc64-de61-46fd-9899-63a5d8f03950) +] +interface ID2D1DCRenderTarget : ID2D1RenderTarget +{ + HRESULT BindDC( + [in] const HDC dc, + [in] const RECT *rect + ); +} + +[ + local, + object, + uuid(e0db51c3-6f77-4bae-b3d5-e47509b35838) +] +interface ID2D1GdiInteropRenderTarget : IUnknown +{ + HRESULT GetDC( + [in] D2D1_DC_INITIALIZE_MODE mode, + [out] HDC *dc + ); + HRESULT ReleaseDC( + [in] const RECT *update + ); +} + +[ + local, + object, + uuid(06152247-6f50-465a-9245-118bfd3b6007) +] +interface ID2D1Factory : IUnknown +{ + HRESULT ReloadSystemMetrics(); + void GetDesktopDpi( + [out] float *dpi_x, + [out] float *dpi_y + ); + HRESULT CreateRectangleGeometry( + [in] const D2D1_RECT_F *rect, + [out] ID2D1RectangleGeometry **geometry + ); + HRESULT CreateRoundedRectangleGeometry( + [in] const D2D1_ROUNDED_RECT *rect, + [out] ID2D1RoundedRectangleGeometry **geometry + ); + HRESULT CreateEllipseGeometry( + [in] const D2D1_ELLIPSE *ellipse, + [out] ID2D1EllipseGeometry **geometry + ); + HRESULT CreateGeometryGroup( + [in] D2D1_FILL_MODE fill_mode, + [in, size_is(geometry_count)] ID2D1Geometry **geometries, + [in] UINT32 geometry_count, + [out] ID2D1GeometryGroup **group + ); + HRESULT CreateTransformedGeometry( + [in] ID2D1Geometry *src_geometry, + [in] const D2D1_MATRIX_3X2_F *transform, + [out] ID2D1TransformedGeometry **transformed_geometry + ); + HRESULT CreatePathGeometry( + [out] ID2D1PathGeometry **geometry + ); + HRESULT CreateStrokeStyle( + [in] const D2D1_STROKE_STYLE_PROPERTIES *desc, + [in, size_is(dash_count)] const float *dashes, + [in] UINT32 dash_count, + [out] ID2D1StrokeStyle **stroke_style + ); + HRESULT CreateDrawingStateBlock( + [in] const D2D1_DRAWING_STATE_DESCRIPTION *desc, + [in] IDWriteRenderingParams *text_rendering_params, + [out] ID2D1DrawingStateBlock **state_block + ); + HRESULT CreateWicBitmapRenderTarget( + [in] IWICBitmap *target, + [in] const D2D1_RENDER_TARGET_PROPERTIES *desc, + [out] ID2D1RenderTarget **render_target + ); + HRESULT CreateHwndRenderTarget( + [in] const D2D1_RENDER_TARGET_PROPERTIES *desc, + [in] const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_rt_desc, + [out] ID2D1HwndRenderTarget **render_target + ); + HRESULT CreateDxgiSurfaceRenderTarget( + [in] IDXGISurface *surface, + [in] const D2D1_RENDER_TARGET_PROPERTIES *desc, + [out] ID2D1RenderTarget **render_target + ); + HRESULT CreateDCRenderTarget( + [in] const D2D1_RENDER_TARGET_PROPERTIES *desc, + [out] ID2D1DCRenderTarget **render_target + ); +} + +[local] HRESULT __stdcall D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type, REFIID iid, + const D2D1_FACTORY_OPTIONS *factory_options, void **factory); +[local] BOOL __stdcall D2D1InvertMatrix(D2D1_MATRIX_3X2_F *matrix); +[local] BOOL __stdcall D2D1IsMatrixInvertible(const D2D1_MATRIX_3X2_F *matrix); +[local] void __stdcall D2D1MakeRotateMatrix(float angle, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix); +[local] void __stdcall D2D1MakeSkewMatrix(float angle_x, float angle_y, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix); diff --git a/WineFix/lib/d2d1/include/windows/d2d1_1.idl b/WineFix/lib/d2d1/include/windows/d2d1_1.idl new file mode 100644 index 0000000..ea46fa9 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1_1.idl @@ -0,0 +1,985 @@ +/* + * Copyright 2017 Lucian Poston + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d2d1.idl"; +import "d2d1effects.idl"; + +interface ID2D1DeviceContext; +interface ID2D1Properties; +interface IPrintDocumentPackageTarget; +interface ID2D1PrintControl; +interface IWICImagingFactory; +interface IWICColorContext; +interface ID2D1ColorContext; +interface ID2D1Effect; +interface ID2D1BitmapBrush1; + +cpp_quote("#ifndef __dwrite_h__") +/* already defined in dwrite.h but needed for WIDL */ +typedef struct DWRITE_GLYPH_RUN_DESCRIPTION DWRITE_GLYPH_RUN_DESCRIPTION; +cpp_quote("#endif /* __dwrite_h__ */") +cpp_quote("#define D2D1_INVALID_PROPERTY_INDEX UINT_MAX") + +typedef enum D2D1_DEVICE_CONTEXT_OPTIONS +{ + D2D1_DEVICE_CONTEXT_OPTIONS_NONE = 0x0, + D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS = 0x1, + D2D1_DEVICE_CONTEXT_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_DEVICE_CONTEXT_OPTIONS; + +typedef enum D2D1_STROKE_TRANSFORM_TYPE +{ + D2D1_STROKE_TRANSFORM_TYPE_NORMAL = 0x0, + D2D1_STROKE_TRANSFORM_TYPE_FIXED = 0x1, + D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE = 0x2, + D2D1_STROKE_TRANSFORM_TYPE_FORCE_DWORD = 0xffffffff, +} D2D1_STROKE_TRANSFORM_TYPE; + +typedef enum D2D1_PRIMITIVE_BLEND +{ + D2D1_PRIMITIVE_BLEND_SOURCE_OVER = 0x0, + D2D1_PRIMITIVE_BLEND_COPY = 0x1, + D2D1_PRIMITIVE_BLEND_MIN = 0x2, + D2D1_PRIMITIVE_BLEND_ADD = 0x3, + D2D1_PRIMITIVE_BLEND_MAX = 0x4, + D2D1_PRIMITIVE_BLEND_FORCE_DWORD = 0xffffffff, +} D2D1_PRIMITIVE_BLEND; + +typedef enum D2D1_UNIT_MODE +{ + D2D1_UNIT_MODE_DIPS = 0x0, + D2D1_UNIT_MODE_PIXELS = 0x1, + D2D1_UNIT_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_UNIT_MODE; + +typedef enum D2D1_PRINT_FONT_SUBSET_MODE +{ + D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT = 0x0, + D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE = 0x1, + D2D1_PRINT_FONT_SUBSET_MODE_NONE = 0x2, + D2D1_PRINT_FONT_SUBSET_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_PRINT_FONT_SUBSET_MODE; + +typedef enum D2D1_COLOR_SPACE +{ + D2D1_COLOR_SPACE_CUSTOM = 0x0, + D2D1_COLOR_SPACE_SRGB = 0x1, + D2D1_COLOR_SPACE_SCRGB = 0x2, + D2D1_COLOR_SPACE_FORCE_DWORD = 0xffffffff, +} D2D1_COLOR_SPACE; + +typedef enum D2D1_BITMAP_OPTIONS +{ + D2D1_BITMAP_OPTIONS_NONE = 0x0, + D2D1_BITMAP_OPTIONS_TARGET = 0x1, + D2D1_BITMAP_OPTIONS_CANNOT_DRAW = 0x2, + D2D1_BITMAP_OPTIONS_CPU_READ = 0x4, + D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE = 0x8, + D2D1_BITMAP_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_BITMAP_OPTIONS; + +typedef enum D2D1_MAP_OPTIONS +{ + D2D1_MAP_OPTIONS_NONE = 0x0, + D2D1_MAP_OPTIONS_READ = 0x1, + D2D1_MAP_OPTIONS_WRITE = 0x2, + D2D1_MAP_OPTIONS_DISCARD = 0x4, + D2D1_MAP_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_MAP_OPTIONS; + +typedef enum D2D1_BUFFER_PRECISION +{ + D2D1_BUFFER_PRECISION_UNKNOWN = 0x0, + D2D1_BUFFER_PRECISION_8BPC_UNORM = 0x1, + D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB = 0x2, + D2D1_BUFFER_PRECISION_16BPC_UNORM = 0x3, + D2D1_BUFFER_PRECISION_16BPC_FLOAT = 0x4, + D2D1_BUFFER_PRECISION_32BPC_FLOAT = 0x5, + D2D1_BUFFER_PRECISION_FORCE_DWORD = 0xffffffff, +} D2D1_BUFFER_PRECISION; + +typedef enum D2D1_COLOR_INTERPOLATION_MODE +{ + D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT = 0x0, + D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED = 0x1, + D2D1_COLOR_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COLOR_INTERPOLATION_MODE; + +typedef enum D2D1_INTERPOLATION_MODE +{ + D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR, + D2D1_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR, + D2D1_INTERPOLATION_MODE_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC, + D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR, + D2D1_INTERPOLATION_MODE_ANISOTROPIC = D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC, + D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC, + D2D1_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_INTERPOLATION_MODE; + +typedef enum D2D1_COMPOSITE_MODE +{ + D2D1_COMPOSITE_MODE_SOURCE_OVER = 0x0, + D2D1_COMPOSITE_MODE_DESTINATION_OVER = 0x1, + D2D1_COMPOSITE_MODE_SOURCE_IN = 0x2, + D2D1_COMPOSITE_MODE_DESTINATION_IN = 0x3, + D2D1_COMPOSITE_MODE_SOURCE_OUT = 0x4, + D2D1_COMPOSITE_MODE_DESTINATION_OUT = 0x5, + D2D1_COMPOSITE_MODE_SOURCE_ATOP = 0x6, + D2D1_COMPOSITE_MODE_DESTINATION_ATOP = 0x7, + D2D1_COMPOSITE_MODE_XOR = 0x8, + D2D1_COMPOSITE_MODE_PLUS = 0x9, + D2D1_COMPOSITE_MODE_SOURCE_COPY = 0xa, + D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY = 0xb, + D2D1_COMPOSITE_MODE_MASK_INVERT = 0xc, + D2D1_COMPOSITE_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COMPOSITE_MODE; + +typedef enum D2D1_LAYER_OPTIONS1 +{ + D2D1_LAYER_OPTIONS1_NONE = 0x0, + D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND = 0x1, + D2D1_LAYER_OPTIONS1_IGNORE_ALPHA = 0x2, + D2D1_LAYER_OPTIONS1_FORCE_DWORD = 0xffffffff, +} D2D1_LAYER_OPTIONS1; + +struct D2D1_PROPERTY_BINDING; +typedef D2D_MATRIX_4X4_F D2D1_MATRIX_4X4_F; + +typedef enum D2D1_PROPERTY_TYPE +{ + D2D1_PROPERTY_TYPE_UNKNOWN = 0x0, + D2D1_PROPERTY_TYPE_STRING = 0x1, + D2D1_PROPERTY_TYPE_BOOL = 0x2, + D2D1_PROPERTY_TYPE_UINT32 = 0x3, + D2D1_PROPERTY_TYPE_INT32 = 0x4, + D2D1_PROPERTY_TYPE_FLOAT = 0x5, + D2D1_PROPERTY_TYPE_VECTOR2 = 0x6, + D2D1_PROPERTY_TYPE_VECTOR3 = 0x7, + D2D1_PROPERTY_TYPE_VECTOR4 = 0x8, + D2D1_PROPERTY_TYPE_BLOB = 0x9, + D2D1_PROPERTY_TYPE_IUNKNOWN = 0xa, + D2D1_PROPERTY_TYPE_ENUM = 0xb, + D2D1_PROPERTY_TYPE_ARRAY = 0xc, + D2D1_PROPERTY_TYPE_CLSID = 0xd, + D2D1_PROPERTY_TYPE_MATRIX_3X2 = 0xe, + D2D1_PROPERTY_TYPE_MATRIX_4X3 = 0xf, + D2D1_PROPERTY_TYPE_MATRIX_4X4 = 0x10, + D2D1_PROPERTY_TYPE_MATRIX_5X4 = 0x11, + D2D1_PROPERTY_TYPE_COLOR_CONTEXT = 0x12, + D2D1_PROPERTY_TYPE_FORCE_DWORD = 0xffffffff, +} D2D1_PROPERTY_TYPE; + +typedef enum D2D1_PROPERTY +{ + D2D1_PROPERTY_CLSID = 0x80000000, + D2D1_PROPERTY_DISPLAYNAME = 0x80000001, + D2D1_PROPERTY_AUTHOR = 0x80000002, + D2D1_PROPERTY_CATEGORY = 0x80000003, + D2D1_PROPERTY_DESCRIPTION = 0x80000004, + D2D1_PROPERTY_INPUTS = 0x80000005, + D2D1_PROPERTY_CACHED = 0x80000006, + D2D1_PROPERTY_PRECISION = 0x80000007, + D2D1_PROPERTY_MIN_INPUTS = 0x80000008, + D2D1_PROPERTY_MAX_INPUTS = 0x80000009, + D2D1_PROPERTY_FORCE_DWORD = 0xffffffff +} D2D1_PROPERTY; + +typedef enum D2D1_SUBPROPERTY +{ + D2D1_SUBPROPERTY_DISPLAYNAME = 0x80000000, + D2D1_SUBPROPERTY_ISREADONLY = 0x80000001, + D2D1_SUBPROPERTY_MIN = 0x80000002, + D2D1_SUBPROPERTY_MAX = 0x80000003, + D2D1_SUBPROPERTY_DEFAULT = 0x80000004, + D2D1_SUBPROPERTY_FIELDS = 0x80000005, + D2D1_SUBPROPERTY_INDEX = 0x80000006, + D2D1_SUBPROPERTY_FORCE_DWORD = 0xffffffff +} D2D1_SUBPROPERTY; + +typedef enum D2D1_THREADING_MODE +{ + D2D1_THREADING_MODE_SINGLE_THREADED = D2D1_FACTORY_TYPE_SINGLE_THREADED, + D2D1_THREADING_MODE_MULTI_THREADED = D2D1_FACTORY_TYPE_MULTI_THREADED, + D2D1_THREADING_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_THREADING_MODE; + +typedef struct D2D1_CREATION_PROPERTIES +{ + D2D1_THREADING_MODE threadingMode; + D2D1_DEBUG_LEVEL debugLevel; + D2D1_DEVICE_CONTEXT_OPTIONS options; +} D2D1_CREATION_PROPERTIES; + +typedef struct D2D1_STROKE_STYLE_PROPERTIES1 +{ + D2D1_CAP_STYLE startCap; + D2D1_CAP_STYLE endCap; + D2D1_CAP_STYLE dashCap; + D2D1_LINE_JOIN lineJoin; + float miterLimit; + D2D1_DASH_STYLE dashStyle; + float dashOffset; + D2D1_STROKE_TRANSFORM_TYPE transformType; +} D2D1_STROKE_STYLE_PROPERTIES1; + +typedef struct D2D1_DRAWING_STATE_DESCRIPTION1 +{ + D2D1_ANTIALIAS_MODE antialiasMode; + D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode; + D2D1_TAG tag1; + D2D1_TAG tag2; + D2D1_MATRIX_3X2_F transform; + D2D1_PRIMITIVE_BLEND primitiveBlend; + D2D1_UNIT_MODE unitMode; +} D2D1_DRAWING_STATE_DESCRIPTION1; + +typedef struct D2D1_PRINT_CONTROL_PROPERTIES +{ + D2D1_PRINT_FONT_SUBSET_MODE fontSubset; + float rasterDPI; + D2D1_COLOR_SPACE colorSpace; +} D2D1_PRINT_CONTROL_PROPERTIES; + +typedef struct D2D1_MAPPED_RECT +{ + UINT32 pitch; + BYTE *bits; +} D2D1_MAPPED_RECT; + +typedef struct D2D1_BITMAP_PROPERTIES1 +{ + D2D1_PIXEL_FORMAT pixelFormat; + float dpiX; + float dpiY; + D2D1_BITMAP_OPTIONS bitmapOptions; + ID2D1ColorContext *colorContext; +} D2D1_BITMAP_PROPERTIES1; + +typedef struct D2D1_IMAGE_BRUSH_PROPERTIES +{ + D2D1_RECT_F sourceRectangle; + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_INTERPOLATION_MODE interpolationMode; +} D2D1_IMAGE_BRUSH_PROPERTIES; + +typedef struct D2D1_BITMAP_BRUSH_PROPERTIES1 +{ + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_INTERPOLATION_MODE interpolationMode; +} D2D1_BITMAP_BRUSH_PROPERTIES1; + +typedef struct D2D1_RENDERING_CONTROLS +{ + D2D1_BUFFER_PRECISION bufferPrecision; + D2D1_SIZE_U tileSize; +} D2D1_RENDERING_CONTROLS; + +typedef struct D2D1_LAYER_PARAMETERS1 +{ + D2D1_RECT_F contentBounds; + ID2D1Geometry *geometricMask; + D2D1_ANTIALIAS_MODE maskAntialiasMode; + D2D1_MATRIX_3X2_F maskTransform; + float opacity; + ID2D1Brush *opacityBrush; + D2D1_LAYER_OPTIONS1 layerOptions; +} D2D1_LAYER_PARAMETERS1; + +typedef struct D2D1_EFFECT_INPUT_DESCRIPTION +{ + ID2D1Effect *effect; + UINT32 inputIndex; + D2D1_RECT_F inputRectangle; +} D2D1_EFFECT_INPUT_DESCRIPTION; + +typedef struct D2D1_POINT_DESCRIPTION +{ + D2D1_POINT_2F point; + D2D1_POINT_2F unitTangentVector; + UINT32 endSegment; + UINT32 endFigure; + float lengthToEndSegment; +} D2D1_POINT_DESCRIPTION; + +typedef HRESULT (__stdcall *PD2D1_EFFECT_FACTORY)(IUnknown **effect); + +[ + object, + uuid(82237326-8111-4f7c-bcf4-b5c1175564fe), + local, +] +interface ID2D1GdiMetafileSink : IUnknown +{ + HRESULT ProcessRecord( + [in] DWORD type, + [in, optional] const void *data, + [in] DWORD size + ); +} + +[ + object, + uuid(2f543dc3-cfc1-4211-864f-cfd91c6f3395), + local, +] +interface ID2D1GdiMetafile : ID2D1Resource +{ + HRESULT Stream( + [in] ID2D1GdiMetafileSink *sink + ); + HRESULT GetBounds( + [out] D2D1_RECT_F *bounds + ); +} + +[ + object, + uuid(62baa2d2-ab54-41b7-b872-787e0106a421), + local, +] +interface ID2D1PathGeometry1 : ID2D1PathGeometry +{ + HRESULT ComputePointAndSegmentAtLength( + [in] float length, + [in] UINT32 start_segment, + [in, optional] const D2D1_MATRIX_3X2_F *transform, + [in] float tolerance, + [out] D2D1_POINT_DESCRIPTION *point_desc + ); +} + +[ + object, + uuid(483473d7-cd46-4f9d-9d3a-3112aa80159d), + local, +] +interface ID2D1Properties : IUnknown +{ + UINT32 GetPropertyCount(); + HRESULT GetPropertyName( + [in] UINT32 index, + [out] WCHAR *name, + [in] UINT32 name_count + ); + UINT32 GetPropertyNameLength( + [in] UINT32 index + ); + D2D1_PROPERTY_TYPE GetType( + [in] UINT32 index + ); + UINT32 GetPropertyIndex( + [in] const WCHAR *name + ); + HRESULT SetValueByName( + [in] const WCHAR *name, + [in] D2D1_PROPERTY_TYPE type, + [in] const BYTE *value, + [in] UINT32 value_size + ); + HRESULT SetValue( + [in] UINT32 index, + [in] D2D1_PROPERTY_TYPE type, + [in] const BYTE *value, + [in] UINT32 value_size + ); + HRESULT GetValueByName( + [in] const WCHAR *name, + [in] D2D1_PROPERTY_TYPE type, + [out] BYTE *value, + [in] UINT32 value_size + ); + HRESULT GetValue( + [in] UINT32 index, + [in] D2D1_PROPERTY_TYPE type, + [out] BYTE *value, + [in] UINT32 value_size + ); + UINT32 GetValueSize( + [in] UINT32 index + ); + HRESULT GetSubProperties( + [in] UINT32 index, + [out] ID2D1Properties **props + ); +} + +[ + object, + uuid(28211a43-7d89-476f-8181-2d6159b220ad), + local, +] +interface ID2D1Effect : ID2D1Properties +{ + void SetInput( + [in] UINT32 index, + [in] ID2D1Image *input, + [in] BOOL invalidate + ); + HRESULT SetInputCount( + [in] UINT32 count + ); + void GetInput( + [in] UINT32 index, + [out] ID2D1Image **input + ); + UINT32 GetInputCount(); + void GetOutput( + [out] ID2D1Image **output + ); +} + +[ + object, + uuid(689f1f85-c72e-4e33-8f19-85754efd5ace), + local, +] +interface ID2D1DrawingStateBlock1 : ID2D1DrawingStateBlock +{ + void GetDescription( + [out] D2D1_DRAWING_STATE_DESCRIPTION1 *desc + ); + void SetDescription( + [in] const D2D1_DRAWING_STATE_DESCRIPTION1 *desc + ); +} + +[ + object, + uuid(1c4820bb-5771-4518-a581-2fe4dd0ec657), + local, +] +interface ID2D1ColorContext : ID2D1Resource +{ + D2D1_COLOR_SPACE GetColorSpace(); + UINT32 GetProfileSize(); + HRESULT GetProfile( + [out] BYTE *profile, + [in] UINT32 size + ); +} + +[ + object, + uuid(a898a84c-3873-4588-b08b-ebbf978df041), + local, +] +interface ID2D1Bitmap1 : ID2D1Bitmap +{ + void GetColorContext( + [out] ID2D1ColorContext **context + ); + D2D1_BITMAP_OPTIONS GetOptions(); + HRESULT GetSurface( + [out] IDXGISurface **surface + ); + HRESULT Map( + [in] D2D1_MAP_OPTIONS options, + [out] D2D1_MAPPED_RECT *mapped_rect + ); + HRESULT Unmap(); +} + +[ + object, + uuid(41343a53-e41a-49a2-91cd-21793bbb62e5), + local, +] +interface ID2D1BitmapBrush1 : ID2D1BitmapBrush +{ + void SetInterpolationMode1( + [in] D2D1_INTERPOLATION_MODE mode + ); + D2D1_INTERPOLATION_MODE GetInterpolationMode1(); +} + +[ + object, + uuid(ae1572f4-5dd0-4777-998b-9279472ae63b), + local, +] +interface ID2D1GradientStopCollection1 : ID2D1GradientStopCollection +{ + void GetGradientStops1( + [out] D2D1_GRADIENT_STOP *gradient, + [in] UINT32 count + ); + D2D1_COLOR_SPACE GetPreInterpolationSpace(); + D2D1_COLOR_SPACE GetPostInterpolationSpace(); + D2D1_BUFFER_PRECISION GetBufferPrecision(); + D2D1_COLOR_INTERPOLATION_MODE GetColorInterpolationMode(); +} + +[ + object, + uuid(47dd575d-ac05-4cdd-8049-9b02cd16f44c), + local, +] +interface ID2D1Device : ID2D1Resource +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext **context + ); + HRESULT CreatePrintControl( + [in] IWICImagingFactory *wic_factory, + [in] IPrintDocumentPackageTarget *document_target, + [in] const D2D1_PRINT_CONTROL_PROPERTIES *desc, + [out] ID2D1PrintControl **print_control + ); + void SetMaximumTextureMemory( + [in] UINT64 max_texture_memory + ); + UINT64 GetMaximumTextureMemory(); + HRESULT ClearResources( + [in, defaultvalue(0)] UINT msec_since_use + ); +} + +[ + object, + uuid(54d7898a-a061-40a7-bec7-e465bcba2c4f), + local, +] +interface ID2D1CommandSink : IUnknown +{ + HRESULT BeginDraw(); + HRESULT EndDraw(); + HRESULT SetAntialiasMode( + [in] D2D1_ANTIALIAS_MODE antialias_mode + ); + HRESULT SetTags( + [in] D2D1_TAG tag1, + [in] D2D1_TAG tag2 + ); + HRESULT SetTextAntialiasMode( + [in] D2D1_TEXT_ANTIALIAS_MODE antialias_mode + ); + HRESULT SetTextRenderingParams( + [in] IDWriteRenderingParams *text_rendering_params + ); + HRESULT SetTransform( + [in] const D2D1_MATRIX_3X2_F *transform + ); + HRESULT SetPrimitiveBlend( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); + HRESULT SetUnitMode( + [in] D2D1_UNIT_MODE unit_mode + ); + HRESULT Clear( + [in] const D2D1_COLOR_F *color + ); + HRESULT DrawGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, + [in] ID2D1Brush *brush, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + HRESULT DrawLine( + [in] D2D1_POINT_2F p0, + [in] D2D1_POINT_2F p1, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + HRESULT DrawGeometry( + [in] ID2D1Geometry *geometry, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + HRESULT DrawRectangle( + [in] const D2D1_RECT_F *rect, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + HRESULT DrawBitmap( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_F *dst_rect, + [in] float opacity, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] const D2D1_RECT_F *src_rect, + [in] const D2D1_MATRIX_4X4_F *perspective_transform + ); + HRESULT DrawImage( + [in] ID2D1Image *image, + [in] const D2D1_POINT_2F *target_offset, + [in] const D2D1_RECT_F *image_rect, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_COMPOSITE_MODE composite_mode + ); + HRESULT DrawGdiMetafile( + [in] ID2D1GdiMetafile *metafile, + [in] const D2D1_POINT_2F *target_offset + ); + HRESULT FillMesh( + [in] ID2D1Mesh *mesh, + [in] ID2D1Brush *brush + ); + HRESULT FillOpacityMask( + [in] ID2D1Bitmap *bitmap, + [in] ID2D1Brush *brush, + [in] const D2D1_RECT_F *dst_rect, + [in] const D2D1_RECT_F *src_rect + ); + HRESULT FillGeometry( + [in] ID2D1Geometry *geometry, + [in] ID2D1Brush *brush, + [in] ID2D1Brush *opacity_brush + ); + HRESULT FillRectangle( + [in] const D2D1_RECT_F *rect, + [in] ID2D1Brush *brush + ); + HRESULT PushAxisAlignedClip( + [in] const D2D1_RECT_F *clip_rect, + [in] D2D1_ANTIALIAS_MODE antialias_mode + ); + HRESULT PushLayer( + [in] const D2D1_LAYER_PARAMETERS1 *layer_parameters, + [in] ID2D1Layer *layer + ); + HRESULT PopAxisAlignedClip(); + HRESULT PopLayer(); +} + +[ + object, + uuid(b4f34a19-2383-4d76-94f6-ec343657c3dc), + local, +] +interface ID2D1CommandList : ID2D1Image +{ + HRESULT Stream( + [in] ID2D1CommandSink *sink + ); + HRESULT Close(); +} + +[ + object, + uuid(2c1d867d-c290-41c8-ae7e-34a98702e9a5), + local, +] +interface ID2D1PrintControl : IUnknown +{ + HRESULT AddPage( + [in] ID2D1CommandList *list, + [in] D2D_SIZE_F size, + [in, optional] IStream *stream, + [out, optional] D2D1_TAG *tag1, + [out, optional] D2D1_TAG *tag2 + ); + HRESULT Close(); +} + +[ + object, + uuid(fe9e984d-3f95-407c-b5db-cb94d4e8f87c), + local, +] +interface ID2D1ImageBrush : ID2D1Brush +{ + void SetImage( + [in] ID2D1Image *image + ); + void SetExtendModeX( + [in] D2D1_EXTEND_MODE extend_mode + ); + void SetExtendModeY( + [in] D2D1_EXTEND_MODE extend_mode + ); + void SetInterpolationMode( + [in] D2D1_INTERPOLATION_MODE interpolation_mode + ); + void SetSourceRectangle( + [in] const D2D1_RECT_F *rect + ); + void GetImage( + [out] ID2D1Image **image + ); + D2D1_EXTEND_MODE GetExtendModeX(); + D2D1_EXTEND_MODE GetExtendModeY(); + D2D1_INTERPOLATION_MODE GetInterpolationMode(); + void GetSourceRectangle( + [out] D2D1_RECT_F *rect + ); +} + +[ + object, + uuid(e8f7fe7a-191c-466d-ad95-975678bda998), + local, +] +interface ID2D1DeviceContext : ID2D1RenderTarget +{ + HRESULT CreateBitmap( + [in] D2D1_SIZE_U size, + [in] const void *src_data, + [in] UINT32 pitch, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateBitmapFromWicBitmap( + [in] IWICBitmapSource *bitmap_source, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateColorContext( + [in] D2D1_COLOR_SPACE space, + [in] const BYTE *profile, + [in] UINT32 profile_size, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromFilename( + [in] const WCHAR *filename, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromWicColorContext( + [in] IWICColorContext *wic_color_context, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateBitmapFromDxgiSurface( + [in] IDXGISurface *surface, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateEffect( + [in] REFCLSID effect_id, + [out] ID2D1Effect **effect + ); + HRESULT CreateGradientStopCollection( + [in] const D2D1_GRADIENT_STOP *stops, + [in] UINT32 stop_count, + [in] D2D1_COLOR_SPACE preinterpolation_space, + [in] D2D1_COLOR_SPACE postinterpolation_space, + [in] D2D1_BUFFER_PRECISION buffer_precision, + [in] D2D1_EXTEND_MODE extend_mode, + [in] D2D1_COLOR_INTERPOLATION_MODE color_interpolation_mode, + [out] ID2D1GradientStopCollection1 **gradient + ); + HRESULT CreateImageBrush( + [in] ID2D1Image *image, + [in] const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1ImageBrush **brush + ); + HRESULT CreateBitmapBrush( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1BitmapBrush1 **bitmap_brush + ); + HRESULT CreateCommandList( + [out] ID2D1CommandList **command_list + ); + BOOL IsDxgiFormatSupported( + [in] DXGI_FORMAT format + ); + BOOL IsBufferPrecisionSupported( + [in] D2D1_BUFFER_PRECISION buffer_precision + ); + HRESULT GetImageLocalBounds( + [in] ID2D1Image *image, + [out] D2D1_RECT_F *local_bounds + ); + HRESULT GetImageWorldBounds( + [in] ID2D1Image *image, + [out] D2D1_RECT_F *world_bounds + ); + HRESULT GetGlyphRunWorldBounds( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] DWRITE_MEASURING_MODE measuring_mode, + [out] D2D1_RECT_F *bounds + ); + void GetDevice( + [out] ID2D1Device **device + ); + void SetTarget( + [in] ID2D1Image *target + ); + void GetTarget( + [out] ID2D1Image **target + ); + void SetRenderingControls( + [in] const D2D1_RENDERING_CONTROLS *rendering_controls + ); + void GetRenderingControls( + [out] D2D1_RENDERING_CONTROLS *rendering_controls + ); + void SetPrimitiveBlend( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); + D2D1_PRIMITIVE_BLEND GetPrimitiveBlend(); + void SetUnitMode( + [in] D2D1_UNIT_MODE unit_mode + ); + D2D1_UNIT_MODE GetUnitMode(); + void DrawGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, + [in] ID2D1Brush *brush, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + void DrawImage( + [in] ID2D1Image *image, + [in] const D2D1_POINT_2F *target_offset, + [in] const D2D1_RECT_F *image_rect, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_COMPOSITE_MODE composite_mode + ); + void DrawGdiMetafile( + [in] ID2D1GdiMetafile *metafile, + [in] const D2D1_POINT_2F *target_offset + ); + void DrawBitmap( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_F *dst_rect, + [in] float opacity, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] const D2D1_RECT_F *src_rect, + [in] const D2D1_MATRIX_4X4_F *perspective_transform + ); + void PushLayer( + [in] const D2D1_LAYER_PARAMETERS1 *layer_parameters, + [in] ID2D1Layer *layer + ); + HRESULT InvalidateEffectInputRectangle( + [in] ID2D1Effect *effect, + [in] UINT32 input, + [in] const D2D1_RECT_F *input_rect + ); + HRESULT GetEffectInvalidRectangleCount( + [in] ID2D1Effect *effect, + [out] UINT32 *rect_count + ); + HRESULT GetEffectInvalidRectangles( + [in] ID2D1Effect *effect, + [out] D2D1_RECT_F *rectangles, + [in] UINT32 rect_count + ); + HRESULT GetEffectRequiredInputRectangles( + [in] ID2D1Effect *effect, + [in] const D2D1_RECT_F *image_rect, + [in] const D2D1_EFFECT_INPUT_DESCRIPTION *desc, + [out] D2D1_RECT_F *input_rect, + [in] UINT32 input_count + ); + void FillOpacityMask( + [in] ID2D1Bitmap *mask, + [in] ID2D1Brush *brush, + [in] const D2D1_RECT_F *dst_rect, + [in] const D2D1_RECT_F *src_rect + ); +} + +[ + object, + uuid(10a72a66-e91c-43f4-993f-ddf4b82b0b4a), + local, +] +interface ID2D1StrokeStyle1 : ID2D1StrokeStyle +{ + D2D1_STROKE_TRANSFORM_TYPE GetStrokeTransformType(); +} + +[ + object, + uuid(bb12d362-daee-4b9a-aa1d-14ba401cfa1f), + local, +] +interface ID2D1Factory1 : ID2D1Factory +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device **device + ); + HRESULT CreateStrokeStyle( + [in] const D2D1_STROKE_STYLE_PROPERTIES1 *desc, + [in, size_is(dash_count)] const float *dashes, + [in] UINT32 dash_count, + [out] ID2D1StrokeStyle1 **stroke_style + ); + HRESULT CreatePathGeometry( + [out] ID2D1PathGeometry1 **geometry + ); + HRESULT CreateDrawingStateBlock( + [in] const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, + [in] IDWriteRenderingParams *text_rendering_params, + [out] ID2D1DrawingStateBlock1 **state_block + ); + HRESULT CreateGdiMetafile( + [in] IStream *stream, + [out] ID2D1GdiMetafile **metafile + ); + HRESULT RegisterEffectFromStream( + [in] REFCLSID effect_id, + [in] IStream *property_xml, + [in, size_is(binding_count)] const struct D2D1_PROPERTY_BINDING *bindings, + [in] UINT32 binding_count, + [in] PD2D1_EFFECT_FACTORY effect_factory + ); + HRESULT RegisterEffectFromString( + [in] REFCLSID effect_id, + [in] const WCHAR *property_xml, + [in, size_is(binding_count)] const struct D2D1_PROPERTY_BINDING *bindings, + [in] UINT32 binding_count, + [in] PD2D1_EFFECT_FACTORY effect_factory + ); + HRESULT UnregisterEffect( + [in] REFCLSID effect_id + ); + HRESULT GetRegisteredEffects( + [out, size_is(effect_count)] CLSID *effects, + [in] UINT32 effect_count, + [out] UINT32 *returned, + [out] UINT32 *registered + ); + HRESULT GetEffectProperties( + [in] REFCLSID effect_id, + [out] ID2D1Properties **props + ); +} + +[ + object, + uuid(31e6e7bc-e0ff-4d46-8c64-a0a8c41c15d3), + local, +] +interface ID2D1Multithread : IUnknown +{ + BOOL GetMultithreadProtected(); + void Enter(); + void Leave(); +} + +[local] HRESULT __stdcall D2D1CreateDevice(IDXGIDevice *dxgi_device, + const D2D1_CREATION_PROPERTIES *creation_properties, ID2D1Device **device); +[local] HRESULT __stdcall D2D1CreateDeviceContext(IDXGISurface *dxgi_surface, + const D2D1_CREATION_PROPERTIES *creation_properties, ID2D1DeviceContext **context); +[local] void __stdcall D2D1SinCos(float angle, float *s, float *c); +[local] float __stdcall D2D1Tan(float angle); +[local] float __stdcall D2D1Vec3Length(float x, float y, float z); +[local] D2D1_COLOR_F __stdcall D2D1ConvertColorSpace(D2D1_COLOR_SPACE src_colour_space, + D2D1_COLOR_SPACE dst_colour_space, const D2D1_COLOR_F *colour); diff --git a/WineFix/lib/d2d1/include/windows/d2d1_2.idl b/WineFix/lib/d2d1/include/windows/d2d1_2.idl new file mode 100644 index 0000000..c4cb06e --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1_2.idl @@ -0,0 +1,105 @@ +/* + * Copyright 2018 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d2d1_1.idl"; +import "d2d1effects_1.idl"; + +typedef enum D2D1_RENDERING_PRIORITY +{ + D2D1_RENDERING_PRIORITY_NORMAL = 0, + D2D1_RENDERING_PRIORITY_LOW = 1, + D2D1_RENDERING_PRIORITY_FORCE_DWORD = 0xffffffff, +} D2D1_RENDERING_PRIORITY; + +[ + object, + uuid(a16907d7-bc02-4801-99e8-8cf7f485f774), + local, +] +interface ID2D1GeometryRealization : ID2D1Resource +{ +} + +[ + object, + uuid(d37f57e4-6908-459f-a199-e72f24f79987), + local, +] +interface ID2D1DeviceContext1 : ID2D1DeviceContext +{ + HRESULT CreateFilledGeometryRealization( + [in] ID2D1Geometry *geometry, + [in] float tolerance, + [out] ID2D1GeometryRealization **realization + ); + HRESULT CreateStrokedGeometryRealization( + [in] ID2D1Geometry *geometry, + [in] float tolerance, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style, + [out] ID2D1GeometryRealization **realization + ); + void DrawGeometryRealization( + [in] ID2D1GeometryRealization *realization, + [in] ID2D1Brush *brush + ); +} + +[ + object, + uuid(d21768e1-23a4-4823-a14b-7c3eba85d658), + local, +] +interface ID2D1Device1 : ID2D1Device +{ + D2D1_RENDERING_PRIORITY GetRenderingPriority(); + void SetRenderingPriority( + [in] D2D1_RENDERING_PRIORITY priority + ); + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext1 **device_context + ); +} + +[ + object, + uuid(94f81a73-9212-4376-9c58-b16a3a0d3992), + local, +] +interface ID2D1Factory2 : ID2D1Factory1 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device1 **device + ); +} + +[ + object, + uuid(9eb767fd-4269-4467-b8c2-eb30cb305743), + local, +] +interface ID2D1CommandSink1 : ID2D1CommandSink +{ + HRESULT SetPrimitiveBlend1( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); +} + +[local] float __stdcall D2D1ComputeMaximumScaleFactor(const D2D1_MATRIX_3X2_F *matrix); diff --git a/WineFix/lib/d2d1/include/windows/d2d1_3.idl b/WineFix/lib/d2d1/include/windows/d2d1_3.idl new file mode 100644 index 0000000..c4955a7 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1_3.idl @@ -0,0 +1,844 @@ +/* + * Copyright 2022 Ziqing Hui for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d2d1_2.idl"; +import "d2d1effects_2.idl"; + +interface IDWriteFontFace; + +typedef enum D2D1_INK_NIB_SHAPE +{ + D2D1_INK_NIB_SHAPE_ROUND = 0x0, + D2D1_INK_NIB_SHAPE_SQUARE = 0x1, + D2D1_INK_NIB_SHAPE_FORCE_DWORD = 0xffffffff +} D2D1_INK_NIB_SHAPE; + +typedef enum D2D1_PATCH_EDGE_MODE +{ + D2D1_PATCH_EDGE_MODE_ALIASED = 0x0, + D2D1_PATCH_EDGE_MODE_ANTIALIASED = 0x1, + D2D1_PATCH_EDGE_MODE_ALIASED_INFLATED = 0x2, + D2D1_PATCH_EDGE_MODE_FORCE_DWORD = 0xffffffff +} D2D1_PATCH_EDGE_MODE; + +typedef enum D2D1_ORIENTATION +{ + D2D1_ORIENTATION_DEFAULT = 0x1, + D2D1_ORIENTATION_FLIP_HORIZONTAL = 0x2, + D2D1_ORIENTATION_ROTATE_CLOCKWISE180 = 0x3, + D2D1_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = 0x4, + D2D1_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = 0x5, + D2D1_ORIENTATION_ROTATE_CLOCKWISE270 = 0x6, + D2D1_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = 0x7, + D2D1_ORIENTATION_ROTATE_CLOCKWISE90 = 0x8, + D2D1_ORIENTATION_FORCE_DWORD = 0xffffffff +} D2D1_ORIENTATION; + +typedef enum D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS +{ + D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_NONE = 0x0, + D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_DISABLE_DPI_SCALE = 0x1, + D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_FORCE_DWORD = 0xffffffff +} D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS; + +typedef enum D2D1_IMAGE_SOURCE_LOADING_OPTIONS +{ + D2D1_IMAGE_SOURCE_LOADING_OPTIONS_NONE = 0x0, + D2D1_IMAGE_SOURCE_LOADING_OPTIONS_RELEASE_SOURCE = 0x1, + D2D1_IMAGE_SOURCE_LOADING_OPTIONS_CACHE_ON_DEMAND = 0x2, + D2D1_IMAGE_SOURCE_LOADING_OPTIONS_FORCE_DWORD = 0xffffffff +} D2D1_IMAGE_SOURCE_LOADING_OPTIONS; + +typedef enum D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS +{ + D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_NONE = 0x0, + D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_LOW_QUALITY_PRIMARY_CONVERSION = 0x1, + D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_FORCE_DWORD = 0xffffffff +} D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS; + +typedef enum D2D1_SPRITE_OPTIONS +{ + D2D1_SPRITE_OPTIONS_NONE = 0x0, + D2D1_SPRITE_OPTIONS_CLAMP_TO_SOURCE_RECTANGLE = 0x1, + D2D1_SPRITE_OPTIONS_FORCE_DWORD = 0xffffffff +} D2D1_SPRITE_OPTIONS; + +typedef enum D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION +{ + D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DEFAULT = 0x0, + D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DISABLE = 0x1, + D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_FORCE_DWORD = 0xffffffff +} D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION; + +typedef enum D2D1_GAMMA1 +{ + D2D1_GAMMA1_G22 = D2D1_GAMMA_2_2, + D2D1_GAMMA1_G10 = D2D1_GAMMA_1_0, + D2D1_GAMMA1_G2084 = 2, + D2D1_GAMMA1_FORCE_DWORD = 0xffffffff +} D2D1_GAMMA1; + +typedef enum D2D1_COLOR_CONTEXT_TYPE +{ + D2D1_COLOR_CONTEXT_TYPE_ICC = 0x0, + D2D1_COLOR_CONTEXT_TYPE_SIMPLE = 0x1, + D2D1_COLOR_CONTEXT_TYPE_DXGI = 0x2, + D2D1_COLOR_CONTEXT_TYPE_FORCE_DWORD = 0xffffffff +} D2D1_COLOR_CONTEXT_TYPE; + +typedef struct D2D1_INK_POINT +{ + float x; + float y; + float radius; +} D2D1_INK_POINT; + +typedef struct D2D1_INK_BEZIER_SEGMENT +{ + D2D1_INK_POINT point1; + D2D1_INK_POINT point2; + D2D1_INK_POINT point3; +} D2D1_INK_BEZIER_SEGMENT; + +typedef struct D2D1_INK_STYLE_PROPERTIES +{ + D2D1_INK_NIB_SHAPE nibShape; + D2D1_MATRIX_3X2_F nibTransform; +} D2D1_INK_STYLE_PROPERTIES; + +typedef struct D2D1_GRADIENT_MESH_PATCH +{ + D2D1_POINT_2F point00; + D2D1_POINT_2F point01; + D2D1_POINT_2F point02; + D2D1_POINT_2F point03; + D2D1_POINT_2F point10; + D2D1_POINT_2F point11; + D2D1_POINT_2F point12; + D2D1_POINT_2F point13; + D2D1_POINT_2F point20; + D2D1_POINT_2F point21; + D2D1_POINT_2F point22; + D2D1_POINT_2F point23; + D2D1_POINT_2F point30; + D2D1_POINT_2F point31; + D2D1_POINT_2F point32; + D2D1_POINT_2F point33; + D2D1_COLOR_F color00; + D2D1_COLOR_F color03; + D2D1_COLOR_F color30; + D2D1_COLOR_F color33; + D2D1_PATCH_EDGE_MODE topEdgeMode; + D2D1_PATCH_EDGE_MODE leftEdgeMode; + D2D1_PATCH_EDGE_MODE bottomEdgeMode; + D2D1_PATCH_EDGE_MODE rightEdgeMode; +} D2D1_GRADIENT_MESH_PATCH; + +typedef struct D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES +{ + D2D1_ORIENTATION orientation; + float scaleX; + float scaleY; + D2D1_INTERPOLATION_MODE interpolationMode; + D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS options; +} D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES; + +typedef struct D2D1_SIMPLE_COLOR_PROFILE +{ + D2D1_POINT_2F redPrimary; + D2D1_POINT_2F greenPrimary; + D2D1_POINT_2F bluePrimary; + D2D1_POINT_2F whitePointXZ; + D2D1_GAMMA1 gamma; +} D2D1_SIMPLE_COLOR_PROFILE; + +[ + object, + uuid(bae8b344-23fc-4071-8cb5-d05d6f073848), + local, +] +interface ID2D1InkStyle : ID2D1Resource +{ + void SetNibTransform( + [in] const D2D1_MATRIX_3X2_F *transform + ); + void GetNibTransform( + [out] D2D1_MATRIX_3X2_F *transform + ); + void SetNibShape( + [in] D2D1_INK_NIB_SHAPE shape + ); + D2D1_INK_NIB_SHAPE GetNibShape(); +} + +[ + object, + uuid(b499923b-7029-478f-a8b3-432c7c5f5312), + local, +] +interface ID2D1Ink : ID2D1Resource +{ + void SetStartPoint( + [in] const D2D1_INK_POINT *start_point + ); + D2D1_INK_POINT GetStartPoint(); + HRESULT AddSegments( + [in] const D2D1_INK_BEZIER_SEGMENT *segments, + [in] UINT32 segment_count + ); + HRESULT RemoveSegmentsAtEnd( + [in] UINT32 segment_count + ); + HRESULT SetSegments( + [in] UINT32 start_segment, + [in] const D2D1_INK_BEZIER_SEGMENT *segments, + [in] UINT32 segment_count + ); + HRESULT SetSegmentAtEnd( + [in] const D2D1_INK_BEZIER_SEGMENT *segment + ); + UINT32 GetSegmentCount(); + HRESULT GetSegments( + [in] UINT32 start_segment, + [out] D2D1_INK_BEZIER_SEGMENT *segments, + [in] UINT32 segment_count + ); + HRESULT StreamAsGeometry( + [in, optional] ID2D1InkStyle *ink_style, + [in, optional] const D2D1_MATRIX_3X2_F *world_transform, + [in] float flattening_tolerance, + [in] ID2D1SimplifiedGeometrySink *geometry_sink + ); + HRESULT GetBounds( + [in, optional] ID2D1InkStyle *ink_style, + [in, optional] const D2D1_MATRIX_3X2_F *world_transform, + [out] D2D1_RECT_F *bounds + ); +} + +[ + object, + uuid(f292e401-c050-4cde-83d7-04962d3b23c2), + local, +] +interface ID2D1GradientMesh : ID2D1Resource +{ + UINT32 GetPatchCount(); + HRESULT GetPatches( + [in] UINT32 start_index, + [out] D2D1_GRADIENT_MESH_PATCH *patches, + [in] UINT32 patch_count + ); +} + +[ + object, + uuid(c9b664e5-74a1-4378-9ac2-eefc37a3f4d8), + local, +] +interface ID2D1ImageSource : ID2D1Image +{ + HRESULT OfferResources(); + HRESULT TryReclaimResources( + [out] BOOL *resources_discarded + ); +} + +[ + object, + uuid(77395441-1c8f-4555-8683-f50dab0fe792), + local, +] +interface ID2D1ImageSourceFromWic : ID2D1ImageSource +{ + HRESULT EnsureCached( + [in, optional] const D2D1_RECT_U *rect_to_fill + ); + HRESULT TrimCache( + [in, optional] const D2D1_RECT_U *rect_to_preserve + ); + void GetSource( + [out] IWICBitmapSource **source + ); +} + +[ + object, + uuid(7f1f79e5-2796-416c-8f55-700f911445e5), + local, +] +interface ID2D1TransformedImageSource : ID2D1Image +{ + void GetSource( + [out] ID2D1ImageSource **source + ); + void GetProperties( + [out] D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES *out + ); +} + +[ + object, + uuid(53dd9855-a3b0-4d5b-82e1-26e25c5e5797), + local, +] +interface ID2D1LookupTable3D : ID2D1Resource +{ +} + +[ + object, + uuid(4dc583bf-3a10-438a-8722-e9765224f1f1), + local, +] +interface ID2D1SpriteBatch : ID2D1Resource +{ + HRESULT AddSprites( + [in] UINT32 sprite_count, + [in] const D2D1_RECT_F *destination_rectangles, + [in] const D2D1_RECT_U *source_rectangles, + [in] const D2D1_COLOR_F *colors, + [in] const D2D1_MATRIX_3X2_F *transforms, + [in] UINT32 destination_rectangles_stride, + [in] UINT32 source_rectangles_stride, + [in] UINT32 colors_stride, + [in] UINT32 transforms_stride + ); + HRESULT SetSprites( + [in] UINT32 start_index, + [in] UINT32 sprite_count, + [in] const D2D1_RECT_F *destination_rectangles, + [in] const D2D1_RECT_U *source_rectangles, + [in] const D2D1_COLOR_F *colors, + [in] const D2D1_MATRIX_3X2_F *transforms, + [in] UINT32 destination_rectangles_stride, + [in] UINT32 source_rectangles_stride, + [in] UINT32 colors_stride, + [in] UINT32 transforms_stride + ); + HRESULT GetSprites( + [in] UINT32 start_index, + [in] UINT32 sprite_count, + [out, optional] D2D1_RECT_F *destination_rectangles, + [out, optional] D2D1_RECT_U *source_rectangles, + [out, optional] D2D1_COLOR_F *colors, + [out, optional] D2D1_MATRIX_3X2_F *transforms + ); + UINT32 GetSpriteCount(void); + void Clear(void); +} + +[ + object, + uuid(af671749-d241-4db8-8e41-dcc2e5c1a438), + local, +] +interface ID2D1SvgGlyphStyle : ID2D1Resource +{ + HRESULT SetFill( + [in, optional] ID2D1Brush *brush + ); + void GetFill( + [out] ID2D1Brush **brush + ); + HRESULT SetStroke( + [in, optional] ID2D1Brush *brush, + [in] FLOAT stroke_width, + [in, optional] const FLOAT *dashes, + [in, optional] UINT32 dashes_count, + [in] FLOAT dash_offset + ); + UINT32 GetStrokeDashesCount(void); + void GetStroke( + [out, optional] ID2D1Brush **brush, + [out, optional] FLOAT *stroke_width, + [out, optional] FLOAT *dashes, + [in, optional] UINT32 dashes_count, + [out, optional] FLOAT *dash_offset + ); +} + +[ + object, + uuid(394ea6a3-0c34-4321-950b-6ca20f0be6c7), + local, +] +interface ID2D1DeviceContext2 : ID2D1DeviceContext1 +{ + HRESULT CreateInk( + [in] const D2D1_INK_POINT *start_point, + [out] ID2D1Ink **ink + ); + HRESULT CreateInkStyle( + [in, optional] const D2D1_INK_STYLE_PROPERTIES *ink_style_properties, + [out] ID2D1InkStyle **ink_style + ); + HRESULT CreateGradientMesh( + [in] const D2D1_GRADIENT_MESH_PATCH *patches, + [in] UINT32 patches_count, + [out] ID2D1GradientMesh **gradient_mesh + ); + HRESULT CreateImageSourceFromWic( + [in] IWICBitmapSource *wic_bitmap_source, + [in] D2D1_IMAGE_SOURCE_LOADING_OPTIONS loading_options, + [in] D2D1_ALPHA_MODE alpha_mode, + [out] ID2D1ImageSourceFromWic **image_source + ); + HRESULT CreateLookupTable3D( + [in] D2D1_BUFFER_PRECISION precision, + [in] const UINT32 *extents, + [in] const BYTE *data, + [in] UINT32 data_count, + [in] const UINT32 *strides, + [out] ID2D1LookupTable3D **lookup_table + ); + HRESULT CreateImageSourceFromDxgi( + [in] IDXGISurface **surfaces, + [in] UINT32 surface_count, + [in] DXGI_COLOR_SPACE_TYPE color_space, + [in] D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS options, + [out] ID2D1ImageSource **image_source + ); + HRESULT GetGradientMeshWorldBounds( + [in] ID2D1GradientMesh *gradient_mesh, + [out] D2D1_RECT_F *bounds + ); + void DrawInk( + [in] ID2D1Ink *ink, + [in] ID2D1Brush *brush, + [in, optional] ID2D1InkStyle *ink_style + ); + void DrawGradientMesh( + [in] ID2D1GradientMesh *gradient_mesh + ); + void DrawGdiMetafile( + [in] ID2D1GdiMetafile *gdi_metafile, + [in, optional] const D2D1_RECT_F *dst_rect, + [in, optional] const D2D1_RECT_F *src_rect + ); + HRESULT CreateTransformedImageSource( + [in] ID2D1ImageSource *source, + [in] const D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES *props, + [out] ID2D1TransformedImageSource **transformed + ); +} + +[ + object, + uuid(235a7496-8351-414c-bcd4-6672ab2d8e00), + local, +] +interface ID2D1DeviceContext3 : ID2D1DeviceContext2 +{ + HRESULT CreateSpriteBatch( + [out] ID2D1SpriteBatch **sprite_batch + ); + void DrawSpriteBatch( + [in] ID2D1SpriteBatch *sprite_batch, + [in] UINT32 start_index, + [in] UINT32 sprite_count, + [in] ID2D1Bitmap *bitmap, + [in] D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_SPRITE_OPTIONS sprite_options + ); +} + +[ + object, + uuid(8c427831-3d90-4476-b647-c4fae349e4db), + local, +] +interface ID2D1DeviceContext4 : ID2D1DeviceContext3 +{ + HRESULT CreateSvgGlyphStyle( + [out] ID2D1SvgGlyphStyle **svg_glyph_style + ); + void DrawText( + [in] const WCHAR *string, + [in] UINT32 string_length, + [in] IDWriteTextFormat *text_format, + [in] const D2D1_RECT_F *layout_rect, + [in, optional] ID2D1Brush *default_fill_brush, + [in, optional] ID2D1SvgGlyphStyle *svg_glyph_style, + [in, optional] UINT32 color_palette_index, + [in] D2D1_DRAW_TEXT_OPTIONS options, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + void DrawTextLayout( + [in] D2D1_POINT_2F origin, + [in] IDWriteTextLayout *text_layout, + [in, optional] ID2D1Brush *default_fill_brush, + [in, optional] ID2D1SvgGlyphStyle *svg_glyph_style, + [in, optional] UINT32 color_palette_index, + [in] D2D1_DRAW_TEXT_OPTIONS options + ); + void DrawColorBitmapGlyphRun( + [in] DWRITE_GLYPH_IMAGE_FORMATS glyph_image_format, + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION bitmap_snap_option + ); + void DrawSvgGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in, optional] ID2D1Brush *default_fill_brush, + [in, optional] ID2D1SvgGlyphStyle *svg_glyph_style, + [in, optional]UINT32 color_palette_index, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + HRESULT GetColorBitmapGlyphImage( + [in] DWRITE_GLYPH_IMAGE_FORMATS glyph_image_format, + [in] D2D1_POINT_2F glyph_origin, + [in] IDWriteFontFace *font_face, + [in] FLOAT font_em_size, + [in] UINT16 glyph_index, + [in] BOOL is_sideways, + [in, optional] const D2D1_MATRIX_3X2_F *world_transform, + [in] FLOAT dpi_x, + [in] FLOAT dpi_y, + [out] D2D1_MATRIX_3X2_F *glyph_transform, + [out] ID2D1Image **glyph_image + ); + HRESULT GetSvgGlyphImage( + [in] D2D1_POINT_2F glyph_origin, + [in] IDWriteFontFace *font_face, + [in] FLOAT font_em_size, + [in] UINT16 glyph_index, + [in] BOOL is_sideways, + [in, optional] const D2D1_MATRIX_3X2_F *world_transform, + [in, optional] ID2D1Brush *default_fill_brush, + [in, optional] ID2D1SvgGlyphStyle *svg_glyph_style, + [in] UINT32 color_palette_index, + [out] D2D1_MATRIX_3X2_F *glyph_transform, + [out] ID2D1CommandList **glyph_image + ); +} + +interface ID2D1SvgDocument; + +[ + object, + uuid(1ab42875-c57f-4be9-bd85-9cd78d6f55ee), + local, +] +interface ID2D1ColorContext1 : ID2D1ColorContext +{ + D2D1_COLOR_CONTEXT_TYPE GetColorContextType(void); + DXGI_COLOR_SPACE_TYPE GetDXGIColorSpace(void); + HRESULT GetSimpleColorProfile( + [out] D2D1_SIMPLE_COLOR_PROFILE *simple_profile + ); +} + +[ + object, + uuid(7836d248-68cc-4df6-b9e8-de991bf62eb7), + local, +] +interface ID2D1DeviceContext5 : ID2D1DeviceContext4 +{ + HRESULT CreateSvgDocument( + [in] IStream *input_xml_stream, + [in] D2D1_SIZE_F viewport_size, + [out] ID2D1SvgDocument **svg_document + ); + void DrawSvgDocument( + [in] ID2D1SvgDocument *svg_document + ); + HRESULT CreateColorContextFromDxgiColorSpace( + [in] DXGI_COLOR_SPACE_TYPE color_space, + [out] ID2D1ColorContext1 **color_context + ); + HRESULT CreateColorContextFromSimpleColorProfile( + [in] const D2D1_SIMPLE_COLOR_PROFILE *simple_profile, + [out] ID2D1ColorContext1 **color_context + ); +} + +[ + object, + uuid(985f7e37-4ed0-4a19-98a3-15b0edfde306), + local, +] +interface ID2D1DeviceContext6 : ID2D1DeviceContext5 +{ + void BlendImage( + [in] ID2D1Image *image, + [in] D2D1_BLEND_MODE blend_mode, + [in] const D2D1_POINT_2F *target_offset, + [in] const D2D1_RECT_F *image_rect, + [in] D2D1_INTERPOLATION_MODE interpolation_mode + ); +} + +cpp_quote("#ifndef DWRITE_PAINT_FEATURE_LEVEL_DEFINED") +cpp_quote("#define DWRITE_PAINT_FEATURE_LEVEL_DEFINED") +typedef enum DWRITE_PAINT_FEATURE_LEVEL +{ + DWRITE_PAINT_FEATURE_LEVEL_NONE = 0, + DWRITE_PAINT_FEATURE_LEVEL_COLR_V0 = 1, + DWRITE_PAINT_FEATURE_LEVEL_COLR_V1 = 2, +} DWRITE_PAINT_FEATURE_LEVEL; +cpp_quote("#endif /* DWRITE_PAINT_FEATURE_LEVEL_DEFINED */") + +[ + object, + uuid(ec891cf7-9b69-4851-9def-4e0915771e62), + local, +] +interface ID2D1DeviceContext7 : ID2D1DeviceContext6 +{ + DWRITE_PAINT_FEATURE_LEVEL GetPaintFeatureLevel(); + void DrawPaintGlyphRun( + [in] D2D1_POINT_2F origin, + [in] const DWRITE_GLYPH_RUN *run, + [in, defaultvalue(NULL)] ID2D1Brush *brush, + [in, defaultvalue(0)] UINT32 palette_index, + [in, defaultvalue(DWRITE_MEASURING_MODE_NATURAL)] DWRITE_MEASURING_MODE measuring_mode + ); + void DrawGlyphRunWithColorSupport( + [in] D2D1_POINT_2F origin, + [in] const DWRITE_GLYPH_RUN *run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *run_desc, + [in] ID2D1Brush *brush, + [in] ID2D1SvgGlyphStyle *style, + [in, defaultvalue(0)] UINT32 palette_index, + [in, defaultvalue(DWRITE_MEASURING_MODE_NATURAL)] DWRITE_MEASURING_MODE measuring_mode, + [in, defaultvalue(D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DEFAULT)] D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION snap_option + ); +} + +[ + object, + uuid(a44472e1-8dfb-4e60-8492-6e2861c9ca8b), + local, +] +interface ID2D1Device2 : ID2D1Device1 +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext2 **context + ); + void FlushDeviceContexts( + [in] ID2D1Bitmap *bitmap + ); + HRESULT GetDxgiDevice( + [out] IDXGIDevice **dxgi_device + ); +} + +[ + object, + uuid(852f2087-802c-4037-ab60-ff2e7ee6fc01), + local, +] +interface ID2D1Device3 : ID2D1Device2 +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext3 **context + ); +} + +[ + object, + uuid(d7bdb159-5683-4a46-bc9c-72dc720b858b), + local, +] +interface ID2D1Device4 : ID2D1Device3 +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext4 **context + ); + void SetMaximumColorGlyphCacheMemory( + UINT64 size + ); + UINT64 GetMaximumColorGlyphCacheMemory(void); +} + +[ + object, + uuid(d55ba0a4-6405-4694-aef5-08ee1a4358b4), + local, +] +interface ID2D1Device5 : ID2D1Device4 +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext5 **context + ); +} + +[ + object, + uuid(7bfef914-2d75-4bad-be87-e18ddb077b6d), + local, +] +interface ID2D1Device6 : ID2D1Device5 +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext6 **context + ); +} + +[ + object, + uuid(f07c8968-dd4e-4ba6-9cbd-eb6d3752dcbb), + local, +] +interface ID2D1Device7 : ID2D1Device6 +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext7 **context + ); +} + +[ + object, + uuid(0869759f-4f00-413f-b03e-2bda45404d0f), + local, +] +interface ID2D1Factory3 : ID2D1Factory2 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device2 **d2d_device + ); +} + +[ + object, + uuid(bd4ec2d2-0662-4bee-ba8e-6f29f032e096), + local, +] +interface ID2D1Factory4 : ID2D1Factory3 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device3 **d2d_device + ); +} + +[ + object, + uuid(c4349994-838e-4b0f-8cab-44997d9eeacc), + local, +] +interface ID2D1Factory5 : ID2D1Factory4 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device4 **d2d_device + ); +} + +[ + object, + uuid(f9976f46-f642-44c1-97ca-da32ea2a2635), + local, +] +interface ID2D1Factory6 : ID2D1Factory5 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device5 **d2d_device + ); +} + +[ + object, + uuid(bdc2bdd3-b96c-4de6-bdf7-99d4745454de), + local, +] +interface ID2D1Factory7 : ID2D1Factory6 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device6 **d2d_device + ); +} + +[ + object, + uuid(677c9311-f36d-4b1f-ae86-86d1223ffd3a), + local, +] +interface ID2D1Factory8 : ID2D1Factory7 +{ + HRESULT CreateDevice( + [in] IDXGIDevice *dxgi_device, + [out] ID2D1Device7 **d2d_device + ); +} + +[ + object, + uuid(3bab440e-417e-47df-a2e2-bc0be6a00916), + local, +] +interface ID2D1CommandSink2 : ID2D1CommandSink1 +{ + HRESULT DrawInk( + [in] ID2D1Ink *ink, + [in] ID2D1Brush *brush, + [in] ID2D1InkStyle *ink_style + ); + + HRESULT DrawGradientMesh( + [in] ID2D1GradientMesh *gradient_mesh + ); + + HRESULT DrawGdiMetafile( + [in] ID2D1GdiMetafile *gdi_metafile, + [in] const D2D1_RECT_F *dest_rect, + [in] const D2D1_RECT_F *src_rect + ); +} + +[ + object, + uuid(18079135-4cf3-4868-bc8e-06067e6d242d), + local, +] +interface ID2D1CommandSink3 : ID2D1CommandSink2 +{ + HRESULT DrawSpriteBatch( + [in] ID2D1SpriteBatch *sprite_batch, + [in] UINT32 start_index, + [in] UINT32 sprite_count, + [in] ID2D1Bitmap *bitmap, + [in] D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_SPRITE_OPTIONS sprite_options + ); +} + +[ + object, + uuid(c78a6519-40d6-4218-b2de-beeeb744bb3e), + local, +] +interface ID2D1CommandSink4 : ID2D1CommandSink3 +{ + HRESULT SetPrimitiveBlend2( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); +} diff --git a/WineFix/lib/d2d1/include/windows/d2d1effectauthor.idl b/WineFix/lib/d2d1/include/windows/d2d1effectauthor.idl new file mode 100644 index 0000000..a58ec35 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1effectauthor.idl @@ -0,0 +1,619 @@ +/* + * Copyright 2022 Ziqing Hui for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + + import "d2d1_1.idl"; + +typedef HRESULT (__stdcall *PD2D1_PROPERTY_SET_FUNCTION)(IUnknown *effect, + const BYTE *data, UINT32 data_size); + +typedef HRESULT (__stdcall *PD2D1_PROPERTY_GET_FUNCTION)(const IUnknown *effect, + BYTE *data, UINT32 data_size, UINT32 *actual_size); + +typedef enum D2D1_FILTER +{ + D2D1_FILTER_MIN_MAG_MIP_POINT = 0x00, + D2D1_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01, + D2D1_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04, + D2D1_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05, + D2D1_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D2D1_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D2D1_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D2D1_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D2D1_FILTER_ANISOTROPIC = 0x55, + D2D1_FILTER_FORCE_DWORD = 0xffffffff +} D2D1_FILTER; + +typedef enum D2D1_FEATURE +{ + D2D1_FEATURE_DOUBLES = 0x0, + D2D1_FEATURE_D3D10_X_HARDWARE_OPTIONS = 0x1, + D2D1_FEATURE_FORCE_DWORD = 0xffffffff +} D2D1_FEATURE; + +typedef struct D2D1_PROPERTY_BINDING +{ + const WCHAR *propertyName; + PD2D1_PROPERTY_SET_FUNCTION setFunction; + PD2D1_PROPERTY_GET_FUNCTION getFunction; +} D2D1_PROPERTY_BINDING; + +typedef enum D2D1_CHANNEL_DEPTH +{ + D2D1_CHANNEL_DEPTH_DEFAULT = 0x0, + D2D1_CHANNEL_DEPTH_1 = 0x1, + D2D1_CHANNEL_DEPTH_4 = 0x4, + D2D1_CHANNEL_DEPTH_FORCE_DWORD = 0xffffffff +} D2D1_CHANNEL_DEPTH; + +typedef enum D2D1_CHANGE_TYPE +{ + D2D1_CHANGE_TYPE_NONE = 0x0, + D2D1_CHANGE_TYPE_PROPERTIES = 0x1, + D2D1_CHANGE_TYPE_CONTEXT = 0x2, + D2D1_CHANGE_TYPE_GRAPH = 0x3, + D2D1_CHANGE_TYPE_FORCE_DWORD = 0xffffffff +} D2D1_CHANGE_TYPE; + +typedef enum D2D1_PIXEL_OPTIONS +{ + D2D1_PIXEL_OPTIONS_NONE = 0x0, + D2D1_PIXEL_OPTIONS_TRIVIAL_SAMPLING = 0x1, + D2D1_PIXEL_OPTIONS_FORCE_DWORD = 0xffffffff +} D2D1_PIXEL_OPTIONS; + +typedef enum D2D1_VERTEX_OPTIONS +{ + D2D1_VERTEX_OPTIONS_NONE = 0x0, + D2D1_VERTEX_OPTIONS_DO_NOT_CLEAR = 0x1, + D2D1_VERTEX_OPTIONS_USE_DEPTH_BUFFER = 0x2, + D2D1_VERTEX_OPTIONS_ASSUME_NO_OVERLAP = 0x4, + D2D1_VERTEX_OPTIONS_FORCE_DWORD = 0xffffffff +} D2D1_VERTEX_OPTIONS; + +typedef enum D2D1_VERTEX_USAGE +{ + D2D1_VERTEX_USAGE_STATIC = 0x0, + D2D1_VERTEX_USAGE_DYNAMIC = 0x1, + D2D1_VERTEX_USAGE_FORCE_DWORD = 0xffffffff +} D2D1_VERTEX_USAGE; + +typedef enum D2D1_BLEND_OPERATION +{ + D2D1_BLEND_OPERATION_ADD = 0x1, + D2D1_BLEND_OPERATION_SUBTRACT = 0x2, + D2D1_BLEND_OPERATION_REV_SUBTRACT = 0x3, + D2D1_BLEND_OPERATION_MIN = 0x4, + D2D1_BLEND_OPERATION_MAX = 0x5, + D2D1_BLEND_OPERATION_FORCE_DWORD = 0xffffffff +} D2D1_BLEND_OPERATION; + +typedef enum D2D1_BLEND +{ + D2D1_BLEND_ZERO = 1, + D2D1_BLEND_ONE = 2, + D2D1_BLEND_SRC_COLOR = 3, + D2D1_BLEND_INV_SRC_COLOR = 4, + D2D1_BLEND_SRC_ALPHA = 5, + D2D1_BLEND_INV_SRC_ALPHA = 6, + D2D1_BLEND_DEST_ALPHA = 7, + D2D1_BLEND_INV_DEST_ALPHA = 8, + D2D1_BLEND_DEST_COLOR = 9, + D2D1_BLEND_INV_DEST_COLOR = 10, + D2D1_BLEND_SRC_ALPHA_SAT = 11, + D2D1_BLEND_BLEND_FACTOR = 14, + D2D1_BLEND_INV_BLEND_FACTOR = 15, + D2D1_BLEND_FORCE_DWORD = 0xffffffff +} D2D1_BLEND; + +typedef struct D2D1_INPUT_DESCRIPTION +{ + D2D1_FILTER filter; + UINT32 levelOfDetailCount; +} D2D1_INPUT_DESCRIPTION; + +typedef struct D2D1_VERTEX_RANGE +{ + UINT32 startVertex; + UINT32 vertexCount; +} D2D1_VERTEX_RANGE; + +typedef struct D2D1_BLEND_DESCRIPTION +{ + D2D1_BLEND sourceBlend; + D2D1_BLEND destinationBlend; + D2D1_BLEND_OPERATION blendOperation; + D2D1_BLEND sourceBlendAlpha; + D2D1_BLEND destinationBlendAlpha; + D2D1_BLEND_OPERATION blendOperationAlpha; + float blendFactor[4]; +} D2D1_BLEND_DESCRIPTION; + +typedef struct D2D1_RESOURCE_TEXTURE_PROPERTIES +{ + const UINT32 *extents; + UINT32 dimensions; + D2D1_BUFFER_PRECISION bufferPrecision; + D2D1_CHANNEL_DEPTH channelDepth; + D2D1_FILTER filter; + const D2D1_EXTEND_MODE *extendModes; +} D2D1_RESOURCE_TEXTURE_PROPERTIES; + +typedef struct D2D1_INPUT_ELEMENT_DESC +{ + const char *semanticName; + UINT32 semanticIndex; + DXGI_FORMAT format; + UINT32 inputSlot; + UINT32 alignedByteOffset; +} D2D1_INPUT_ELEMENT_DESC; + +typedef struct D2D1_VERTEX_BUFFER_PROPERTIES +{ + UINT32 inputCount; + D2D1_VERTEX_USAGE usage; + const BYTE *data; + UINT32 byteWidth; +} D2D1_VERTEX_BUFFER_PROPERTIES; + +typedef struct D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES +{ + const BYTE *shaderBufferWithInputSignature; + UINT32 shaderBufferSize; + const D2D1_INPUT_ELEMENT_DESC *inputElements; + UINT32 elementCount; + UINT32 stride; +} D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES; + +[ + object, + uuid(9b8b1336-00a5-4668-92b7-ced5d8bf9b7b), + local, +] +interface ID2D1VertexBuffer : IUnknown +{ + HRESULT Map( + [out] BYTE **data, + [in] UINT32 size + ); + HRESULT Unmap(); +} + +[ + object, + uuid(688d15c3-02b0-438d-b13a-d1b44c32c39a), + local, +] +interface ID2D1ResourceTexture : IUnknown +{ + HRESULT Update( + [in] const UINT32 *min_extents, + [in] const UINT32 *max_extents, + [in] const UINT32 *strides, + [in] UINT32 dimensions, + [in] const BYTE *data, + [in] UINT32 data_size + ); +} + +[ + object, + uuid(519ae1bd-d19a-420d-b849-364f594776b7), + local, +] +interface ID2D1RenderInfo : IUnknown +{ + HRESULT SetInputDescription( + [in] UINT32 index, + [in] D2D1_INPUT_DESCRIPTION description + ); + HRESULT SetOutputBuffer( + [in] D2D1_BUFFER_PRECISION precision, + [in] D2D1_CHANNEL_DEPTH depth + ); + void SetCached( + [in] BOOL is_cached + ); + void SetInstructionCountHint( + [in] UINT32 count + ); +} + +[ + object, + uuid(693ce632-7f2f-45de-93fe-18d88b37aa21), + local, +] +interface ID2D1DrawInfo : ID2D1RenderInfo +{ + HRESULT SetPixelShaderConstantBuffer( + [in] const BYTE *buffer, + [in] UINT32 size + ); + HRESULT SetResourceTexture( + [in] UINT32 index, + [in] ID2D1ResourceTexture *texture + ); + HRESULT SetVertexShaderConstantBuffer( + [in] const BYTE *buffer, + [in] UINT32 size + ); + HRESULT SetPixelShader( + [in] REFGUID id, + [in] D2D1_PIXEL_OPTIONS options + ); + HRESULT SetVertexProcessing( + [in, optional] ID2D1VertexBuffer *buffer, + [in] D2D1_VERTEX_OPTIONS options, + [in, optional] const D2D1_BLEND_DESCRIPTION *description, + [in, optional] const D2D1_VERTEX_RANGE *range, + [in, optional] const GUID *shader + ); +} + +[ + object, + uuid(5598b14b-9fd7-48b7-9bdb-8f0964eb38bc), + local, +] +interface ID2D1ComputeInfo : ID2D1RenderInfo +{ + HRESULT SetComputeShaderconstantBuffer( + [in] const BYTE *buffer, + [in] UINT32 size + ); + HRESULT SetComputeShader( + [in] REFGUID id + ); + HRESULT SetResourceTexture( + [in] UINT32 index, + [in] ID2D1ResourceTexture *texture + ); +} + +[ + object, + uuid(b2efe1e7-729f-4102-949f-505fa21bf666), + local, +] +interface ID2D1TransformNode : IUnknown +{ + UINT32 GetInputCount(); +} + +[ + object, + uuid(13d29038-c3e6-4034-9081-13b53a417992), + local, +] +interface ID2D1TransformGraph : IUnknown +{ + UINT32 GetInputCount(); + HRESULT SetSingleTransformNode( + [in] ID2D1TransformNode *node + ); + HRESULT AddNode( + [in] ID2D1TransformNode *node + ); + HRESULT RemoveNode( + [in] ID2D1TransformNode *node + ); + HRESULT SetOutputNode( + [in] ID2D1TransformNode *node + ); + HRESULT ConnectNode( + [in] ID2D1TransformNode *from_node, + [in] ID2D1TransformNode *to_node, + [in] UINT32 index + ); + HRESULT ConnectToEffectInput( + [in] UINT32 input_index, + [in] ID2D1TransformNode *node, + [in] UINT32 node_index + ); + void Clear(); + HRESULT SetPassthroughGraph( + [in] UINT32 index + ); +} + +[ + object, + uuid(ef1a287d-342a-4f76-8fdb-da0d6ea9f92b), + local, +] +interface ID2D1Transform : ID2D1TransformNode +{ + HRESULT MapOutputRectToInputRects( + [in] const D2D1_RECT_L *output_rect, + [out] D2D1_RECT_L *input_rects, + [in] UINT32 input_rects_count + ); + HRESULT MapInputRectsToOutputRect( + [in] const D2D1_RECT_L *input_rects, + [in] const D2D1_RECT_L *input_opaque_rects, + [in] UINT32 input_rect_count, + [out] D2D1_RECT_L *output_rect, + [out] D2D1_RECT_L *output_opaque_rect + ); + HRESULT MapInvalidRect( + [in] UINT32 index, + [in] D2D1_RECT_L input_rect, + [out] D2D1_RECT_L *output_rect + ); +} + +[ + object, + uuid(36bfdcb6-9739-435d-a30d-a653beff6a6f), + local, +] +interface ID2D1DrawTransform : ID2D1Transform +{ + HRESULT SetDrawInfo( + [in] ID2D1DrawInfo *info + ); +} + +[ + object, + uuid(0d85573c-01e3-4f7d-bfd9-0d60608bf3c3), + local, +] +interface ID2D1ComputeTransform : ID2D1Transform +{ + HRESULT SetComputeInfo( + [in] ID2D1ComputeInfo *info + ); + HRESULT CalculateThreadgroups( + [in] const D2D1_RECT_L *output_rect, + [out] UINT32 *dimension_x, + [out] UINT32 *dimension_y, + [out] UINT32 *dimension_z + ); +} + +[ + object, + uuid(0359dc30-95e6-4568-9055-27720d130e93), + local, +] +interface ID2D1AnalysisTransform : IUnknown +{ + HRESULT ProcessAnalysisResults( + [in] const BYTE *data, + [in] UINT32 size + ); +} + +[ + object, + uuid(db1800dd-0c34-4cf9-be90-31cc0a5653e1), + local, +] +interface ID2D1SourceTransform : ID2D1Transform +{ + HRESULT SetRenderInfo( + [in] ID2D1RenderInfo *info + ); + HRESULT Draw( + [in] ID2D1Bitmap1 *target, + [in] const D2D1_RECT_L *draw_rect, + [in] D2D1_POINT_2U target_origin + ); +} + +[ + object, + uuid(1a799d8a-69f7-4e4c-9fed-437ccc6684cc), + local, +] +interface ID2D1ConcreteTransform : ID2D1TransformNode +{ + HRESULT SetOutputBuffer( + [in] D2D1_BUFFER_PRECISION precision, + [in] D2D1_CHANNEL_DEPTH depth + ); + void SetCached( + [in] BOOL is_cached + ); +} + +[ + object, + uuid(63ac0b32-ba44-450f-8806-7f4ca1ff2f1b), + local, +] +interface ID2D1BlendTransform : ID2D1ConcreteTransform +{ + void SetDescription( + [in] const D2D1_BLEND_DESCRIPTION *description + ); + void GetDescription( + [out] D2D1_BLEND_DESCRIPTION *description + ); +} + +[ + object, + uuid(4998735c-3a19-473c-9781-656847e3a347), + local, +] +interface ID2D1BorderTransform : ID2D1ConcreteTransform +{ + void SetExtendModeX( + [in] D2D1_EXTEND_MODE mode + ); + void SetExtendModeY( + [in] D2D1_EXTEND_MODE mode + ); + D2D1_EXTEND_MODE GetExtendModeX(); + D2D1_EXTEND_MODE GetExtendModeY(); +} + +[ + object, + uuid(3fe6adea-7643-4f53-bd14-a0ce63f24042), + local, +] +interface ID2D1OffsetTransform : ID2D1TransformNode +{ + void SetOffset( + [in] D2D1_POINT_2L offset + ); + D2D1_POINT_2L GetOffset(); +} + +[ + object, + uuid(90f732e2-5092-4606-a819-8651970baccd), + local, +] +interface ID2D1BoundsAdjustmentTransform : ID2D1TransformNode +{ + void SetOutputBounds( + [in] const D2D1_RECT_L *bounds + ); + void GetOutputBounds( + [out] D2D1_RECT_L *bounds + ); +} + +[ + object, + uuid(3d9f916b-27dc-4ad7-b4f1-64945340f563), + local, +] +interface ID2D1EffectContext : IUnknown +{ + void GetDpi( + [out] float *dpi_x, + [out] float *dpi_y + ); + HRESULT CreateEffect( + [in] REFCLSID clsid, + [out] ID2D1Effect **effect + ); + HRESULT GetMaximumSupportedFeatureLevel( + [in] const D3D_FEATURE_LEVEL *levels, + [in] UINT32 level_count, + [out] D3D_FEATURE_LEVEL *max_level + ); + HRESULT CreateTransformNodeFromEffect( + [in] ID2D1Effect *effect, + [out] ID2D1TransformNode **node + ); + HRESULT CreateBlendTransform( + [in] UINT32 num_inputs, + [in] const D2D1_BLEND_DESCRIPTION *description, + [out] ID2D1BlendTransform **transform + ); + HRESULT CreateBorderTransform( + [in] D2D1_EXTEND_MODE mode_x, + [in] D2D1_EXTEND_MODE mode_y, + [out] ID2D1BorderTransform **transform + ); + HRESULT CreateOffsetTransform( + [in] D2D1_POINT_2L offset, + [out] ID2D1OffsetTransform **transform + ); + HRESULT CreateBoundsAdjustmentTransform( + [in] const D2D1_RECT_L *output_rect, + [out] ID2D1BoundsAdjustmentTransform **transform + ); + HRESULT LoadPixelShader( + [in] REFGUID shader_id, + [in] const BYTE *buffer, + [in] UINT32 buffer_size + ); + HRESULT LoadVertexShader( + [in] REFGUID shader_id, + [in] const BYTE *buffer, + [in] UINT32 buffer_size + ); + HRESULT LoadComputeShader( + [in] REFGUID shader_id, + [in] const BYTE *buffer, + [in] UINT32 buffer_size + ); + BOOL IsShaderLoaded( + [in] REFGUID shader_id + ); + HRESULT CreateResourceTexture( + [in, optional] const GUID *id, + [in] const D2D1_RESOURCE_TEXTURE_PROPERTIES *texture_properties, + [in] const BYTE *data, + [in] const UINT32 *strides, + [in] UINT32 data_size, + [out] ID2D1ResourceTexture **texture + ); + HRESULT FindResourceTexture( + [in] const GUID *id, + [out] ID2D1ResourceTexture **texture + ); + HRESULT CreateVertexBuffer( + [in] const D2D1_VERTEX_BUFFER_PROPERTIES *buffer_properties, + [in, optional] const GUID *id, + [in, optional] const D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES *custom_buffer_properties, + [out] ID2D1VertexBuffer **buffer + ); + HRESULT FindVertexBuffer( + [in] const GUID *id, + [out] ID2D1VertexBuffer **buffer + ); + HRESULT CreateColorContext( + [in] D2D1_COLOR_SPACE space, + [in] const BYTE *profile, + [in] UINT32 profile_size, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromFilename( + [in] const WCHAR *filename, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromWicColorContext( + [in] IWICColorContext *wic_color_context, + [out] ID2D1ColorContext **color_context + ); + HRESULT CheckFeatureSupport( + [in] D2D1_FEATURE feature, + [out] void *data, + [in] UINT32 data_size + ); + BOOL IsBufferPrecisionSupported( + [in] D2D1_BUFFER_PRECISION precision + ); +} + +[ + object, + uuid(a248fd3f-3e6c-4e63-9f03-7f68ecc91db9), + local, +] +interface ID2D1EffectImpl : IUnknown +{ + HRESULT Initialize( + [in] ID2D1EffectContext *context, + [in] ID2D1TransformGraph *graph + ); + HRESULT PrepareForRender( + [in] D2D1_CHANGE_TYPE type + ); + HRESULT SetGraph( + [in] ID2D1TransformGraph *graph + ); +} diff --git a/WineFix/lib/d2d1/include/windows/d2d1effects.idl b/WineFix/lib/d2d1/include/windows/d2d1effects.idl new file mode 100644 index 0000000..9c795b6 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1effects.idl @@ -0,0 +1,199 @@ +/* + * Copyright 2021 Ziqing Hui for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +cpp_quote("DEFINE_GUID(CLSID_D2D12DAffineTransform, 0x6aa97485,0x6354,0x4cfc,0x90,0x8c,0xe4,0xa7,0x4f,0x62,0xc9,0x6c);") +cpp_quote("DEFINE_GUID(CLSID_D2D13DPerspectiveTransform, 0xc2844d0b,0x3d86,0x46e7,0x85,0xba,0x52,0x6c,0x92,0x40,0xf3,0xfb);") +cpp_quote("DEFINE_GUID(CLSID_D2D13DTransform, 0xe8467b04,0xec61,0x4b8a,0xb5,0xde,0xd4,0xd7,0x3d,0xeb,0xea,0x5a);") +cpp_quote("DEFINE_GUID(CLSID_D2D1ArithmeticComposite, 0xfc151437,0x049a,0x4784,0xa2,0x4a,0xf1,0xc4,0xda,0xf2,0x09,0x87);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Atlas, 0x913e2be4,0xfdcf,0x4fe2,0xa5,0xf0,0x24,0x54,0xf1,0x4f,0xf4,0x08);") +cpp_quote("DEFINE_GUID(CLSID_D2D1BitmapSource, 0x5fb6c24d,0xc6dd,0x4231,0x94,0x04,0x50,0xf4,0xd5,0xc3,0x25,0x2d);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Blend, 0x81c5b77b,0x13f8,0x4cdd,0xad,0x20,0xc8,0x90,0x54,0x7a,0xc6,0x5d);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Border, 0x2a2d49c0,0x4acf,0x43c7,0x8c,0x6a,0x7c,0x4a,0x27,0x87,0x4d,0x27);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Brightness, 0x8cea8d1e,0x77b0,0x4986,0xb3,0xb9,0x2f,0x0c,0x0e,0xae,0x78,0x87);") +cpp_quote("DEFINE_GUID(CLSID_D2D1ColorManagement, 0x1a28524c,0xfdd6,0x4aa4,0xae,0x8f,0x83,0x7e,0xb8,0x26,0x7b,0x37);") +cpp_quote("DEFINE_GUID(CLSID_D2D1ColorMatrix, 0x921f03d6,0x641c,0x47df,0x85,0x2d,0xb4,0xbb,0x61,0x53,0xae,0x11);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Composite, 0x48fc9f51,0xf6ac,0x48f1,0x8b,0x58,0x3b,0x28,0xac,0x46,0xf7,0x6d);") +cpp_quote("DEFINE_GUID(CLSID_D2D1ConvolveMatrix, 0x407f8c08,0x5533,0x4331,0xa3,0x41,0x23,0xcc,0x38,0x77,0x84,0x3e);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Crop, 0xe23f7110,0x0e9a,0x4324,0xaf,0x47,0x6a,0x2c,0x0c,0x46,0xf3,0x5b);") +cpp_quote("DEFINE_GUID(CLSID_D2D1DirectionalBlur, 0x174319a6,0x58e9,0x49b2,0xbb,0x63,0xca,0xf2,0xc8,0x11,0xa3,0xdb);") +cpp_quote("DEFINE_GUID(CLSID_D2D1DiscreteTransfer, 0x90866fcd,0x488e,0x454b,0xaf,0x06,0xe5,0x04,0x1b,0x66,0xc3,0x6c);") +cpp_quote("DEFINE_GUID(CLSID_D2D1DisplacementMap, 0xedc48364,0x0417,0x4111,0x94,0x50,0x43,0x84,0x5f,0xa9,0xf8,0x90);") +cpp_quote("DEFINE_GUID(CLSID_D2D1DistantDiffuse, 0x3e7efd62,0xa32d,0x46d4,0xa8,0x3c,0x52,0x78,0x88,0x9a,0xc9,0x54);") +cpp_quote("DEFINE_GUID(CLSID_D2D1DistantSpecular, 0x428c1ee5,0x77b8,0x4450,0x8a,0xb5,0x72,0x21,0x9c,0x21,0xab,0xda);") +cpp_quote("DEFINE_GUID(CLSID_D2D1DpiCompensation, 0x6c26c5c7,0x34e0,0x46fc,0x9c,0xfd,0xe5,0x82,0x37,0x6, 0xe2,0x28);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Flood, 0x61c23c20,0xae69,0x4d8e,0x94,0xcf,0x50,0x07,0x8d,0xf6,0x38,0xf2);") +cpp_quote("DEFINE_GUID(CLSID_D2D1GammaTransfer, 0x409444c4,0xc419,0x41a0,0xb0,0xc1,0x8c,0xd0,0xc0,0xa1,0x8e,0x42);") +cpp_quote("DEFINE_GUID(CLSID_D2D1GaussianBlur, 0x1feb6d69,0x2fe6,0x4ac9,0x8c,0x58,0x1d,0x7f,0x93,0xe7,0xa6,0xa5);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Scale, 0x9daf9369,0x3846,0x4d0e,0xa4,0x4e,0xc, 0x60,0x79,0x34,0xa5,0xd7);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Histogram, 0x881db7d0,0xf7ee,0x4d4d,0xa6,0xd2,0x46,0x97,0xac,0xc6,0x6e,0xe8);") +cpp_quote("DEFINE_GUID(CLSID_D2D1HueRotation, 0x0f4458ec,0x4b32,0x491b,0x9e,0x85,0xbd,0x73,0xf4,0x4d,0x3e,0xb6);") +cpp_quote("DEFINE_GUID(CLSID_D2D1LinearTransfer, 0xad47c8fd,0x63ef,0x4acc,0x9b,0x51,0x67,0x97,0x9c,0x03,0x6c,0x06);") +cpp_quote("DEFINE_GUID(CLSID_D2D1LuminanceToAlpha, 0x41251ab7,0x0beb,0x46f8,0x9d,0xa7,0x59,0xe9,0x3f,0xcc,0xe5,0xde);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Morphology, 0xeae6c40d,0x626a,0x4c2d,0xbf,0xcb,0x39,0x10,0x01,0xab,0xe2,0x02);") +cpp_quote("DEFINE_GUID(CLSID_D2D1OpacityMetadata, 0x6c53006a,0x4450,0x4199,0xaa,0x5b,0xad,0x16,0x56,0xfe,0xce,0x5e);") +cpp_quote("DEFINE_GUID(CLSID_D2D1PointDiffuse, 0xb9e303c3,0xc08c,0x4f91,0x8b,0x7b,0x38,0x65,0x6b,0xc4,0x8c,0x20);") +cpp_quote("DEFINE_GUID(CLSID_D2D1PointSpecular, 0x09c3ca26,0x3ae2,0x4f09,0x9e,0xbc,0xed,0x38,0x65,0xd5,0x3f,0x22);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Premultiply, 0x06eab419,0xdeed,0x4018,0x80,0xd2,0x3e,0x1d,0x47,0x1a,0xde,0xb2);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Saturation, 0x5cb2d9cf,0x327d,0x459f,0xa0,0xce,0x40,0xc0,0xb2,0x08,0x6b,0xf7);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Shadow, 0xc67ea361,0x1863,0x4e69,0x89,0xdb,0x69,0x5d,0x3e,0x9a,0x5b,0x6b);") +cpp_quote("DEFINE_GUID(CLSID_D2D1SpotDiffuse, 0x818a1105,0x7932,0x44f4,0xaa,0x86,0x08,0xae,0x7b,0x2f,0x2c,0x93);") +cpp_quote("DEFINE_GUID(CLSID_D2D1SpotSpecular, 0xedae421e,0x7654,0x4a37,0x9d,0xb8,0x71,0xac,0xc1,0xbe,0xb3,0xc1);") +cpp_quote("DEFINE_GUID(CLSID_D2D1TableTransfer, 0x5bf818c3,0x5e43,0x48cb,0xb6,0x31,0x86,0x83,0x96,0xd6,0xa1,0xd4);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Tile, 0xb0784138,0x3b76,0x4bc5,0xb1,0x3b,0x0f,0xa2,0xad,0x02,0x65,0x9f);") +cpp_quote("DEFINE_GUID(CLSID_D2D1Turbulence, 0xcf2bb6ae,0x889a,0x4ad7,0xba,0x29,0xa2,0xfd,0x73,0x2c,0x9f,0xc9);") +cpp_quote("DEFINE_GUID(CLSID_D2D1UnPremultiply, 0xfb9ac489,0xad8d,0x41ed,0x99,0x99,0xbb,0x63,0x47,0xd1,0x10,0xf7);") + +typedef enum D2D1_BORDER_MODE +{ + D2D1_BORDER_MODE_SOFT = 0x0, + D2D1_BORDER_MODE_HARD = 0x1, + D2D1_BORDER_MODE_FORCE_DWORD = 0xffffffff +} D2D1_BORDER_MODE; + +typedef enum D2D1_2DAFFINETRANSFORM_PROP +{ + D2D1_2DAFFINETRANSFORM_PROP_INTERPOLATION_MODE = 0x0, + D2D1_2DAFFINETRANSFORM_PROP_BORDER_MODE = 0x1, + D2D1_2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX = 0x2, + D2D1_2DAFFINETRANSFORM_PROP_SHARPNESS = 0x3, + D2D1_2DAFFINETRANSFORM_PROP_FORCE_DWORD = 0xffffffff +} D2D1_2DAFFINETRANSFORM_PROP; + +typedef enum D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE +{ + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = 0x0, + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR = 0x1, + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_CUBIC = 0x2, + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = 0x3, + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = 0x4, + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = 0x5, + D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff +} D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE; + +typedef enum D2D1_3DPERSPECTIVETRANSFORM_PROP +{ + D2D1_3DPERSPECTIVETRANSFORM_PROP_INTERPOLATION_MODE = 0x0, + D2D1_3DPERSPECTIVETRANSFORM_PROP_BORDER_MODE = 0x1, + D2D1_3DPERSPECTIVETRANSFORM_PROP_DEPTH = 0x2, + D2D1_3DPERSPECTIVETRANSFORM_PROP_PERSPECTIVE_ORIGIN = 0x3, + D2D1_3DPERSPECTIVETRANSFORM_PROP_LOCAL_OFFSET = 0x4, + D2D1_3DPERSPECTIVETRANSFORM_PROP_GLOBAL_OFFSET = 0x5, + D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION_ORIGIN = 0x6, + D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION = 0x7, + D2D1_3DPERSPECTIVETRANSFORM_PROP_FORCE_DWORD = 0xffffffff +} D2D1_3DPERSPECTIVETRANSFORM_PROP; + +typedef enum D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE +{ + D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = 0x0, + D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_LINEAR = 0x1, + D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_CUBIC = 0x2, + D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = 0x3, + D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = 0x4, + D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff +} D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE; + +typedef enum D2D1_COMPOSITE_PROP +{ + D2D1_COMPOSITE_PROP_MODE = 0x0, + D2D1_COMPOSITE_PROP_FORCE_DWORD = 0xffffffff +} D2D1_COMPOSITE_PROP; + +typedef enum D2D1_CROP_PROP +{ + D2D1_CROP_PROP_RECT = 0x0, + D2D1_CROP_PROP_BORDER_MODE = 0x1, + D2D1_CROP_PROP_FORCE_DWORD = 0xffffffff +} D2D1_CROP_PROP; + +typedef enum D2D1_BLEND_MODE +{ + D2D1_BLEND_MODE_MULTIPLY = 0x0, + D2D1_BLEND_MODE_SCREEN = 0x1, + D2D1_BLEND_MODE_DARKEN = 0x2, + D2D1_BLEND_MODE_LIGHTEN = 0x3, + D2D1_BLEND_MODE_DISSOLVE = 0x4, + D2D1_BLEND_MODE_COLOR_BURN = 0x5, + D2D1_BLEND_MODE_LINEAR_BURN = 0x6, + D2D1_BLEND_MODE_DARKER_COLOR = 0x7, + D2D1_BLEND_MODE_LIGHTER_COLOR = 0x8, + D2D1_BLEND_MODE_COLOR_DODGE = 0x9, + D2D1_BLEND_MODE_LINEAR_DODGE = 0xa, + D2D1_BLEND_MODE_OVERLAY = 0xb, + D2D1_BLEND_MODE_SOFT_LIGHT = 0xc, + D2D1_BLEND_MODE_HARD_LIGHT = 0xd, + D2D1_BLEND_MODE_VIVID_LIGHT = 0xe, + D2D1_BLEND_MODE_LINEAR_LIGHT = 0xf, + D2D1_BLEND_MODE_PIN_LIGHT = 0x10, + D2D1_BLEND_MODE_HARD_MIX = 0x11, + D2D1_BLEND_MODE_DIFFERENCE = 0x12, + D2D1_BLEND_MODE_EXCLUSION = 0x13, + D2D1_BLEND_MODE_HUE = 0x14, + D2D1_BLEND_MODE_SATURATION = 0x15, + D2D1_BLEND_MODE_COLOR = 0x16, + D2D1_BLEND_MODE_LUMINOSITY = 0x17, + D2D1_BLEND_MODE_SUBTRACT = 0x18, + D2D1_BLEND_MODE_DIVISION = 0x19, + D2D1_BLEND_MODE_FORCE_DWORD = 0xffffffff +} D2D1_BLEND_MODE; + +typedef enum D2D1_GAUSSIANBLUR_PROP +{ + D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION = 0, + D2D1_GAUSSIANBLUR_PROP_OPTIMIZATION = 1, + D2D1_GAUSSIANBLUR_PROP_BORDER_MODE = 2, + D2D1_GAUSSIANBLUR_PROP_FORCE_DWORD = 0xffffffff +} D2D1_GAUSSIANBLUR_PROP; + +typedef enum D2D1_GAUSSIANBLUR_OPTIMIZATION +{ + D2D1_GAUSSIANBLUR_OPTIMIZATION_SPEED = 0, + D2D1_GAUSSIANBLUR_OPTIMIZATION_BALANCED = 1, + D2D1_GAUSSIANBLUR_OPTIMIZATION_QUALITY = 2, + D2D1_GAUSSIANBLUR_OPTIMIZATION_FORCE_DWORD = 0xffffffff +} D2D1_GAUSSIANBLUR_OPTIMIZATION; + +typedef enum D2D1_POINTSPECULAR_PROP +{ + D2D1_POINTSPECULAR_PROP_LIGHT_POSITION = 0, + D2D1_POINTSPECULAR_PROP_SPECULAR_EXPONENT = 1, + D2D1_POINTSPECULAR_PROP_SPECULAR_CONSTANT = 2, + D2D1_POINTSPECULAR_PROP_SURFACE_SCALE = 3, + D2D1_POINTSPECULAR_PROP_COLOR = 4, + D2D1_POINTSPECULAR_PROP_KERNEL_UNIT_LENGTH = 5, + D2D1_POINTSPECULAR_PROP_SCALE_MODE = 6, + D2D1_POINTSPECULAR_PROP_FORCE_DWORD = 0xffffffff +} D2D1_POINTSPECULAR_PROP; + +typedef enum D2D1_POINTSPECULAR_SCALE_MODE +{ + D2D1_POINTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = 0, + D2D1_POINTSPECULAR_SCALE_MODE_LINEAR = 1, + D2D1_POINTSPECULAR_SCALE_MODE_CUBIC = 2, + D2D1_POINTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = 3, + D2D1_POINTSPECULAR_SCALE_MODE_ANISOTROPIC = 4, + D2D1_POINTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = 5, + D2D1_POINTSPECULAR_SCALE_MODE_FORCE_DWORD = 0xffffffff +} D2D1_POINTSPECULAR_SCALE_MODE; + +typedef enum D2D1_ARITHMETICCOMPOSITE_PROP +{ + D2D1_ARITHMETICCOMPOSITE_PROP_COEFFICIENTS = 0, + D2D1_ARITHMETICCOMPOSITE_PROP_CLAMP_OUTPUT = 1, + D2D1_ARITHMETICCOMPOSITE_PROP_FORCE_DWORD = 0xffffffff +} D2D1_ARITHMETICCOMPOSITE_PROP; diff --git a/WineFix/lib/d2d1/include/windows/d2d1effects_1.idl b/WineFix/lib/d2d1/include/windows/d2d1effects_1.idl new file mode 100644 index 0000000..03616b7 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1effects_1.idl @@ -0,0 +1,50 @@ +/* + * Copyright 2022 Ziqing Hui for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d2d1effects.idl"; + +cpp_quote("DEFINE_GUID(CLSID_D2D1YCbCr, 0x99503cc1,0x66c7,0x45c9,0xa8,0x75,0x8a,0xd8,0xa7,0x91,0x44,0x01);") + +typedef enum D2D1_YCBCR_PROP +{ + D2D1_YCBCR_PROP_CHROMA_SUBSAMPLING = 0x0, + D2D1_YCBCR_PROP_TRANSFORM_MATRIX = 0x1, + D2D1_YCBCR_PROP_INTERPOLATION_MODE = 0x2, + D2D1_YCBCR_PROP_FORCE_DWORD = 0xffffffff +} D2D1_YCBCR_PROP; + +typedef enum D2D1_YCBCR_CHROMA_SUBSAMPLING +{ + D2D1_YCBCR_CHROMA_SUBSAMPLING_AUTO = 0x0, + D2D1_YCBCR_CHROMA_SUBSAMPLING_420 = 0x1, + D2D1_YCBCR_CHROMA_SUBSAMPLING_422 = 0x2, + D2D1_YCBCR_CHROMA_SUBSAMPLING_444 = 0x3, + D2D1_YCBCR_CHROMA_SUBSAMPLING_440 = 0x4, + D2D1_YCBCR_CHROMA_SUBSAMPLING_FORCE_DWORD = 0xffffffff +} D2D1_YCBCR_CHROMA_SUBSAMPLING; + +typedef enum D2D1_YCBCR_INTERPOLATION_MODE +{ + D2D1_YCBCR_INTERPOLATION_MODE_NEAREST_NEIGHBOR = 0x0, + D2D1_YCBCR_INTERPOLATION_MODE_LINEAR = 0x1, + D2D1_YCBCR_INTERPOLATION_MODE_CUBIC = 0x2, + D2D1_YCBCR_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = 0x3, + D2D1_YCBCR_INTERPOLATION_MODE_ANISOTROPIC = 0x4, + D2D1_YCBCR_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = 0x5, + D2D1_YCBCR_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff +} D2D1_YCBCR_INTERPOLATION_MODE; diff --git a/WineFix/lib/d2d1/include/windows/d2d1effects_2.idl b/WineFix/lib/d2d1/include/windows/d2d1effects_2.idl new file mode 100644 index 0000000..9cd93a8 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d2d1effects_2.idl @@ -0,0 +1,39 @@ +/* + * Copyright 2022 Ziqing Hui for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d2d1effects_1.idl"; + +cpp_quote("DEFINE_GUID(CLSID_D2D1Grayscale, 0x36dde0eb,0x3725,0x42e0,0x83,0x6d,0x52,0xfb,0x20,0xae,0xe6,0x44);") +cpp_quote("DEFINE_GUID(CLSID_D2D1HighlightsShadows, 0xcadc8384,0x323f,0x4c7e,0xa3,0x61,0x2e,0x2b,0x24,0xdf,0x6e,0xe4);") + +typedef enum D2D1_HIGHLIGHTSANDSHADOWS_PROP +{ + D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS = 0x0, + D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS = 0x1, + D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY = 0x2, + D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA = 0x3, + D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS = 0x4, + D2D1_HIGHLIGHTSANDSHADOWS_PROP_FORCE_DWORD = 0xffffffff +} D2D1_HIGHLIGHTSANDSHADOWS_PROP; + +typedef enum D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA +{ + D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR = 0x0, + D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_SRGB = 0x1, + D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_FORCE_DWORD = 0xffffffff +} D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA; diff --git a/WineFix/lib/d2d1/include/windows/d3d.h b/WineFix/lib/d2d1/include/windows/d3d.h new file mode 100644 index 0000000..f118deb --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d.h @@ -0,0 +1,1568 @@ +/* + * Copyright (C) the Wine project + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D_H +#define __WINE_D3D_H + +#include + +#define COM_NO_WINDOWS_H +#include +#include /* must precede d3dcaps.h */ +#include + +/***************************************************************************** + * Predeclare the interfaces + */ +DEFINE_GUID(IID_IDirect3D, 0x3BBA0080,0x2421,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56); +DEFINE_GUID(IID_IDirect3D2, 0x6aae1ec1,0x662a,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a); +DEFINE_GUID(IID_IDirect3D3, 0xbb223240,0xe72b,0x11d0,0xa9,0xb4,0x00,0xaa,0x00,0xc0,0x99,0x3e); +DEFINE_GUID(IID_IDirect3D7, 0xf5049e77,0x4861,0x11d2,0xa4,0x07,0x00,0xa0,0xc9,0x06,0x29,0xa8); + +DEFINE_GUID(IID_IDirect3DRampDevice, 0xF2086B20,0x259F,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56); +DEFINE_GUID(IID_IDirect3DRGBDevice, 0xA4665C60,0x2673,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56); +DEFINE_GUID(IID_IDirect3DHALDevice, 0x84E63dE0,0x46AA,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E); +DEFINE_GUID(IID_IDirect3DMMXDevice, 0x881949a1,0xd6f3,0x11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29); +DEFINE_GUID(IID_IDirect3DRefDevice, 0x50936643,0x13e9,0x11d1,0x89,0xaa,0x00,0xa0,0xc9,0x05,0x41,0x29); +DEFINE_GUID(IID_IDirect3DTnLHalDevice, 0xf5049e78,0x4861,0x11d2,0xa4,0x07,0x00,0xa0,0xc9,0x06,0x29,0xa8); +DEFINE_GUID(IID_IDirect3DNullDevice, 0x8767df22,0xbacc,0x11d1,0x89,0x69,0x00,0xa0,0xc9,0x06,0x29,0xa8); + +DEFINE_GUID(IID_IDirect3DDevice, 0x64108800,0x957d,0x11D0,0x89,0xAB,0x00,0xA0,0xC9,0x05,0x41,0x29); +DEFINE_GUID(IID_IDirect3DDevice2, 0x93281501,0x8CF8,0x11D0,0x89,0xAB,0x00,0xA0,0xC9,0x05,0x41,0x29); +DEFINE_GUID(IID_IDirect3DDevice3, 0xb0ab3b60,0x33d7,0x11d1,0xa9,0x81,0x00,0xc0,0x4f,0xd7,0xb1,0x74); +DEFINE_GUID(IID_IDirect3DDevice7, 0xf5049e79,0x4861,0x11d2,0xa4,0x07,0x00,0xa0,0xc9,0x06,0x29,0xa8); + +DEFINE_GUID(IID_IDirect3DTexture, 0x2CDCD9E0,0x25A0,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56); +DEFINE_GUID(IID_IDirect3DTexture2, 0x93281502,0x8CF8,0x11D0,0x89,0xAB,0x00,0xA0,0xC9,0x05,0x41,0x29); + +DEFINE_GUID(IID_IDirect3DLight, 0x4417C142,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E); + +DEFINE_GUID(IID_IDirect3DMaterial, 0x4417C144,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E); +DEFINE_GUID(IID_IDirect3DMaterial2, 0x93281503,0x8CF8,0x11D0,0x89,0xAB,0x00,0xA0,0xC9,0x05,0x41,0x29); +DEFINE_GUID(IID_IDirect3DMaterial3, 0xca9c46f4,0xd3c5,0x11d1,0xb7,0x5a,0x00,0x60,0x08,0x52,0xb3,0x12); + +DEFINE_GUID(IID_IDirect3DExecuteBuffer, 0x4417C145,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E); + +DEFINE_GUID(IID_IDirect3DViewport, 0x4417C146,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E); +DEFINE_GUID(IID_IDirect3DViewport2, 0x93281500,0x8CF8,0x11D0,0x89,0xAB,0x00,0xA0,0xC9,0x05,0x41,0x29); +DEFINE_GUID(IID_IDirect3DViewport3, 0xb0ab3b61,0x33d7,0x11d1,0xa9,0x81,0x00,0xc0,0x4f,0xd7,0xb1,0x74); + +DEFINE_GUID(IID_IDirect3DVertexBuffer, 0x7a503555,0x4a83,0x11d1,0xa5,0xdb,0x00,0xa0,0xc9,0x03,0x67,0xf8); +DEFINE_GUID(IID_IDirect3DVertexBuffer7, 0xf5049e7d,0x4861,0x11d2,0xa4,0x07,0x00,0xa0,0xc9,0x06,0x29,0xa8); + + +typedef struct IDirect3D *LPDIRECT3D; +typedef struct IDirect3D2 *LPDIRECT3D2; +typedef struct IDirect3D3 *LPDIRECT3D3; +typedef struct IDirect3D7 *LPDIRECT3D7; + +typedef struct IDirect3DLight *LPDIRECT3DLIGHT; + +typedef struct IDirect3DDevice *LPDIRECT3DDEVICE; +typedef struct IDirect3DDevice2 *LPDIRECT3DDEVICE2; +typedef struct IDirect3DDevice3 *LPDIRECT3DDEVICE3; +typedef struct IDirect3DDevice7 *LPDIRECT3DDEVICE7; + +typedef struct IDirect3DViewport *LPDIRECT3DVIEWPORT; +typedef struct IDirect3DViewport2 *LPDIRECT3DVIEWPORT2; +typedef struct IDirect3DViewport3 *LPDIRECT3DVIEWPORT3; + +typedef struct IDirect3DMaterial *LPDIRECT3DMATERIAL; +typedef struct IDirect3DMaterial2 *LPDIRECT3DMATERIAL2; +typedef struct IDirect3DMaterial3 *LPDIRECT3DMATERIAL3; + +typedef struct IDirect3DTexture *LPDIRECT3DTEXTURE; +typedef struct IDirect3DTexture2 *LPDIRECT3DTEXTURE2; + +typedef struct IDirect3DExecuteBuffer *LPDIRECT3DEXECUTEBUFFER; + +typedef struct IDirect3DVertexBuffer *LPDIRECT3DVERTEXBUFFER; +typedef struct IDirect3DVertexBuffer7 *LPDIRECT3DVERTEXBUFFER7; + +/* ******************************************************************** + Error Codes + ******************************************************************** */ +#define D3D_OK DD_OK +#define D3DERR_BADMAJORVERSION MAKE_DDHRESULT(700) +#define D3DERR_BADMINORVERSION MAKE_DDHRESULT(701) +#define D3DERR_INVALID_DEVICE MAKE_DDHRESULT(705) +#define D3DERR_INITFAILED MAKE_DDHRESULT(706) +#define D3DERR_DEVICEAGGREGATED MAKE_DDHRESULT(707) +#define D3DERR_EXECUTE_CREATE_FAILED MAKE_DDHRESULT(710) +#define D3DERR_EXECUTE_DESTROY_FAILED MAKE_DDHRESULT(711) +#define D3DERR_EXECUTE_LOCK_FAILED MAKE_DDHRESULT(712) +#define D3DERR_EXECUTE_UNLOCK_FAILED MAKE_DDHRESULT(713) +#define D3DERR_EXECUTE_LOCKED MAKE_DDHRESULT(714) +#define D3DERR_EXECUTE_NOT_LOCKED MAKE_DDHRESULT(715) +#define D3DERR_EXECUTE_FAILED MAKE_DDHRESULT(716) +#define D3DERR_EXECUTE_CLIPPED_FAILED MAKE_DDHRESULT(717) +#define D3DERR_TEXTURE_NO_SUPPORT MAKE_DDHRESULT(720) +#define D3DERR_TEXTURE_CREATE_FAILED MAKE_DDHRESULT(721) +#define D3DERR_TEXTURE_DESTROY_FAILED MAKE_DDHRESULT(722) +#define D3DERR_TEXTURE_LOCK_FAILED MAKE_DDHRESULT(723) +#define D3DERR_TEXTURE_UNLOCK_FAILED MAKE_DDHRESULT(724) +#define D3DERR_TEXTURE_LOAD_FAILED MAKE_DDHRESULT(725) +#define D3DERR_TEXTURE_SWAP_FAILED MAKE_DDHRESULT(726) +#define D3DERR_TEXTURE_LOCKED MAKE_DDHRESULT(727) +#define D3DERR_TEXTURE_NOT_LOCKED MAKE_DDHRESULT(728) +#define D3DERR_TEXTURE_GETSURF_FAILED MAKE_DDHRESULT(729) +#define D3DERR_MATRIX_CREATE_FAILED MAKE_DDHRESULT(730) +#define D3DERR_MATRIX_DESTROY_FAILED MAKE_DDHRESULT(731) +#define D3DERR_MATRIX_SETDATA_FAILED MAKE_DDHRESULT(732) +#define D3DERR_MATRIX_GETDATA_FAILED MAKE_DDHRESULT(733) +#define D3DERR_SETVIEWPORTDATA_FAILED MAKE_DDHRESULT(734) +#define D3DERR_INVALIDCURRENTVIEWPORT MAKE_DDHRESULT(735) +#define D3DERR_INVALIDPRIMITIVETYPE MAKE_DDHRESULT(736) +#define D3DERR_INVALIDVERTEXTYPE MAKE_DDHRESULT(737) +#define D3DERR_TEXTURE_BADSIZE MAKE_DDHRESULT(738) +#define D3DERR_INVALIDRAMPTEXTURE MAKE_DDHRESULT(739) +#define D3DERR_MATERIAL_CREATE_FAILED MAKE_DDHRESULT(740) +#define D3DERR_MATERIAL_DESTROY_FAILED MAKE_DDHRESULT(741) +#define D3DERR_MATERIAL_SETDATA_FAILED MAKE_DDHRESULT(742) +#define D3DERR_MATERIAL_GETDATA_FAILED MAKE_DDHRESULT(743) +#define D3DERR_INVALIDPALETTE MAKE_DDHRESULT(744) +#define D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY MAKE_DDHRESULT(745) +#define D3DERR_ZBUFF_NEEDS_VIDEOMEMORY MAKE_DDHRESULT(746) +#define D3DERR_SURFACENOTINVIDMEM MAKE_DDHRESULT(747) +#define D3DERR_LIGHT_SET_FAILED MAKE_DDHRESULT(750) +#define D3DERR_LIGHTHASVIEWPORT MAKE_DDHRESULT(751) +#define D3DERR_LIGHTNOTINTHISVIEWPORT MAKE_DDHRESULT(752) +#define D3DERR_SCENE_IN_SCENE MAKE_DDHRESULT(760) +#define D3DERR_SCENE_NOT_IN_SCENE MAKE_DDHRESULT(761) +#define D3DERR_SCENE_BEGIN_FAILED MAKE_DDHRESULT(762) +#define D3DERR_SCENE_END_FAILED MAKE_DDHRESULT(763) +#define D3DERR_INBEGIN MAKE_DDHRESULT(770) +#define D3DERR_NOTINBEGIN MAKE_DDHRESULT(771) +#define D3DERR_NOVIEWPORTS MAKE_DDHRESULT(772) +#define D3DERR_VIEWPORTDATANOTSET MAKE_DDHRESULT(773) +#define D3DERR_VIEWPORTHASNODEVICE MAKE_DDHRESULT(774) +#define D3DERR_NOCURRENTVIEWPORT MAKE_DDHRESULT(775) +#define D3DERR_INVALIDVERTEXFORMAT MAKE_DDHRESULT(2048) +#define D3DERR_COLORKEYATTACHED MAKE_DDHRESULT(2050) +#define D3DERR_VERTEXBUFFEROPTIMIZED MAKE_DDHRESULT(2060) +#define D3DERR_VBUF_CREATE_FAILED MAKE_DDHRESULT(2061) +#define D3DERR_VERTEXBUFFERLOCKED MAKE_DDHRESULT(2062) +#define D3DERR_VERTEXBUFFERUNLOCKFAILED MAKE_DDHRESULT(2063) +#define D3DERR_ZBUFFER_NOTPRESENT MAKE_DDHRESULT(2070) +#define D3DERR_STENCILBUFFER_NOTPRESENT MAKE_DDHRESULT(2071) + +#define D3DERR_WRONGTEXTUREFORMAT MAKE_DDHRESULT(2072) +#define D3DERR_UNSUPPORTEDCOLOROPERATION MAKE_DDHRESULT(2073) +#define D3DERR_UNSUPPORTEDCOLORARG MAKE_DDHRESULT(2074) +#define D3DERR_UNSUPPORTEDALPHAOPERATION MAKE_DDHRESULT(2075) +#define D3DERR_UNSUPPORTEDALPHAARG MAKE_DDHRESULT(2076) +#define D3DERR_TOOMANYOPERATIONS MAKE_DDHRESULT(2077) +#define D3DERR_CONFLICTINGTEXTUREFILTER MAKE_DDHRESULT(2078) +#define D3DERR_UNSUPPORTEDFACTORVALUE MAKE_DDHRESULT(2079) +#define D3DERR_CONFLICTINGRENDERSTATE MAKE_DDHRESULT(2081) +#define D3DERR_UNSUPPORTEDTEXTUREFILTER MAKE_DDHRESULT(2082) +#define D3DERR_TOOMANYPRIMITIVES MAKE_DDHRESULT(2083) +#define D3DERR_INVALIDMATRIX MAKE_DDHRESULT(2084) +#define D3DERR_TOOMANYVERTICES MAKE_DDHRESULT(2085) +#define D3DERR_CONFLICTINGTEXTUREPALETTE MAKE_DDHRESULT(2086) + +#define D3DERR_INVALIDSTATEBLOCK MAKE_DDHRESULT(2100) +#define D3DERR_INBEGINSTATEBLOCK MAKE_DDHRESULT(2101) +#define D3DERR_NOTINBEGINSTATEBLOCK MAKE_DDHRESULT(2102) + +/* ******************************************************************** + Enums + ******************************************************************** */ +#define D3DNEXT_NEXT __MSABI_LONG(0x01) +#define D3DNEXT_HEAD __MSABI_LONG(0x02) +#define D3DNEXT_TAIL __MSABI_LONG(0x04) + +#define D3DDP_WAIT __MSABI_LONG(0x00000001) +#define D3DDP_OUTOFORDER __MSABI_LONG(0x00000002) +#define D3DDP_DONOTCLIP __MSABI_LONG(0x00000004) +#define D3DDP_DONOTUPDATEEXTENTS __MSABI_LONG(0x00000008) +#define D3DDP_DONOTLIGHT __MSABI_LONG(0x00000010) + +/* ******************************************************************** + Types and structures + ******************************************************************** */ +typedef DWORD D3DVIEWPORTHANDLE, *LPD3DVIEWPORTHANDLE; + + +/***************************************************************************** + * IDirect3D interface + */ +#undef INTERFACE +#define INTERFACE IDirect3D +DECLARE_INTERFACE_(IDirect3D,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3D methods ***/ + STDMETHOD(Initialize)(THIS_ REFIID riid) PURE; + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK cb, void *ctx) PURE; + STDMETHOD(CreateLight)(THIS_ struct IDirect3DLight **light, IUnknown *outer) PURE; + STDMETHOD(CreateMaterial)(THIS_ struct IDirect3DMaterial **material, IUnknown *outer) PURE; + STDMETHOD(CreateViewport)(THIS_ struct IDirect3DViewport **viewport, IUnknown *outer) PURE; + STDMETHOD(FindDevice)(THIS_ D3DFINDDEVICESEARCH *search, D3DFINDDEVICERESULT *result) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3D_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3D methods ***/ +#define IDirect3D_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3D_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D_CreateLight(p,a,b) (p)->lpVtbl->CreateLight(p,a,b) +#define IDirect3D_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3D_CreateViewport(p,a,b) (p)->lpVtbl->CreateViewport(p,a,b) +#define IDirect3D_FindDevice(p,a,b) (p)->lpVtbl->FindDevice(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3D_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D_AddRef(p) (p)->AddRef() +#define IDirect3D_Release(p) (p)->Release() +/*** IDirect3D methods ***/ +#define IDirect3D_Initialize(p,a) (p)->Initialize(a) +#define IDirect3D_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D_CreateLight(p,a,b) (p)->CreateLight(a,b) +#define IDirect3D_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3D_CreateViewport(p,a,b) (p)->CreateViewport(a,b) +#define IDirect3D_FindDevice(p,a,b) (p)->FindDevice(a,b) +#endif + + +/***************************************************************************** + * IDirect3D2 interface + */ +#define INTERFACE IDirect3D2 +DECLARE_INTERFACE_(IDirect3D2,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3D2 methods ***/ + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK cb, void *ctx) PURE; + STDMETHOD(CreateLight)(THIS_ struct IDirect3DLight **light, IUnknown *outer) PURE; + STDMETHOD(CreateMaterial)(THIS_ struct IDirect3DMaterial2 **material, IUnknown *outer) PURE; + STDMETHOD(CreateViewport)(THIS_ struct IDirect3DViewport2 **viewport, IUnknown *outer) PURE; + STDMETHOD(FindDevice)(THIS_ D3DFINDDEVICESEARCH *search, D3DFINDDEVICERESULT *result) PURE; + STDMETHOD(CreateDevice)(THIS_ REFCLSID rclsid, IDirectDrawSurface *surface, + struct IDirect3DDevice2 **device) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3D2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3D2 methods ***/ +#define IDirect3D2_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D2_CreateLight(p,a,b) (p)->lpVtbl->CreateLight(p,a,b) +#define IDirect3D2_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3D2_CreateViewport(p,a,b) (p)->lpVtbl->CreateViewport(p,a,b) +#define IDirect3D2_FindDevice(p,a,b) (p)->lpVtbl->FindDevice(p,a,b) +#define IDirect3D2_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3D2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D2_AddRef(p) (p)->AddRef() +#define IDirect3D2_Release(p) (p)->Release() +/*** IDirect3D2 methods ***/ +#define IDirect3D2_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D2_CreateLight(p,a,b) (p)->CreateLight(a,b) +#define IDirect3D2_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3D2_CreateViewport(p,a,b) (p)->CreateViewport(a,b) +#define IDirect3D2_FindDevice(p,a,b) (p)->FindDevice(a,b) +#define IDirect3D2_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#endif + + +/***************************************************************************** + * IDirect3D3 interface + */ +#define INTERFACE IDirect3D3 +DECLARE_INTERFACE_(IDirect3D3,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3D3 methods ***/ + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK cb, void *ctx) PURE; + STDMETHOD(CreateLight)(THIS_ struct IDirect3DLight **light, IUnknown *outer) PURE; + STDMETHOD(CreateMaterial)(THIS_ struct IDirect3DMaterial3 **material, IUnknown *outer) PURE; + STDMETHOD(CreateViewport)(THIS_ struct IDirect3DViewport3 **viewport, IUnknown *outer) PURE; + STDMETHOD(FindDevice)(THIS_ D3DFINDDEVICESEARCH *search, D3DFINDDEVICERESULT *result) PURE; + STDMETHOD(CreateDevice)(THIS_ REFCLSID rclsid, IDirectDrawSurface4 *surface, + struct IDirect3DDevice3 **device, IUnknown *outer) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ D3DVERTEXBUFFERDESC *desc, struct IDirect3DVertexBuffer **buffer, + DWORD flags, IUnknown *outer) PURE; + STDMETHOD(EnumZBufferFormats)(THIS_ REFCLSID device_iid, LPD3DENUMPIXELFORMATSCALLBACK cb, void *ctx) PURE; + STDMETHOD(EvictManagedTextures)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3D3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3D3 methods ***/ +#define IDirect3D3_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D3_CreateLight(p,a,b) (p)->lpVtbl->CreateLight(p,a,b) +#define IDirect3D3_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3D3_CreateViewport(p,a,b) (p)->lpVtbl->CreateViewport(p,a,b) +#define IDirect3D3_FindDevice(p,a,b) (p)->lpVtbl->FindDevice(p,a,b) +#define IDirect3D3_CreateDevice(p,a,b,c,d) (p)->lpVtbl->CreateDevice(p,a,b,c,d) +#define IDirect3D3_CreateVertexBuffer(p,a,b,c,d) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c,d) +#define IDirect3D3_EnumZBufferFormats(p,a,b,c) (p)->lpVtbl->EnumZBufferFormats(p,a,b,c) +#define IDirect3D3_EvictManagedTextures(p) (p)->lpVtbl->EvictManagedTextures(p) +#else +/*** IUnknown methods ***/ +#define IDirect3D3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D3_AddRef(p) (p)->AddRef() +#define IDirect3D3_Release(p) (p)->Release() +/*** IDirect3D3 methods ***/ +#define IDirect3D3_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D3_CreateLight(p,a,b) (p)->CreateLight(a,b) +#define IDirect3D3_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3D3_CreateViewport(p,a,b) (p)->CreateViewport(a,b) +#define IDirect3D3_FindDevice(p,a,b) (p)->FindDevice(a,b) +#define IDirect3D3_CreateDevice(p,a,b,c,d) (p)->CreateDevice(a,b,c,d) +#define IDirect3D3_CreateVertexBuffer(p,a,b,c,d) (p)->CreateVertexBuffer(a,b,c,d) +#define IDirect3D3_EnumZBufferFormats(p,a,b,c) (p)->EnumZBufferFormats(a,b,c) +#define IDirect3D3_EvictManagedTextures(p) (p)->EvictManagedTextures() +#endif + +/***************************************************************************** + * IDirect3D7 interface + */ +#define INTERFACE IDirect3D7 +DECLARE_INTERFACE_(IDirect3D7,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3D7 methods ***/ + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK7 cb, void *ctx) PURE; + STDMETHOD(CreateDevice)(THIS_ REFCLSID rclsid, IDirectDrawSurface7 *surface, + struct IDirect3DDevice7 **device) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ D3DVERTEXBUFFERDESC *desc, + struct IDirect3DVertexBuffer7 **buffer, DWORD flags) PURE; + STDMETHOD(EnumZBufferFormats)(THIS_ REFCLSID device_iid, LPD3DENUMPIXELFORMATSCALLBACK cb, void *ctx) PURE; + STDMETHOD(EvictManagedTextures)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3D7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D7_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3D3 methods ***/ +#define IDirect3D7_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D7_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirect3D7_CreateVertexBuffer(p,a,b,c) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c) +#define IDirect3D7_EnumZBufferFormats(p,a,b,c) (p)->lpVtbl->EnumZBufferFormats(p,a,b,c) +#define IDirect3D7_EvictManagedTextures(p) (p)->lpVtbl->EvictManagedTextures(p) +#else +/*** IUnknown methods ***/ +#define IDirect3D7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D7_AddRef(p) (p)->AddRef() +#define IDirect3D7_Release(p) (p)->Release() +/*** IDirect3D3 methods ***/ +#define IDirect3D7_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D7_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirect3D7_CreateVertexBuffer(p,a,b,c) (p)->CreateVertexBuffer(a,b,c) +#define IDirect3D7_EnumZBufferFormats(p,a,b,c) (p)->EnumZBufferFormats(a,b,c) +#define IDirect3D7_EvictManagedTextures(p) (p)->EvictManagedTextures() +#endif + + +/***************************************************************************** + * IDirect3DLight interface + */ +#define INTERFACE IDirect3DLight +DECLARE_INTERFACE_(IDirect3DLight,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DLight methods ***/ + STDMETHOD(Initialize)(THIS_ IDirect3D *d3d) PURE; + STDMETHOD(SetLight)(THIS_ D3DLIGHT *data) PURE; + STDMETHOD(GetLight)(THIS_ D3DLIGHT *data) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DLight_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DLight_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DLight_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DLight methods ***/ +#define IDirect3DLight_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DLight_SetLight(p,a) (p)->lpVtbl->SetLight(p,a) +#define IDirect3DLight_GetLight(p,a) (p)->lpVtbl->GetLight(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DLight_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DLight_AddRef(p) (p)->AddRef() +#define IDirect3DLight_Release(p) (p)->Release() +/*** IDirect3DLight methods ***/ +#define IDirect3DLight_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DLight_SetLight(p,a) (p)->SetLight(a) +#define IDirect3DLight_GetLight(p,a) (p)->GetLight(a) +#endif + + +/***************************************************************************** + * IDirect3DMaterial interface + */ +#define INTERFACE IDirect3DMaterial +DECLARE_INTERFACE_(IDirect3DMaterial,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DMaterial methods ***/ + STDMETHOD(Initialize)(THIS_ IDirect3D *d3d) PURE; + STDMETHOD(SetMaterial)(THIS_ D3DMATERIAL *data) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL *data) PURE; + STDMETHOD(GetHandle)(THIS_ struct IDirect3DDevice *device, D3DMATERIALHANDLE *handle) PURE; + STDMETHOD(Reserve)(THIS) PURE; + STDMETHOD(Unreserve)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DMaterial_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DMaterial_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DMaterial_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DMaterial methods ***/ +#define IDirect3DMaterial_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DMaterial_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DMaterial_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DMaterial_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#define IDirect3DMaterial_Reserve(p) (p)->lpVtbl->Reserve(p) +#define IDirect3DMaterial_Unreserve(p) (p)->lpVtbl->Unreserve(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DMaterial_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DMaterial_AddRef(p) (p)->AddRef() +#define IDirect3DMaterial_Release(p) (p)->Release() +/*** IDirect3DMaterial methods ***/ +#define IDirect3DMaterial_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DMaterial_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DMaterial_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DMaterial_GetHandle(p,a,b) (p)->GetHandle(a,b) +#define IDirect3DMaterial_Reserve(p) (p)->Reserve() +#define IDirect3DMaterial_Unreserve(p) (p)->Unreserve() +#endif + + +/***************************************************************************** + * IDirect3DMaterial2 interface + */ +#define INTERFACE IDirect3DMaterial2 +DECLARE_INTERFACE_(IDirect3DMaterial2,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DMaterial2 methods ***/ + STDMETHOD(SetMaterial)(THIS_ D3DMATERIAL *data) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL *data) PURE; + STDMETHOD(GetHandle)(THIS_ struct IDirect3DDevice2 *device, D3DMATERIALHANDLE *handle) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DMaterial2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DMaterial2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DMaterial2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DMaterial2 methods ***/ +#define IDirect3DMaterial2_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DMaterial2_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DMaterial2_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DMaterial2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DMaterial2_AddRef(p) (p)->AddRef() +#define IDirect3DMaterial2_Release(p) (p)->Release() +/*** IDirect3DMaterial2 methods ***/ +#define IDirect3DMaterial2_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DMaterial2_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DMaterial2_GetHandle(p,a,b) (p)->GetHandle(a,b) +#endif + + +/***************************************************************************** + * IDirect3DMaterial3 interface + */ +#define INTERFACE IDirect3DMaterial3 +DECLARE_INTERFACE_(IDirect3DMaterial3,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DMaterial3 methods ***/ + STDMETHOD(SetMaterial)(THIS_ D3DMATERIAL *data) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL *data) PURE; + STDMETHOD(GetHandle)(THIS_ struct IDirect3DDevice3 *device, D3DMATERIALHANDLE *handle) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DMaterial3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DMaterial3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DMaterial3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DMaterial3 methods ***/ +#define IDirect3DMaterial3_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DMaterial3_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DMaterial3_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DMaterial3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DMaterial3_AddRef(p) (p)->AddRef() +#define IDirect3DMaterial3_Release(p) (p)->Release() +/*** IDirect3DMaterial3 methods ***/ +#define IDirect3DMaterial3_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DMaterial3_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DMaterial3_GetHandle(p,a,b) (p)->GetHandle(a,b) +#endif + + +/***************************************************************************** + * IDirect3DTexture interface + */ +#define INTERFACE IDirect3DTexture +DECLARE_INTERFACE_(IDirect3DTexture,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DTexture methods ***/ + STDMETHOD(Initialize)(THIS_ struct IDirect3DDevice *device, IDirectDrawSurface *surface) PURE; + STDMETHOD(GetHandle)(THIS_ struct IDirect3DDevice *device, D3DTEXTUREHANDLE *handle) PURE; + STDMETHOD(PaletteChanged)(THIS_ DWORD dwStart, DWORD dwCount) PURE; + STDMETHOD(Load)(THIS_ IDirect3DTexture *texture) PURE; + STDMETHOD(Unload)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DTexture_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DTexture_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DTexture_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DTexture methods ***/ +#define IDirect3DTexture_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirect3DTexture_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#define IDirect3DTexture_PaletteChanged(p,a,b) (p)->lpVtbl->PaletteChanged(p,a,b) +#define IDirect3DTexture_Load(p,a) (p)->lpVtbl->Load(p,a) +#define IDirect3DTexture_Unload(p) (p)->lpVtbl->Unload(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DTexture_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DTexture_AddRef(p) (p)->AddRef() +#define IDirect3DTexture_Release(p) (p)->Release() +/*** IDirect3DTexture methods ***/ +#define IDirect3DTexture_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirect3DTexture_GetHandle(p,a,b) (p)->GetHandle(a,b) +#define IDirect3DTexture_PaletteChanged(p,a,b) (p)->PaletteChanged(a,b) +#define IDirect3DTexture_Load(p,a) (p)->Load(a) +#define IDirect3DTexture_Unload(p) (p)->Unload() +#endif + + +/***************************************************************************** + * IDirect3DTexture2 interface + */ +#define INTERFACE IDirect3DTexture2 +DECLARE_INTERFACE_(IDirect3DTexture2,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DTexture2 methods ***/ + STDMETHOD(GetHandle)(THIS_ struct IDirect3DDevice2 *device, D3DTEXTUREHANDLE *handle) PURE; + STDMETHOD(PaletteChanged)(THIS_ DWORD dwStart, DWORD dwCount) PURE; + STDMETHOD(Load)(THIS_ IDirect3DTexture2 *texture) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DTexture2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DTexture2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DTexture2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DTexture2 methods ***/ +#define IDirect3DTexture2_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#define IDirect3DTexture2_PaletteChanged(p,a,b) (p)->lpVtbl->PaletteChanged(p,a,b) +#define IDirect3DTexture2_Load(p,a) (p)->lpVtbl->Load(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DTexture2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DTexture2_AddRef(p) (p)->AddRef() +#define IDirect3DTexture2_Release(p) (p)->Release() +/*** IDirect3DTexture2 methods ***/ +#define IDirect3DTexture2_GetHandle(p,a,b) (p)->GetHandle(a,b) +#define IDirect3DTexture2_PaletteChanged(p,a,b) (p)->PaletteChanged(a,b) +#define IDirect3DTexture2_Load(p,a) (p)->Load(a) +#endif + + +/***************************************************************************** + * IDirect3DViewport interface + */ +#define INTERFACE IDirect3DViewport +DECLARE_INTERFACE_(IDirect3DViewport,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DViewport methods ***/ + STDMETHOD(Initialize)(THIS_ IDirect3D *d3d) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT *data) PURE; + STDMETHOD(SetViewport)(THIS_ D3DVIEWPORT *data) PURE; + STDMETHOD(TransformVertices)(THIS_ DWORD vertex_count, D3DTRANSFORMDATA *data, DWORD flags, DWORD *offscreen) PURE; + STDMETHOD(LightElements)(THIS_ DWORD element_count, D3DLIGHTDATA *data) PURE; + STDMETHOD(SetBackground)(THIS_ D3DMATERIALHANDLE hMat) PURE; + STDMETHOD(GetBackground)(THIS_ D3DMATERIALHANDLE *material, BOOL *valid) PURE; + STDMETHOD(SetBackgroundDepth)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(GetBackgroundDepth)(THIS_ IDirectDrawSurface **surface, BOOL *valid) PURE; + STDMETHOD(Clear)(THIS_ DWORD count, D3DRECT *rects, DWORD flags) PURE; + STDMETHOD(AddLight)(THIS_ IDirect3DLight *light) PURE; + STDMETHOD(DeleteLight)(THIS_ IDirect3DLight *light) PURE; + STDMETHOD(NextLight)(THIS_ IDirect3DLight *ref, IDirect3DLight **light, DWORD flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DViewport_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DViewport_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DViewport_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DViewport methods ***/ +#define IDirect3DViewport_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DViewport_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DViewport_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DViewport_TransformVertices(p,a,b,c,d) (p)->lpVtbl->TransformVertices(p,a,b,c,d) +#define IDirect3DViewport_LightElements(p,a,b) (p)->lpVtbl->LightElements(p,a,b) +#define IDirect3DViewport_SetBackground(p,a) (p)->lpVtbl->SetBackground(p,a) +#define IDirect3DViewport_GetBackground(p,a,b) (p)->lpVtbl->GetBackground(p,a,b) +#define IDirect3DViewport_SetBackgroundDepth(p,a) (p)->lpVtbl->SetBackgroundDepth(p,a) +#define IDirect3DViewport_GetBackgroundDepth(p,a,b) (p)->lpVtbl->GetBackgroundDepth(p,a,b) +#define IDirect3DViewport_Clear(p,a,b,c) (p)->lpVtbl->Clear(p,a,b,c) +#define IDirect3DViewport_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DViewport_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DViewport_NextLight(p,a,b,c) (p)->lpVtbl->NextLight(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DViewport_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DViewport_AddRef(p) (p)->AddRef() +#define IDirect3DViewport_Release(p) (p)->Release() +/*** IDirect3DViewport methods ***/ +#define IDirect3DViewport_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DViewport_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DViewport_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DViewport_TransformVertices(p,a,b,c,d) (p)->TransformVertices(a,b,c,d) +#define IDirect3DViewport_LightElements(p,a,b) (p)->LightElements(a,b) +#define IDirect3DViewport_SetBackground(p,a) (p)->SetBackground(a) +#define IDirect3DViewport_GetBackground(p,a,b) (p)->GetBackground(a,b) +#define IDirect3DViewport_SetBackgroundDepth(p,a) (p)->SetBackgroundDepth(a) +#define IDirect3DViewport_GetBackgroundDepth(p,a,b) (p)->GetBackgroundDepth(a,b) +#define IDirect3DViewport_Clear(p,a,b,c) (p)->Clear(a,b,c) +#define IDirect3DViewport_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DViewport_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DViewport_NextLight(p,a,b,c) (p)->NextLight(a,b,c) +#endif + + +/***************************************************************************** + * IDirect3DViewport2 interface + */ +#define INTERFACE IDirect3DViewport2 +DECLARE_INTERFACE_(IDirect3DViewport2,IDirect3DViewport) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DViewport methods ***/ + STDMETHOD(Initialize)(THIS_ IDirect3D *d3d) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT *data) PURE; + STDMETHOD(SetViewport)(THIS_ D3DVIEWPORT *data) PURE; + STDMETHOD(TransformVertices)(THIS_ DWORD vertex_count, D3DTRANSFORMDATA *data, DWORD flags, DWORD *offscreen) PURE; + STDMETHOD(LightElements)(THIS_ DWORD element_count, D3DLIGHTDATA *data) PURE; + STDMETHOD(SetBackground)(THIS_ D3DMATERIALHANDLE hMat) PURE; + STDMETHOD(GetBackground)(THIS_ D3DMATERIALHANDLE *material, BOOL *valid) PURE; + STDMETHOD(SetBackgroundDepth)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(GetBackgroundDepth)(THIS_ IDirectDrawSurface **surface, BOOL *valid) PURE; + STDMETHOD(Clear)(THIS_ DWORD count, D3DRECT *rects, DWORD flags) PURE; + STDMETHOD(AddLight)(THIS_ IDirect3DLight *light) PURE; + STDMETHOD(DeleteLight)(THIS_ IDirect3DLight *light) PURE; + STDMETHOD(NextLight)(THIS_ IDirect3DLight *ref, IDirect3DLight **light, DWORD flags) PURE; + /*** IDirect3DViewport2 methods ***/ + STDMETHOD(GetViewport2)(THIS_ D3DVIEWPORT2 *data) PURE; + STDMETHOD(SetViewport2)(THIS_ D3DVIEWPORT2 *data) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DViewport2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DViewport2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DViewport2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3Viewport methods ***/ +#define IDirect3DViewport2_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DViewport2_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DViewport2_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DViewport2_TransformVertices(p,a,b,c,d) (p)->lpVtbl->TransformVertices(p,a,b,c,d) +#define IDirect3DViewport2_LightElements(p,a,b) (p)->lpVtbl->LightElements(p,a,b) +#define IDirect3DViewport2_SetBackground(p,a) (p)->lpVtbl->SetBackground(p,a) +#define IDirect3DViewport2_GetBackground(p,a,b) (p)->lpVtbl->GetBackground(p,a,b) +#define IDirect3DViewport2_SetBackgroundDepth(p,a) (p)->lpVtbl->SetBackgroundDepth(p,a) +#define IDirect3DViewport2_GetBackgroundDepth(p,a,b) (p)->lpVtbl->GetBackgroundDepth(p,a,b) +#define IDirect3DViewport2_Clear(p,a,b,c) (p)->lpVtbl->Clear(p,a,b,c) +#define IDirect3DViewport2_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DViewport2_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DViewport2_NextLight(p,a,b,c) (p)->lpVtbl->NextLight(p,a,b,c) +/*** IDirect3DViewport2 methods ***/ +#define IDirect3DViewport2_GetViewport2(p,a) (p)->lpVtbl->GetViewport2(p,a) +#define IDirect3DViewport2_SetViewport2(p,a) (p)->lpVtbl->SetViewport2(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DViewport2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DViewport2_AddRef(p) (p)->AddRef() +#define IDirect3DViewport2_Release(p) (p)->Release() +/*** IDirect3Viewport methods ***/ +#define IDirect3DViewport2_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DViewport2_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DViewport2_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DViewport2_TransformVertices(p,a,b,c,d) (p)->TransformVertices(a,b,c,d) +#define IDirect3DViewport2_LightElements(p,a,b) (p)->LightElements(a,b) +#define IDirect3DViewport2_SetBackground(p,a) (p)->SetBackground(a) +#define IDirect3DViewport2_GetBackground(p,a,b) (p)->GetBackground(a,b) +#define IDirect3DViewport2_SetBackgroundDepth(p,a) (p)->SetBackgroundDepth(a) +#define IDirect3DViewport2_GetBackgroundDepth(p,a,b) (p)->GetBackgroundDepth(a,b) +#define IDirect3DViewport2_Clear(p,a,b,c) (p)->Clear(a,b,c) +#define IDirect3DViewport2_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DViewport2_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DViewport2_NextLight(p,a,b,c) (p)->NextLight(a,b,c) +/*** IDirect3DViewport2 methods ***/ +#define IDirect3DViewport2_GetViewport2(p,a) (p)->GetViewport2(a) +#define IDirect3DViewport2_SetViewport2(p,a) (p)->SetViewport2(a) +#endif + +/***************************************************************************** + * IDirect3DViewport3 interface + */ +#define INTERFACE IDirect3DViewport3 +DECLARE_INTERFACE_(IDirect3DViewport3,IDirect3DViewport2) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DViewport methods ***/ + STDMETHOD(Initialize)(THIS_ IDirect3D *d3d) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT *data) PURE; + STDMETHOD(SetViewport)(THIS_ D3DVIEWPORT *data) PURE; + STDMETHOD(TransformVertices)(THIS_ DWORD vertex_count, D3DTRANSFORMDATA *data, DWORD flags, DWORD *offscreen) PURE; + STDMETHOD(LightElements)(THIS_ DWORD element_count, D3DLIGHTDATA *data) PURE; + STDMETHOD(SetBackground)(THIS_ D3DMATERIALHANDLE hMat) PURE; + STDMETHOD(GetBackground)(THIS_ D3DMATERIALHANDLE *material, BOOL *valid) PURE; + STDMETHOD(SetBackgroundDepth)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(GetBackgroundDepth)(THIS_ IDirectDrawSurface **surface, BOOL *valid) PURE; + STDMETHOD(Clear)(THIS_ DWORD count, D3DRECT *rects, DWORD flags) PURE; + STDMETHOD(AddLight)(THIS_ IDirect3DLight *light) PURE; + STDMETHOD(DeleteLight)(THIS_ IDirect3DLight *light) PURE; + STDMETHOD(NextLight)(THIS_ IDirect3DLight *ref, IDirect3DLight **light, DWORD flags) PURE; + /*** IDirect3DViewport2 methods ***/ + STDMETHOD(GetViewport2)(THIS_ D3DVIEWPORT2 *data) PURE; + STDMETHOD(SetViewport2)(THIS_ D3DVIEWPORT2 *data) PURE; + /*** IDirect3DViewport3 methods ***/ + STDMETHOD(SetBackgroundDepth2)(THIS_ IDirectDrawSurface4 *surface) PURE; + STDMETHOD(GetBackgroundDepth2)(THIS_ IDirectDrawSurface4 **surface, BOOL *valid) PURE; + STDMETHOD(Clear2)(THIS_ DWORD count, D3DRECT *rects, DWORD flags, DWORD color, D3DVALUE z, DWORD stencil) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DViewport3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DViewport3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DViewport3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3Viewport methods ***/ +#define IDirect3DViewport3_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DViewport3_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DViewport3_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DViewport3_TransformVertices(p,a,b,c,d) (p)->lpVtbl->TransformVertices(p,a,b,c,d) +#define IDirect3DViewport3_LightElements(p,a,b) (p)->lpVtbl->LightElements(p,a,b) +#define IDirect3DViewport3_SetBackground(p,a) (p)->lpVtbl->SetBackground(p,a) +#define IDirect3DViewport3_GetBackground(p,a,b) (p)->lpVtbl->GetBackground(p,a,b) +#define IDirect3DViewport3_SetBackgroundDepth(p,a) (p)->lpVtbl->SetBackgroundDepth(p,a) +#define IDirect3DViewport3_GetBackgroundDepth(p,a,b) (p)->lpVtbl->GetBackgroundDepth(p,a,b) +#define IDirect3DViewport3_Clear(p,a,b,c) (p)->lpVtbl->Clear(p,a,b,c) +#define IDirect3DViewport3_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DViewport3_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DViewport3_NextLight(p,a,b,c) (p)->lpVtbl->NextLight(p,a,b,c) +/*** IDirect3DViewport2 methods ***/ +#define IDirect3DViewport3_GetViewport2(p,a) (p)->lpVtbl->GetViewport2(p,a) +#define IDirect3DViewport3_SetViewport2(p,a) (p)->lpVtbl->SetViewport2(p,a) +/*** IDirect3DViewport3 methods ***/ +#define IDirect3DViewport3_SetBackgroundDepth2(p,a) (p)->lpVtbl->SetBackgroundDepth2(p,a) +#define IDirect3DViewport3_GetBackgroundDepth2(p,a,b) (p)->lpVtbl->GetBackgroundDepth2(p,a,b) +#define IDirect3DViewport3_Clear2(p,a,b,c,d,e,f) (p)->lpVtbl->Clear2(p,a,b,c,d,e,f) +#else +/*** IUnknown methods ***/ +#define IDirect3DViewport3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DViewport3_AddRef(p) (p)->AddRef() +#define IDirect3DViewport3_Release(p) (p)->Release() +/*** IDirect3Viewport methods ***/ +#define IDirect3DViewport3_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DViewport3_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DViewport3_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DViewport3_TransformVertices(p,a,b,c,d) (p)->TransformVertices(a,b,c,d) +#define IDirect3DViewport3_LightElements(p,a,b) (p)->LightElements(a,b) +#define IDirect3DViewport3_SetBackground(p,a) (p)->SetBackground(a) +#define IDirect3DViewport3_GetBackground(p,a,b) (p)->GetBackground(a,b) +#define IDirect3DViewport3_SetBackgroundDepth(p,a) (p)->SetBackgroundDepth(a) +#define IDirect3DViewport3_GetBackgroundDepth(p,a,b) (p)->GetBackgroundDepth(a,b) +#define IDirect3DViewport3_Clear(p,a,b,c) (p)->Clear(a,b,c) +#define IDirect3DViewport3_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DViewport3_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DViewport3_NextLight(p,a,b,c) (p)->NextLight(a,b,c) +/*** IDirect3DViewport2 methods ***/ +#define IDirect3DViewport3_GetViewport2(p,a) (p)->GetViewport2(a) +#define IDirect3DViewport3_SetViewport2(p,a) (p)->SetViewport2(a) +/*** IDirect3DViewport3 methods ***/ +#define IDirect3DViewport3_SetBackgroundDepth2(p,a) (p)->SetBackgroundDepth2(a) +#define IDirect3DViewport3_GetBackgroundDepth2(p,a,b) (p)->GetBackgroundDepth2(a,b) +#define IDirect3DViewport3_Clear2(p,a,b,c,d,e,f) (p)->Clear2(a,b,c,d,e,f) +#endif + + + +/***************************************************************************** + * IDirect3DExecuteBuffer interface + */ +#define INTERFACE IDirect3DExecuteBuffer +DECLARE_INTERFACE_(IDirect3DExecuteBuffer,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DExecuteBuffer methods ***/ + STDMETHOD(Initialize)(THIS_ struct IDirect3DDevice *device, D3DEXECUTEBUFFERDESC *desc) PURE; + STDMETHOD(Lock)(THIS_ D3DEXECUTEBUFFERDESC *desc) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(SetExecuteData)(THIS_ D3DEXECUTEDATA *data) PURE; + STDMETHOD(GetExecuteData)(THIS_ D3DEXECUTEDATA *data) PURE; + STDMETHOD(Validate)(THIS_ DWORD *offset, LPD3DVALIDATECALLBACK cb, void *ctx, DWORD reserved) PURE; + STDMETHOD(Optimize)(THIS_ DWORD dwDummy) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DExecuteBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DExecuteBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DExecuteBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DExecuteBuffer methods ***/ +#define IDirect3DExecuteBuffer_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirect3DExecuteBuffer_Lock(p,a) (p)->lpVtbl->Lock(p,a) +#define IDirect3DExecuteBuffer_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DExecuteBuffer_SetExecuteData(p,a) (p)->lpVtbl->SetExecuteData(p,a) +#define IDirect3DExecuteBuffer_GetExecuteData(p,a) (p)->lpVtbl->GetExecuteData(p,a) +#define IDirect3DExecuteBuffer_Validate(p,a,b,c,d) (p)->lpVtbl->Validate(p,a,b,c,d) +#define IDirect3DExecuteBuffer_Optimize(p,a) (p)->lpVtbl->Optimize(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DExecuteBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DExecuteBuffer_AddRef(p) (p)->AddRef() +#define IDirect3DExecuteBuffer_Release(p) (p)->Release() +/*** IDirect3DExecuteBuffer methods ***/ +#define IDirect3DExecuteBuffer_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirect3DExecuteBuffer_Lock(p,a) (p)->Lock(a) +#define IDirect3DExecuteBuffer_Unlock(p) (p)->Unlock() +#define IDirect3DExecuteBuffer_SetExecuteData(p,a) (p)->SetExecuteData(a) +#define IDirect3DExecuteBuffer_GetExecuteData(p,a) (p)->GetExecuteData(a) +#define IDirect3DExecuteBuffer_Validate(p,a,b,c,d) (p)->Validate(a,b,c,d) +#define IDirect3DExecuteBuffer_Optimize(p,a) (p)->Optimize(a) +#endif + + +/***************************************************************************** + * IDirect3DDevice interface + */ +#define INTERFACE IDirect3DDevice +DECLARE_INTERFACE_(IDirect3DDevice,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DDevice methods ***/ + STDMETHOD(Initialize)(THIS_ IDirect3D *d3d, GUID *guid, D3DDEVICEDESC *desc) PURE; + STDMETHOD(GetCaps)(THIS_ D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc) PURE; + STDMETHOD(SwapTextureHandles)(THIS_ IDirect3DTexture *tex1, IDirect3DTexture *tex2) PURE; + STDMETHOD(CreateExecuteBuffer)(THIS_ D3DEXECUTEBUFFERDESC *desc, + IDirect3DExecuteBuffer **buffer, IUnknown *outer) PURE; + STDMETHOD(GetStats)(THIS_ D3DSTATS *stats) PURE; + STDMETHOD(Execute)(THIS_ IDirect3DExecuteBuffer *buffer, IDirect3DViewport *viewport, + DWORD flags) PURE; + STDMETHOD(AddViewport)(THIS_ IDirect3DViewport *viewport) PURE; + STDMETHOD(DeleteViewport)(THIS_ IDirect3DViewport *viewport) PURE; + STDMETHOD(NextViewport)(THIS_ IDirect3DViewport *ref, + IDirect3DViewport **viewport, DWORD flags) PURE; + STDMETHOD(Pick)(THIS_ IDirect3DExecuteBuffer *buffer, IDirect3DViewport *viewport, + DWORD flags, D3DRECT *rect) PURE; + STDMETHOD(GetPickRecords)(THIS_ DWORD *count, D3DPICKRECORD *records) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMTEXTUREFORMATSCALLBACK cb, void *ctx) PURE; + STDMETHOD(CreateMatrix)(THIS_ D3DMATRIXHANDLE *matrix) PURE; + STDMETHOD(SetMatrix)(THIS_ D3DMATRIXHANDLE handle, D3DMATRIX *matrix) PURE; + STDMETHOD(GetMatrix)(THIS_ D3DMATRIXHANDLE handle, D3DMATRIX *matrix) PURE; + STDMETHOD(DeleteMatrix)(THIS_ D3DMATRIXHANDLE D3DMatHandle) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D **d3d) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DDevice methods ***/ +#define IDirect3DDevice_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c) +#define IDirect3DDevice_GetCaps(p,a,b) (p)->lpVtbl->GetCaps(p,a,b) +#define IDirect3DDevice_SwapTextureHandles(p,a,b) (p)->lpVtbl->SwapTextureHandles(p,a,b) +#define IDirect3DDevice_CreateExecuteBuffer(p,a,b,c) (p)->lpVtbl->CreateExecuteBuffer(p,a,b,c) +#define IDirect3DDevice_GetStats(p,a) (p)->lpVtbl->GetStats(p,a) +#define IDirect3DDevice_Execute(p,a,b,c) (p)->lpVtbl->Execute(p,a,b,c) +#define IDirect3DDevice_AddViewport(p,a) (p)->lpVtbl->AddViewport(p,a) +#define IDirect3DDevice_DeleteViewport(p,a) (p)->lpVtbl->DeleteViewport(p,a) +#define IDirect3DDevice_NextViewport(p,a,b,c) (p)->lpVtbl->NextViewport(p,a,b,c) +#define IDirect3DDevice_Pick(p,a,b,c,d) (p)->lpVtbl->Pick(p,a,b,c,d) +#define IDirect3DDevice_GetPickRecords(p,a,b) (p)->lpVtbl->GetPickRecords(p,a,b) +#define IDirect3DDevice_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice_CreateMatrix(p,a) (p)->lpVtbl->CreateMatrix(p,a) +#define IDirect3DDevice_SetMatrix(p,a,b) (p)->lpVtbl->SetMatrix(p,a,b) +#define IDirect3DDevice_GetMatrix(p,a,b) (p)->lpVtbl->GetMatrix(p,a,b) +#define IDirect3DDevice_DeleteMatrix(p,a) (p)->lpVtbl->DeleteMatrix(p,a) +#define IDirect3DDevice_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice_AddRef(p) (p)->AddRef() +#define IDirect3DDevice_Release(p) (p)->Release() +/*** IDirect3DDevice methods ***/ +#define IDirect3DDevice_Initialize(p,a,b,c) (p)->Initialize(a,b,c) +#define IDirect3DDevice_GetCaps(p,a,b) (p)->GetCaps(a,b) +#define IDirect3DDevice_SwapTextureHandles(p,a,b) (p)->SwapTextureHandles(a,b) +#define IDirect3DDevice_CreateExecuteBuffer(p,a,b,c) (p)->CreateExecuteBuffer(a,b,c) +#define IDirect3DDevice_GetStats(p,a) (p)->GetStats(a) +#define IDirect3DDevice_Execute(p,a,b,c) (p)->Execute(a,b,c) +#define IDirect3DDevice_AddViewport(p,a) (p)->AddViewport(a) +#define IDirect3DDevice_DeleteViewport(p,a) (p)->DeleteViewport(a) +#define IDirect3DDevice_NextViewport(p,a,b,c) (p)->NextViewport(a,b,c) +#define IDirect3DDevice_Pick(p,a,b,c,d) (p)->Pick(a,b,c,d) +#define IDirect3DDevice_GetPickRecords(p,a,b) (p)->GetPickRecords(a,b) +#define IDirect3DDevice_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice_CreateMatrix(p,a) (p)->CreateMatrix(a) +#define IDirect3DDevice_SetMatrix(p,a,b) (p)->SetMatrix(a,b) +#define IDirect3DDevice_GetMatrix(p,a,b) (p)->GetMatrix(a,b) +#define IDirect3DDevice_DeleteMatrix(p,a) (p)->DeleteMatrix(a) +#define IDirect3DDevice_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice_EndScene(p) (p)->EndScene() +#define IDirect3DDevice_GetDirect3D(p,a) (p)->GetDirect3D(a) +#endif + + +/***************************************************************************** + * IDirect3DDevice2 interface + */ +#define INTERFACE IDirect3DDevice2 +DECLARE_INTERFACE_(IDirect3DDevice2,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DDevice2 methods ***/ + STDMETHOD(GetCaps)(THIS_ D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc) PURE; + STDMETHOD(SwapTextureHandles)(THIS_ IDirect3DTexture2 *tex1, IDirect3DTexture2 *tex2) PURE; + STDMETHOD(GetStats)(THIS_ D3DSTATS *stats) PURE; + STDMETHOD(AddViewport)(THIS_ IDirect3DViewport2 *viewport) PURE; + STDMETHOD(DeleteViewport)(THIS_ IDirect3DViewport2 *viewport) PURE; + STDMETHOD(NextViewport)(THIS_ IDirect3DViewport2 *ref, + IDirect3DViewport2 **viewport, DWORD flags) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMTEXTUREFORMATSCALLBACK cb, void *ctx) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D2 **d3d) PURE; + /*** DrawPrimitive API ***/ + STDMETHOD(SetCurrentViewport)(THIS_ IDirect3DViewport2 *viewport) PURE; + STDMETHOD(GetCurrentViewport)(THIS_ IDirect3DViewport2 **viewport) PURE; + STDMETHOD(SetRenderTarget)(THIS_ IDirectDrawSurface *surface, DWORD flags) PURE; + STDMETHOD(GetRenderTarget)(THIS_ IDirectDrawSurface **surface) PURE; + STDMETHOD(Begin)(THIS_ D3DPRIMITIVETYPE d3dpt,D3DVERTEXTYPE dwVertexTypeDesc,DWORD dwFlags) PURE; + STDMETHOD(BeginIndexed)(THIS_ D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, + void *vertices, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(Vertex)(THIS_ void *vertex) PURE; + STDMETHOD(Index)(THIS_ WORD wVertexIndex) PURE; + STDMETHOD(End)(THIS_ DWORD dwFlags) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState) PURE; + STDMETHOD(GetLightState)(THIS_ D3DLIGHTSTATETYPE dwLightStateType, LPDWORD lpdwLightState) PURE; + STDMETHOD(SetLightState)(THIS_ D3DLIGHTSTATETYPE dwLightStateType, DWORD dwLightState) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, + void *vertices, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, + void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags) PURE; + STDMETHOD(SetClipStatus)(THIS_ D3DCLIPSTATUS *clip_status) PURE; + STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS *clip_status) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DDevice2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DDevice2 methods ***/ +#define IDirect3DDevice2_GetCaps(p,a,b) (p)->lpVtbl->GetCaps(p,a,b) +#define IDirect3DDevice2_SwapTextureHandles(p,a,b) (p)->lpVtbl->SwapTextureHandles(p,a,b) +#define IDirect3DDevice2_GetStats(p,a) (p)->lpVtbl->GetStats(p,a) +#define IDirect3DDevice2_AddViewport(p,a) (p)->lpVtbl->AddViewport(p,a) +#define IDirect3DDevice2_DeleteViewport(p,a) (p)->lpVtbl->DeleteViewport(p,a) +#define IDirect3DDevice2_NextViewport(p,a,b,c) (p)->lpVtbl->NextViewport(p,a,b,c) +#define IDirect3DDevice2_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice2_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice2_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice2_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice2_SetCurrentViewport(p,a) (p)->lpVtbl->SetCurrentViewport(p,a) +#define IDirect3DDevice2_GetCurrentViewport(p,a) (p)->lpVtbl->GetCurrentViewport(p,a) +#define IDirect3DDevice2_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice2_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice2_Begin(p,a,b,c) (p)->lpVtbl->Begin(p,a,b,c) +#define IDirect3DDevice2_BeginIndexed(p,a,b,c,d,e) (p)->lpVtbl->BeginIndexed(p,a,b,c,d,e) +#define IDirect3DDevice2_Vertex(p,a) (p)->lpVtbl->Vertex(p,a) +#define IDirect3DDevice2_Index(p,a) (p)->lpVtbl->Index(p,a) +#define IDirect3DDevice2_End(p,a) (p)->lpVtbl->End(p,a) +#define IDirect3DDevice2_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice2_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice2_GetLightState(p,a,b) (p)->lpVtbl->GetLightState(p,a,b) +#define IDirect3DDevice2_SetLightState(p,a,b) (p)->lpVtbl->SetLightState(p,a,b) +#define IDirect3DDevice2_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice2_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice2_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice2_DrawPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice2_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f,g) +#define IDirect3DDevice2_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice2_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DDevice2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice2_AddRef(p) (p)->AddRef() +#define IDirect3DDevice2_Release(p) (p)->Release() +/*** IDirect3DDevice2 methods ***/ +#define IDirect3DDevice2_GetCaps(p,a,b) (p)->GetCaps(a,b) +#define IDirect3DDevice2_SwapTextureHandles(p,a,b) (p)->SwapTextureHandles(a,b) +#define IDirect3DDevice2_GetStats(p,a) (p)->GetStats(a) +#define IDirect3DDevice2_AddViewport(p,a) (p)->AddViewport(a) +#define IDirect3DDevice2_DeleteViewport(p,a) (p)->DeleteViewport(a) +#define IDirect3DDevice2_NextViewport(p,a,b,c) (p)->NextViewport(a,b,c) +#define IDirect3DDevice2_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice2_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice2_EndScene(p) (p)->EndScene() +#define IDirect3DDevice2_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice2_SetCurrentViewport(p,a) (p)->SetCurrentViewport(a) +#define IDirect3DDevice2_GetCurrentViewport(p,a) (p)->GetCurrentViewport(a) +#define IDirect3DDevice2_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice2_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice2_Begin(p,a,b,c) (p)->Begin(a,b,c) +#define IDirect3DDevice2_BeginIndexed(p,a,b,c,d,e) (p)->BeginIndexed(a,b,c,d,e) +#define IDirect3DDevice2_Vertex(p,a) (p)->Vertex(a) +#define IDirect3DDevice2_Index(p,a) (p)->Index(a) +#define IDirect3DDevice2_End(p,a) (p)->End(a) +#define IDirect3DDevice2_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice2_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice2_GetLightState(p,a,b) (p)->GetLightState(a,b) +#define IDirect3DDevice2_SetLightState(p,a,b) (p)->SetLightState(a,b) +#define IDirect3DDevice2_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice2_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice2_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice2_DrawPrimitive(p,a,b,c,d,e) (p)->DrawPrimitive(a,b,c,d,e) +#define IDirect3DDevice2_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitive(a,b,c,d,e,f,g) +#define IDirect3DDevice2_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice2_GetClipStatus(p,a) (p)->GetClipStatus(a) +#endif + +/***************************************************************************** + * IDirect3DDevice3 interface + */ +#define INTERFACE IDirect3DDevice3 +DECLARE_INTERFACE_(IDirect3DDevice3,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DDevice3 methods ***/ + STDMETHOD(GetCaps)(THIS_ D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc) PURE; + STDMETHOD(GetStats)(THIS_ D3DSTATS *stats) PURE; + STDMETHOD(AddViewport)(THIS_ IDirect3DViewport3 *viewport) PURE; + STDMETHOD(DeleteViewport)(THIS_ IDirect3DViewport3 *viewport) PURE; + STDMETHOD(NextViewport)(THIS_ IDirect3DViewport3 *ref, + IDirect3DViewport3 **viewport, DWORD flags) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMPIXELFORMATSCALLBACK cb, void *ctx) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D3 **d3d) PURE; + /*** DrawPrimitive API ***/ + STDMETHOD(SetCurrentViewport)(THIS_ IDirect3DViewport3 *viewport) PURE; + STDMETHOD(GetCurrentViewport)(THIS_ IDirect3DViewport3 **viewport) PURE; + STDMETHOD(SetRenderTarget)(THIS_ IDirectDrawSurface4 *surface, DWORD flags) PURE; + STDMETHOD(GetRenderTarget)(THIS_ IDirectDrawSurface4 **surface) PURE; + STDMETHOD(Begin)(THIS_ D3DPRIMITIVETYPE d3dptPrimitiveType,DWORD dwVertexTypeDesc, DWORD dwFlags) PURE; + STDMETHOD(BeginIndexed)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + void *vertices, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(Vertex)(THIS_ void *vertex) PURE; + STDMETHOD(Index)(THIS_ WORD wVertexIndex) PURE; + STDMETHOD(End)(THIS_ DWORD dwFlags) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState) PURE; + STDMETHOD(GetLightState)(THIS_ D3DLIGHTSTATETYPE dwLightStateType, LPDWORD lpdwLightState) PURE; + STDMETHOD(SetLightState)(THIS_ D3DLIGHTSTATETYPE dwLightStateType, DWORD dwLightState) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD vertex_type, + void *vertices, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags) PURE; + STDMETHOD(SetClipStatus)(THIS_ D3DCLIPSTATUS *clip_status) PURE; + STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS *clip_status) PURE; + STDMETHOD(DrawPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, WORD *indices, DWORD index_count, + DWORD flags) PURE; + STDMETHOD(DrawPrimitiveVB)(THIS_ D3DPRIMITIVETYPE primitive_type, struct IDirect3DVertexBuffer *vb, + DWORD start_vertex, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitiveVB)(THIS_ D3DPRIMITIVETYPE primitive_type, struct IDirect3DVertexBuffer *vb, + WORD *indices, DWORD index_count, DWORD flags) PURE; + STDMETHOD(ComputeSphereVisibility)(THIS_ D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, + DWORD flags, DWORD *ret) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD stage, IDirect3DTexture2 **texture) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD stage, IDirect3DTexture2 *texture) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD dwStage,D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,LPDWORD lpdwState) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD dwStage,D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,DWORD dwState) PURE; + STDMETHOD(ValidateDevice)(THIS_ LPDWORD lpdwPasses) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DDevice3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DDevice3 methods ***/ +#define IDirect3DDevice3_GetCaps(p,a,b) (p)->lpVtbl->GetCaps(p,a,b) +#define IDirect3DDevice3_GetStats(p,a) (p)->lpVtbl->GetStats(p,a) +#define IDirect3DDevice3_AddViewport(p,a) (p)->lpVtbl->AddViewport(p,a) +#define IDirect3DDevice3_DeleteViewport(p,a) (p)->lpVtbl->DeleteViewport(p,a) +#define IDirect3DDevice3_NextViewport(p,a,b,c) (p)->lpVtbl->NextViewport(p,a,b,c) +#define IDirect3DDevice3_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice3_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice3_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice3_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice3_SetCurrentViewport(p,a) (p)->lpVtbl->SetCurrentViewport(p,a) +#define IDirect3DDevice3_GetCurrentViewport(p,a) (p)->lpVtbl->GetCurrentViewport(p,a) +#define IDirect3DDevice3_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice3_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice3_Begin(p,a,b,c) (p)->lpVtbl->Begin(p,a,b,c) +#define IDirect3DDevice3_BeginIndexed(p,a,b,c,d,e) (p)->lpVtbl->BeginIndexed(p,a,b,c,d,e) +#define IDirect3DDevice3_Vertex(p,a) (p)->lpVtbl->Vertex(p,a) +#define IDirect3DDevice3_Index(p,a) (p)->lpVtbl->Index(p,a) +#define IDirect3DDevice3_End(p,a) (p)->lpVtbl->End(p,a) +#define IDirect3DDevice3_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice3_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice3_GetLightState(p,a,b) (p)->lpVtbl->GetLightState(p,a,b) +#define IDirect3DDevice3_SetLightState(p,a,b) (p)->lpVtbl->SetLightState(p,a,b) +#define IDirect3DDevice3_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice3_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice3_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice3_DrawPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f,g) +#define IDirect3DDevice3_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice3_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice3_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveStrided(p,a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) +#define IDirect3DDevice3_DrawPrimitiveVB(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveVB(p,a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveVB(p,a,b,c,d,e) (p)->lpVtbl->DrawIndexedPrimitiveVB(p,a,b,c,d,e) +#define IDirect3DDevice3_ComputeSphereVisibility(p,a,b,c,d,e) (p)->lpVtbl->ComputeSphereVisibility(p,a,b,c,d,e) +#define IDirect3DDevice3_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice3_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice3_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice3_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice3_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DDevice3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice3_AddRef(p) (p)->AddRef() +#define IDirect3DDevice3_Release(p) (p)->Release() +/*** IDirect3DDevice3 methods ***/ +#define IDirect3DDevice3_GetCaps(p,a,b) (p)->GetCaps(a,b) +#define IDirect3DDevice3_GetStats(p,a) (p)->GetStats(a) +#define IDirect3DDevice3_AddViewport(p,a) (p)->AddViewport(a) +#define IDirect3DDevice3_DeleteViewport(p,a) (p)->DeleteViewport(a) +#define IDirect3DDevice3_NextViewport(p,a,b,c) (p)->NextViewport(a,b,c) +#define IDirect3DDevice3_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice3_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice3_EndScene(p) (p)->EndScene() +#define IDirect3DDevice3_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice3_SetCurrentViewport(p,a) (p)->SetCurrentViewport(a) +#define IDirect3DDevice3_GetCurrentViewport(p,a) (p)->GetCurrentViewport(a) +#define IDirect3DDevice3_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice3_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice3_Begin(p,a,b,c) (p)->Begin(a,b,c) +#define IDirect3DDevice3_BeginIndexed(p,a,b,c,d,e) (p)->BeginIndexed(a,b,c,d,e) +#define IDirect3DDevice3_Vertex(p,a) (p)->Vertex(a) +#define IDirect3DDevice3_Index(p,a) (p)->Index(a) +#define IDirect3DDevice3_End(p,a) (p)->End(a) +#define IDirect3DDevice3_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice3_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice3_GetLightState(p,a,b) (p)->GetLightState(a,b) +#define IDirect3DDevice3_SetLightState(p,a,b) (p)->SetLightState(a,b) +#define IDirect3DDevice3_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice3_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice3_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice3_DrawPrimitive(p,a,b,c,d,e) (p)->DrawPrimitive(a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitive(a,b,c,d,e,f,g) +#define IDirect3DDevice3_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice3_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice3_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->DrawPrimitiveStrided(a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitiveStrided(a,b,c,d,e,f,g) +#define IDirect3DDevice3_DrawPrimitiveVB(p,a,b,c,d,e) (p)->DrawPrimitiveVB(a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveVB(p,a,b,c,d,e) (p)->DrawIndexedPrimitiveVB(a,b,c,d,e) +#define IDirect3DDevice3_ComputeSphereVisibility(p,a,b,c,d,e) (p)->ComputeSphereVisibility(a,b,c,d,e) +#define IDirect3DDevice3_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice3_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice3_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice3_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice3_ValidateDevice(p,a) (p)->ValidateDevice(a) +#endif + +/***************************************************************************** + * IDirect3DDevice7 interface + */ +#define INTERFACE IDirect3DDevice7 +DECLARE_INTERFACE_(IDirect3DDevice7,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DDevice7 methods ***/ + STDMETHOD(GetCaps)(THIS_ D3DDEVICEDESC7 *desc) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMPIXELFORMATSCALLBACK cb, void *ctx) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D7 **d3d) PURE; + STDMETHOD(SetRenderTarget)(THIS_ IDirectDrawSurface7 *surface, DWORD flags) PURE; + STDMETHOD(GetRenderTarget)(THIS_ IDirectDrawSurface7 **surface) PURE; + STDMETHOD(Clear)(THIS_ DWORD count, D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(SetViewport)(THIS_ D3DVIEWPORT7 *data) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT7 *data) PURE; + STDMETHOD(SetMaterial)(THIS_ D3DMATERIAL7 *data) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL7 *data) PURE; + STDMETHOD(SetLight)(THIS_ DWORD idx, D3DLIGHT7 *data) PURE; + STDMETHOD(GetLight)(THIS_ DWORD idx, D3DLIGHT7 *data) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState) PURE; + STDMETHOD(BeginStateBlock)(THIS) PURE; + STDMETHOD(EndStateBlock)(THIS_ LPDWORD lpdwBlockHandle) PURE; + STDMETHOD(PreLoad)(THIS_ IDirectDrawSurface7 *surface) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + void *vertices, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags) PURE; + STDMETHOD(SetClipStatus)(THIS_ D3DCLIPSTATUS *clip_status) PURE; + STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS *clip_status) PURE; + STDMETHOD(DrawPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE primitive_type, DWORD fvf, + D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, WORD *indices, DWORD index_count, + DWORD flags) PURE; + STDMETHOD(DrawPrimitiveVB)(THIS_ D3DPRIMITIVETYPE primitive_type, struct IDirect3DVertexBuffer7 *vb, + DWORD start_vertex, DWORD vertex_count, DWORD flags) PURE; + STDMETHOD(DrawIndexedPrimitiveVB)(THIS_ D3DPRIMITIVETYPE primitive_type, struct IDirect3DVertexBuffer7 *vb, + DWORD start_vertex, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags) PURE; + STDMETHOD(ComputeSphereVisibility)(THIS_ D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, + DWORD flags, DWORD *ret) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD stage, IDirectDrawSurface7 **surface) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD stage, IDirectDrawSurface7 *surface) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD dwStage,D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,LPDWORD lpdwState) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD dwStage,D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,DWORD dwState) PURE; + STDMETHOD(ValidateDevice)(THIS_ LPDWORD lpdwPasses) PURE; + STDMETHOD(ApplyStateBlock)(THIS_ DWORD dwBlockHandle) PURE; + STDMETHOD(CaptureStateBlock)(THIS_ DWORD dwBlockHandle) PURE; + STDMETHOD(DeleteStateBlock)(THIS_ DWORD dwBlockHandle) PURE; + STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE d3dsbType,LPDWORD lpdwBlockHandle) PURE; + STDMETHOD(Load)(THIS_ IDirectDrawSurface7 *dst_surface, POINT *dst_point, + IDirectDrawSurface7 *src_surface, RECT *src_rect, DWORD flags) PURE; + STDMETHOD(LightEnable)(THIS_ DWORD dwLightIndex,BOOL bEnable) PURE; + STDMETHOD(GetLightEnable)(THIS_ DWORD dwLightIndex,BOOL *pbEnable) PURE; + STDMETHOD(SetClipPlane)(THIS_ DWORD dwIndex,D3DVALUE *pPlaneEquation) PURE; + STDMETHOD(GetClipPlane)(THIS_ DWORD dwIndex,D3DVALUE *pPlaneEquation) PURE; + STDMETHOD(GetInfo)(THIS_ DWORD info_id, void *info, DWORD info_size) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DDevice7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice7_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DDevice7 methods ***/ +#define IDirect3DDevice7_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a) +#define IDirect3DDevice7_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice7_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice7_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice7_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice7_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice7_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice7_Clear(p,a,b,c,d,e,f) (p)->lpVtbl->Clear(p,a,b,c,d,e,f) +#define IDirect3DDevice7_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice7_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice7_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DDevice7_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice7_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DDevice7_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DDevice7_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DDevice7_SetLight(p,a,b) (p)->lpVtbl->SetLight(p,a,b) +#define IDirect3DDevice7_GetLight(p,a,b) (p)->lpVtbl->GetLight(p,a,b) +#define IDirect3DDevice7_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice7_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice7_BeginStateBlock(p) (p)->lpVtbl->BeginStateBlock(p) +#define IDirect3DDevice7_EndStateBlock(p,a) (p)->lpVtbl->EndStateBlock(p,a) +#define IDirect3DDevice7_PreLoad(p,a) (p)->lpVtbl->PreLoad(p,a) +#define IDirect3DDevice7_DrawPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f,g) +#define IDirect3DDevice7_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice7_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice7_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveStrided(p,a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) +#define IDirect3DDevice7_DrawPrimitiveVB(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveVB(p,a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveVB(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitiveVB(p,a,b,c,d,e,f,g) +#define IDirect3DDevice7_ComputeSphereVisibility(p,a,b,c,d,e) (p)->lpVtbl->ComputeSphereVisibility(p,a,b,c,d,e) +#define IDirect3DDevice7_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice7_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice7_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice7_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice7_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#define IDirect3DDevice7_ApplyStateBlock(p,a) (p)->lpVtbl->ApplyStateBlock(p,a) +#define IDirect3DDevice7_CaptureStateBlock(p,a) (p)->lpVtbl->CaptureStateBlock(p,a) +#define IDirect3DDevice7_DeleteStateBlock(p,a) (p)->lpVtbl->DeleteStateBlock(p,a) +#define IDirect3DDevice7_CreateStateBlock(p,a,b) (p)->lpVtbl->CreateStateBlock(p,a,b) +#define IDirect3DDevice7_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DDevice7_LightEnable(p,a,b) (p)->lpVtbl->LightEnable(p,a,b) +#define IDirect3DDevice7_GetLightEnable(p,a,b) (p)->lpVtbl->GetLightEnable(p,a,b) +#define IDirect3DDevice7_SetClipPlane(p,a,b) (p)->lpVtbl->SetClipPlane(p,a,b) +#define IDirect3DDevice7_GetClipPlane(p,a,b) (p)->lpVtbl->GetClipPlane(p,a,b) +#define IDirect3DDevice7_GetInfo(p,a,b,c) (p)->lpVtbl->GetInfo(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DDevice7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice7_AddRef(p) (p)->AddRef() +#define IDirect3DDevice7_Release(p) (p)->Release() +/*** IDirect3DDevice7 methods ***/ +#define IDirect3DDevice7_GetCaps(p,a) (p)->GetCaps(a) +#define IDirect3DDevice7_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice7_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice7_EndScene(p) (p)->EndScene() +#define IDirect3DDevice7_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice7_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice7_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice7_Clear(p,a,b,c,d,e,f) (p)->Clear(a,b,c,d,e,f) +#define IDirect3DDevice7_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice7_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice7_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DDevice7_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice7_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DDevice7_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DDevice7_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DDevice7_SetLight(p,a,b) (p)->SetLight(a,b) +#define IDirect3DDevice7_GetLight(p,a,b) (p)->GetLight(a,b) +#define IDirect3DDevice7_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice7_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice7_BeginStateBlock(p) (p)->BeginStateBlock() +#define IDirect3DDevice7_EndStateBlock(p,a) (p)->EndStateBlock(a) +#define IDirect3DDevice7_PreLoad(p,a) (p)->PreLoad(a) +#define IDirect3DDevice7_DrawPrimitive(p,a,b,c,d,e) (p)->DrawPrimitive(a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitive(a,b,c,d,e,f,g) +#define IDirect3DDevice7_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice7_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice7_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->DrawPrimitiveStrided(a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitiveStrided(a,b,c,d,e,f,g) +#define IDirect3DDevice7_DrawPrimitiveVB(p,a,b,c,d,e) (p)->DrawPrimitiveVB(a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveVB(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitiveVB(a,b,c,d,e,f,g) +#define IDirect3DDevice7_ComputeSphereVisibility(p,a,b,c,d,e) (p)->ComputeSphereVisibility(a,b,c,d,e) +#define IDirect3DDevice7_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice7_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice7_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice7_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice7_ValidateDevice(p,a) (p)->ValidateDevice(a) +#define IDirect3DDevice7_ApplyStateBlock(p,a) (p)->ApplyStateBlock(a) +#define IDirect3DDevice7_CaptureStateBlock(p,a) (p)->CaptureStateBlock(a) +#define IDirect3DDevice7_DeleteStateBlock(p,a) (p)->DeleteStateBlock(a) +#define IDirect3DDevice7_CreateStateBlock(p,a,b) (p)->CreateStateBlock(a,b) +#define IDirect3DDevice7_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DDevice7_LightEnable(p,a,b) (p)->LightEnable(a,b) +#define IDirect3DDevice7_GetLightEnable(p,a,b) (p)->GetLightEnable(a,b) +#define IDirect3DDevice7_SetClipPlane(p,a,b) (p)->SetClipPlane(a,b) +#define IDirect3DDevice7_GetClipPlane(p,a,b) (p)->GetClipPlane(a,b) +#define IDirect3DDevice7_GetInfo(p,a,b,c) (p)->GetInfo(a,b,c) +#endif + + + +/***************************************************************************** + * IDirect3DVertexBuffer interface + */ +#define INTERFACE IDirect3DVertexBuffer +DECLARE_INTERFACE_(IDirect3DVertexBuffer,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DVertexBuffer methods ***/ + STDMETHOD(Lock)(THIS_ DWORD flags, void **data, DWORD *data_size) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(ProcessVertices)(THIS_ DWORD vertex_op, DWORD dst_idx, DWORD count, + IDirect3DVertexBuffer *src_buffer, DWORD src_idx, + IDirect3DDevice3 *device, DWORD flags) PURE; + STDMETHOD(GetVertexBufferDesc)(THIS_ D3DVERTEXBUFFERDESC *desc) PURE; + STDMETHOD(Optimize)(THIS_ IDirect3DDevice3 *device, DWORD flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVertexBuffer methods ***/ +#define IDirect3DVertexBuffer_Lock(p,a,b,c) (p)->lpVtbl->Lock(p,a,b,c) +#define IDirect3DVertexBuffer_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DVertexBuffer_ProcessVertices(p,a,b,c,d,e,f,g) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer_GetVertexBufferDesc(p,a) (p)->lpVtbl->GetVertexBufferDesc(p,a) +#define IDirect3DVertexBuffer_Optimize(p,a,b) (p)->lpVtbl->Optimize(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexBuffer_AddRef(p) (p)->AddRef() +#define IDirect3DVertexBuffer_Release(p) (p)->Release() +/*** IDirect3DVertexBuffer methods ***/ +#define IDirect3DVertexBuffer_Lock(p,a,b,c) (p)->Lock(a,b,c) +#define IDirect3DVertexBuffer_Unlock(p) (p)->Unlock() +#define IDirect3DVertexBuffer_ProcessVertices(p,a,b,c,d,e,f,g) (p)->ProcessVertices(a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer_GetVertexBufferDesc(p,a) (p)->GetVertexBufferDesc(a) +#define IDirect3DVertexBuffer_Optimize(p,a,b) (p)->Optimize(a,b) +#endif + +/***************************************************************************** + * IDirect3DVertexBuffer7 interface + */ +#define INTERFACE IDirect3DVertexBuffer7 +DECLARE_INTERFACE_(IDirect3DVertexBuffer7,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DVertexBuffer7 methods ***/ + STDMETHOD(Lock)(THIS_ DWORD flags, void **data, DWORD *data_size) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(ProcessVertices)(THIS_ DWORD vertex_op, DWORD dst_idx, DWORD count, + IDirect3DVertexBuffer7 *src_buffer, DWORD src_idx, + IDirect3DDevice7 *device, DWORD flags) PURE; + STDMETHOD(GetVertexBufferDesc)(THIS_ D3DVERTEXBUFFERDESC *desc) PURE; + STDMETHOD(Optimize)(THIS_ IDirect3DDevice7 *device, DWORD flags) PURE; + STDMETHOD(ProcessVerticesStrided)(THIS_ DWORD vertex_op, DWORD dst_idx, DWORD count, + D3DDRAWPRIMITIVESTRIDEDDATA *data, DWORD fvf, IDirect3DDevice7 *device, DWORD flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexBuffer7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexBuffer7_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVertexBuffer7 methods ***/ +#define IDirect3DVertexBuffer7_Lock(p,a,b,c) (p)->lpVtbl->Lock(p,a,b,c) +#define IDirect3DVertexBuffer7_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DVertexBuffer7_ProcessVertices(p,a,b,c,d,e,f,g) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer7_GetVertexBufferDesc(p,a) (p)->lpVtbl->GetVertexBufferDesc(p,a) +#define IDirect3DVertexBuffer7_Optimize(p,a,b) (p)->lpVtbl->Optimize(p,a,b) +#define IDirect3DVertexBuffer7_ProcessVerticesStrided(p,a,b,c,d,e,f,g) (p)->lpVtbl->ProcessVerticesStrided(p,a,b,c,d,e,f,g) +#else +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexBuffer7_AddRef(p) (p)->AddRef() +#define IDirect3DVertexBuffer7_Release(p) (p)->Release() +/*** IDirect3DVertexBuffer7 methods ***/ +#define IDirect3DVertexBuffer7_Lock(p,a,b,c) (p)->Lock(a,b,c) +#define IDirect3DVertexBuffer7_Unlock(p) (p)->Unlock() +#define IDirect3DVertexBuffer7_ProcessVertices(p,a,b,c,d,e,f,g) (p)->ProcessVertices(a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer7_GetVertexBufferDesc(p,a) (p)->GetVertexBufferDesc(a) +#define IDirect3DVertexBuffer7_Optimize(p,a,b) (p)->Optimize(a,b) +#define IDirect3DVertexBuffer7_ProcessVerticesStrided(p,a,b,c,d,e,f,g) (p)->ProcessVerticesStrided(a,b,c,d,e,f,g) +#endif + +#endif /* __WINE_D3D_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3d10.idl b/WineFix/lib/d2d1/include/windows/d3d10.idl new file mode 100644 index 0000000..fb2fa91 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10.idl @@ -0,0 +1,1654 @@ +/* + * Copyright 2007 Andras Kovacs + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi.idl"; +import "d3dcommon.idl"; + +cpp_quote("#ifndef _D3D10_CONSTANTS") +cpp_quote("#define _D3D10_CONSTANTS") +const float D3D10_DEFAULT_BLEND_FACTOR_ALPHA = 1.0; +const float D3D10_DEFAULT_BLEND_FACTOR_BLUE = 1.0; +const float D3D10_DEFAULT_BLEND_FACTOR_GREEN = 1.0; +const float D3D10_DEFAULT_BLEND_FACTOR_RED = 1.0; +const float D3D10_DEFAULT_BORDER_COLOR_COMPONENT = 0.0; +const float D3D10_DEFAULT_SLOPE_SCALED_DEPTH_BIAS = 0.0; +const float D3D10_DEFAULT_DEPTH_BIAS_CLAMP = 0.0; +const float D3D10_DEFAULT_MAX_ANISOTROPY = 16.0; +const float D3D10_DEFAULT_MIP_LOD_BIAS = 0.0; +const float D3D10_DEFAULT_VIEWPORT_MAX_DEPTH = 0.0; +const float D3D10_DEFAULT_VIEWPORT_MIN_DEPTH = 0.0; +const float D3D10_FLOAT16_FUSED_TOLERANCE_IN_ULP = 0.6; +const float D3D10_FLOAT32_MAX = 3.402823466e+38; +const float D3D10_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP = 0.6; +const float D3D10_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR = 2.4; +const float D3D10_FLOAT_TO_SRGB_EXPONENT_NUMERATOR = 1.0; +const float D3D10_FLOAT_TO_SRGB_OFFSET = 0.055; +const float D3D10_FLOAT_TO_SRGB_SCALE_1 = 12.92; +const float D3D10_FLOAT_TO_SRGB_SCALE_2 = 1.055; +const float D3D10_FLOAT_TO_SRGB_THRESHOLD = 0.0031308; +const float D3D10_FTOI_INSTRUCTION_MAX_INPUT = 2147483647.999; +const float D3D10_FTOI_INSTRUCTION_MIN_INPUT = -2147483648.999; +const float D3D10_FTOU_INSTRUCTION_MAX_INPUT = 4294967295.999; +const float D3D10_FTOU_INSTRUCTION_MIN_INPUT = 0.0; +const float D3D10_LINEAR_GAMMA = 1.0; +const float D3D10_MAX_BORDER_COLOR_COMPONENT = 1.0; +const float D3D10_MAX_DEPTH = 1.0; +const float D3D10_MAX_POSITION_VALUE = 3.402823466e+34; +const float D3D10_MIN_BORDER_COLOR_COMPONENT = 0.0; +const float D3D10_MIN_DEPTH = 0.0; +const float D3D10_MIP_LOD_BIAS_MAX = 15.99; +const float D3D10_MIP_LOD_BIAS_MIN = -16.0; +const float D3D10_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.5; +const float D3D10_MULTISAMPLE_ANTIALIAS_LINE_WIDTH = 1.4; +const float D3D10_SRGB_GAMMA = 2.2; +const float D3D10_SRGB_TO_FLOAT_DENOMINATOR_1 = 12.92; +const float D3D10_SRGB_TO_FLOAT_DENOMINATOR_2 = 1.055; +const float D3D10_SRGB_TO_FLOAT_EXPONENT = 2.4; +const float D3D10_SRGB_TO_FLOAT_OFFSET = 0.055; +const float D3D10_SRGB_TO_FLOAT_THRESHOLD = 0.04045; +const float D3D10_SRGB_TO_FLOAT_TOLERANCE_IN_ULP = 0.5; +const float D3D10_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.0; +const float D3D_SPEC_VERSION = 1.050005; +const unsigned int D3D10_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff; +const unsigned int D3D10_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff; +const unsigned int D3D10_8BIT_INDEX_STRIP_CUT_VALUE = 0xff; +const unsigned int D3D10_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; +const unsigned int D3D10_CLIP_OR_CULL_DISTANCE_COUNT = 8; +const unsigned int D3D10_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const unsigned int D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; +const unsigned int D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; +const unsigned int D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const unsigned int D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; +const unsigned int D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; +const unsigned int D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; +const unsigned int D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; +const unsigned int D3D10_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; +const unsigned int D3D10_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; +const unsigned int D3D10_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; +const unsigned int D3D10_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; +const unsigned int D3D10_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; +const unsigned int D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; +const unsigned int D3D10_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; +const unsigned int D3D10_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; +const unsigned int D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; +const int D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; +const int D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; +const unsigned int D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; +const unsigned int D3D10_DEFAULT_DEPTH_BIAS = 0; +const unsigned int D3D10_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; +const unsigned int D3D10_DEFAULT_SAMPLE_MASK = 0xffffffff; +const unsigned int D3D10_DEFAULT_SCISSOR_ENDX = 0; +const unsigned int D3D10_DEFAULT_SCISSOR_ENDY = 0; +const unsigned int D3D10_DEFAULT_SCISSOR_STARTX = 0; +const unsigned int D3D10_DEFAULT_SCISSOR_STARTY = 0; +const unsigned int D3D10_DEFAULT_STENCIL_READ_MASK = 0xff; +const unsigned int D3D10_DEFAULT_STENCIL_REFERENCE = 0; +const unsigned int D3D10_DEFAULT_STENCIL_WRITE_MASK = 0xff; +const unsigned int D3D10_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; +const unsigned int D3D10_DEFAULT_VIEWPORT_HEIGHT = 0; +const unsigned int D3D10_DEFAULT_VIEWPORT_TOPLEFTX = 0; +const unsigned int D3D10_DEFAULT_VIEWPORT_TOPLEFTY = 0; +const unsigned int D3D10_DEFAULT_VIEWPORT_WIDTH = 0; +const unsigned int D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1; +const unsigned int D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1; +const unsigned int D3D10_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2; +const unsigned int D3D10_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_GS_INPUT_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT =32; +const unsigned int D3D10_GS_INPUT_REGISTER_COUNT = 16; +const unsigned int D3D10_GS_INPUT_REGISTER_READS_PER_INST = 2; +const unsigned int D3D10_GS_INPUT_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_GS_INPUT_REGISTER_VERTICES = 6; +const unsigned int D3D10_GS_OUTPUT_ELEMENTS = 32; +const unsigned int D3D10_GS_OUTPUT_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_GS_OUTPUT_REGISTER_COUNT = 32; +const unsigned int D3D10_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; +const unsigned int D3D10_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; +const unsigned int D3D10_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; +const unsigned int D3D10_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; +const unsigned int D3D10_IA_INSTANCE_ID_BIT_COUNT = 32; +const unsigned int D3D10_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; +const unsigned int D3D10_IA_PRIMITIVE_ID_BIT_COUNT = 32; +const unsigned int D3D10_IA_VERTEX_ID_BIT_COUNT = 32; +const unsigned int D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 16; +const unsigned int D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 64; +const unsigned int D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 16; +const unsigned int D3D10_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff; +const unsigned int D3D10_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff; +const unsigned int D3D10_MAX_MAXANISOTROPY = 16; +const unsigned int D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; +const unsigned int D3D10_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17; +const unsigned int D3D10_MIN_MAXANISOTROPY = 0; +const unsigned int D3D10_MIP_LOD_FRACTIONAL_BIT_COUNT = 6; +const unsigned int D3D10_MIP_LOD_RANGE_BIT_COUNT = 8; +const unsigned int D3D10_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0; +const unsigned int D3D10_PIXEL_ADDRESS_RANGE_BIT_COUNT = 13; +const unsigned int D3D10_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; +const unsigned int D3D10_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff; +const unsigned int D3D10_PS_FRONTFACING_FALSE_VALUE = 0; +const unsigned int D3D10_PS_FRONTFACING_TRUE_VALUE = 0xffffffff; +const unsigned int D3D10_PS_INPUT_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_PS_INPUT_REGISTER_COUNT = 32; +const unsigned int D3D10_PS_INPUT_REGISTER_READS_PER_INST = 2; +const unsigned int D3D10_PS_INPUT_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; +const unsigned int D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; +const unsigned int D3D10_PS_OUTPUT_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_PS_OUTPUT_REGISTER_COUNT = 8; +const unsigned int D3D10_REQ_BLEND_OBJECT_COUNT_PER_CONTEXT = 4096; +const unsigned int D3D10_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; +const unsigned int D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const unsigned int D3D10_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_CONTEXT = 4096; +const unsigned int D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; +const unsigned int D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; +const unsigned int D3D10_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 8192; +const unsigned int D3D10_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; +const unsigned int D3D10_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const unsigned int D3D10_REQ_MAXANISOTROPY = 16; +const unsigned int D3D10_REQ_MIP_LEVELS = 14; +const unsigned int D3D10_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; +const unsigned int D3D10_REQ_RASTERIZER_OBJECT_COUNT_PER_CONTEXT = 4096; +const unsigned int D3D10_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 8192; +const unsigned int D3D10_REQ_RESOURCE_SIZE_IN_MEGABYTES = 128; +const unsigned int D3D10_REQ_RESOURCE_VIEW_COUNT_PER_CONTEXT_2_TO_EXP = 20; +const unsigned int D3D10_REQ_SAMPLER_OBJECT_COUNT_PER_CONTEXT = 4096; +const unsigned int D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 512; +const unsigned int D3D10_REQ_TEXTURE1D_U_DIMENSION = 8192; +const unsigned int D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 512; +const unsigned int D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION = 8192; +const unsigned int D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; +const unsigned int D3D10_REQ_TEXTURECUBE_DIMENSION = 8192; +const unsigned int D3D10_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; +const unsigned int D3D10_SHADER_MAJOR_VERSION = 4; +const unsigned int D3D10_SHADER_MINOR_VERSION = 0; +const unsigned int D3D10_SHIFT_INSTRUCTION_PAD_VALUE = 0; +const unsigned int D3D10_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; +const unsigned int D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; +const unsigned int D3D10_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; +const unsigned int D3D10_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 256; +const unsigned int D3D10_SO_BUFFER_SLOT_COUNT = 4; +const unsigned int D3D10_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff; +const unsigned int D3D10_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER = 1; +const unsigned int D3D10_SO_SINGLE_BUFFER_COMPONENT_LIMIT = 64; +const unsigned int D3D10_STANDARD_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; +const unsigned int D3D10_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; +const unsigned int D3D10_STANDARD_PIXEL_COMPONENT_COUNT = 128; +const unsigned int D3D10_STANDARD_PIXEL_ELEMENT_COUNT = 32; +const unsigned int D3D10_STANDARD_VECTOR_SIZE = 4; +const unsigned int D3D10_STANDARD_VERTEX_ELEMENT_COUNT = 16; +const unsigned int D3D10_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; +const unsigned int D3D10_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; +const unsigned int D3D10_SUBTEXEL_FRACTIONAL_BIT_COUNT = 6; +const unsigned int D3D10_TEXEL_ADDRESS_RANGE_BIT_COUNT = 18; +const unsigned int D3D10_UNBOUND_MEMORY_ACCESS_RESULT = 0; +const unsigned int D3D10_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; +const unsigned int D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; +const unsigned int D3D10_VIEWPORT_BOUNDS_MAX = 16383; +const int D3D10_VIEWPORT_BOUNDS_MIN = -16384; +const unsigned int D3D10_VS_INPUT_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_VS_INPUT_REGISTER_COUNT = 16; +const unsigned int D3D10_VS_INPUT_REGISTER_READS_PER_INST = 2; +const unsigned int D3D10_VS_INPUT_REGISTER_READ_PORTS = 1; +const unsigned int D3D10_VS_OUTPUT_REGISTER_COMPONENTS = 4; +const unsigned int D3D10_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const unsigned int D3D10_VS_OUTPUT_REGISTER_COUNT = 16; +const unsigned int D3D10_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10; +const unsigned int D3D10_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25; +const unsigned int D3D10_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25; +const unsigned int D3D_MAJOR_VERSION = 10; +const unsigned int D3D_MINOR_VERSION = 0; +const unsigned int D3D_SPEC_DATE_DAY = 8; +const unsigned int D3D_SPEC_DATE_MONTH = 8; +const unsigned int D3D_SPEC_DATE_YEAR = 2006; +cpp_quote("#endif") + +const unsigned int D3D10_APPEND_ALIGNED_ELEMENT = 0xffffffff; +const unsigned int _FACD3D10 = 0x879; +const unsigned int _FACD3D10DEBUG = _FACD3D10 + 1; +const unsigned int D3D10_FILTER_TYPE_MASK = 0x3; +const unsigned int D3D10_SDK_VERSION = 29; + +cpp_quote("#define MAKE_D3D10_HRESULT(code) MAKE_HRESULT( 1, _FACD3D10, code)") +cpp_quote("#define MAKE_D3D10_STATUS(code) MAKE_HRESULT( 0, _FACD3D10, code)") + +cpp_quote("#if defined(__cplusplus) && !defined(D3D10_NO_HELPERS)") +cpp_quote("inline unsigned int D3D10CalcSubresource(unsigned int level, unsigned int layer, unsigned int level_count)") +cpp_quote("{") +cpp_quote(" return layer * level_count + level;") +cpp_quote("}") +cpp_quote("#endif") + +typedef enum D3D10_BLEND { + D3D10_BLEND_ZERO = 1, + D3D10_BLEND_ONE = 2, + D3D10_BLEND_SRC_COLOR = 3, + D3D10_BLEND_INV_SRC_COLOR = 4, + D3D10_BLEND_SRC_ALPHA = 5, + D3D10_BLEND_INV_SRC_ALPHA = 6, + D3D10_BLEND_DEST_ALPHA = 7, + D3D10_BLEND_INV_DEST_ALPHA = 8, + D3D10_BLEND_DEST_COLOR = 9, + D3D10_BLEND_INV_DEST_COLOR = 10, + D3D10_BLEND_SRC_ALPHA_SAT = 11, + D3D10_BLEND_BLEND_FACTOR = 14, + D3D10_BLEND_INV_BLEND_FACTOR = 15, + D3D10_BLEND_SRC1_COLOR = 16, + D3D10_BLEND_INV_SRC1_COLOR = 17, + D3D10_BLEND_SRC1_ALPHA = 18, + D3D10_BLEND_INV_SRC1_ALPHA = 19 +} D3D10_BLEND; + +typedef enum D3D10_BLEND_OP { + D3D10_BLEND_OP_ADD = 1, + D3D10_BLEND_OP_SUBTRACT, + D3D10_BLEND_OP_REV_SUBTRACT, + D3D10_BLEND_OP_MIN, + D3D10_BLEND_OP_MAX, +} D3D10_BLEND_OP; + +typedef struct D3D10_BLEND_DESC { + BOOL AlphaToCoverageEnable; + BOOL BlendEnable[8]; + D3D10_BLEND SrcBlend; + D3D10_BLEND DestBlend; + D3D10_BLEND_OP BlendOp; + D3D10_BLEND SrcBlendAlpha; + D3D10_BLEND DestBlendAlpha; + D3D10_BLEND_OP BlendOpAlpha; + UINT8 RenderTargetWriteMask[8]; +} D3D10_BLEND_DESC; + +typedef enum D3D10_DEPTH_WRITE_MASK { + D3D10_DEPTH_WRITE_MASK_ZERO, + D3D10_DEPTH_WRITE_MASK_ALL, +} D3D10_DEPTH_WRITE_MASK; + +typedef enum D3D10_COMPARISON_FUNC { + D3D10_COMPARISON_NEVER = 1, + D3D10_COMPARISON_LESS, + D3D10_COMPARISON_EQUAL, + D3D10_COMPARISON_LESS_EQUAL, + D3D10_COMPARISON_GREATER, + D3D10_COMPARISON_NOT_EQUAL, + D3D10_COMPARISON_GREATER_EQUAL, + D3D10_COMPARISON_ALWAYS, +} D3D10_COMPARISON_FUNC; + +typedef enum D3D10_STENCIL_OP { + D3D10_STENCIL_OP_KEEP = 1, + D3D10_STENCIL_OP_ZERO, + D3D10_STENCIL_OP_REPLACE, + D3D10_STENCIL_OP_INCR_SAT, + D3D10_STENCIL_OP_DECR_SAT, + D3D10_STENCIL_OP_INVERT, + D3D10_STENCIL_OP_INCR, + D3D10_STENCIL_OP_DECR, +} D3D10_STENCIL_OP; + +typedef struct D3D10_DEPTH_STENCILOP_DESC { + D3D10_STENCIL_OP StencilFailOp; + D3D10_STENCIL_OP StencilDepthFailOp; + D3D10_STENCIL_OP StencilPassOp; + D3D10_COMPARISON_FUNC StencilFunc; +} D3D10_DEPTH_STENCILOP_DESC; + +typedef struct D3D10_DEPTH_STENCIL_DESC { + BOOL DepthEnable; + D3D10_DEPTH_WRITE_MASK DepthWriteMask; + D3D10_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D10_DEPTH_STENCILOP_DESC FrontFace; + D3D10_DEPTH_STENCILOP_DESC BackFace; +} D3D10_DEPTH_STENCIL_DESC; + +typedef enum D3D10_FILL_MODE { + D3D10_FILL_WIREFRAME = 2, + D3D10_FILL_SOLID, +} D3D10_FILL_MODE; + +typedef enum D3D10_CULL_MODE { + D3D10_CULL_NONE = 1, + D3D10_CULL_FRONT, + D3D10_CULL_BACK, +} D3D10_CULL_MODE; + +typedef struct D3D10_RASTERIZER_DESC { + D3D10_FILL_MODE FillMode; + D3D10_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; +} D3D10_RASTERIZER_DESC; + +typedef enum D3D10_FILTER { + D3D10_FILTER_MIN_MAG_MIP_POINT = 0, + D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1, + D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4, + D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5, + D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D3D10_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D10_FILTER_ANISOTROPIC = 0x55, + D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, + D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, + D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, + D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, + D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, + D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, + D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, + D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D10_FILTER_COMPARISON_ANISOTROPIC = 0xd5, + D3D10_FILTER_TEXT_1BIT = 0x80000000 +} D3D10_FILTER; + +typedef enum D3D10_TEXTURE_ADDRESS_MODE { + D3D10_TEXTURE_ADDRESS_WRAP = 1, + D3D10_TEXTURE_ADDRESS_MIRROR, + D3D10_TEXTURE_ADDRESS_CLAMP, + D3D10_TEXTURE_ADDRESS_BORDER, + D3D10_TEXTURE_ADDRESS_MIRROR_ONCE, +} D3D10_TEXTURE_ADDRESS_MODE; + +typedef struct D3D10_SAMPLER_DESC { + D3D10_FILTER Filter; + D3D10_TEXTURE_ADDRESS_MODE AddressU; + D3D10_TEXTURE_ADDRESS_MODE AddressV; + D3D10_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D10_COMPARISON_FUNC ComparisonFunc; + FLOAT BorderColor[4]; + FLOAT MinLOD; + FLOAT MaxLOD; +} D3D10_SAMPLER_DESC; + +typedef enum D3D10_COUNTER { + D3D10_COUNTER_GPU_IDLE, + D3D10_COUNTER_VERTEX_PROCESSING, + D3D10_COUNTER_GEOMETRY_PROCESSING, + D3D10_COUNTER_PIXEL_PROCESSING, + D3D10_COUNTER_OTHER_GPU_PROCESSING, + D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION, + D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION, + D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION, + D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION, + D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION, + D3D10_COUNTER_VS_MEMORY_LIMITED, + D3D10_COUNTER_VS_COMPUTATION_LIMITED, + D3D10_COUNTER_GS_MEMORY_LIMITED, + D3D10_COUNTER_GS_COMPUTATION_LIMITED, + D3D10_COUNTER_PS_MEMORY_LIMITED, + D3D10_COUNTER_PS_COMPUTATION_LIMITED, + D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE, + D3D10_COUNTER_TEXTURE_CACHE_HIT_RATE, + D3D10_COUNTER_DEVICE_DEPENDENT_0 = 0x40000000 +} D3D10_COUNTER; + +typedef struct D3D10_COUNTER_DESC { + D3D10_COUNTER Counter; + UINT MiscFlags; +} D3D10_COUNTER_DESC; + +typedef enum D3D10_COUNTER_TYPE { + D3D10_COUNTER_TYPE_FLOAT32, + D3D10_COUNTER_TYPE_UINT16, + D3D10_COUNTER_TYPE_UINT32, + D3D10_COUNTER_TYPE_UINT64, +} D3D10_COUNTER_TYPE; + +typedef struct D3D10_COUNTER_INFO { + D3D10_COUNTER LastDeviceDependentCounter; + UINT NumSimultaneousCounters; + UINT8 NumDetectableParallelUnits; +} D3D10_COUNTER_INFO; + +typedef enum D3D10_RESOURCE_DIMENSION { + D3D10_RESOURCE_DIMENSION_UNKNOWN, + D3D10_RESOURCE_DIMENSION_BUFFER, + D3D10_RESOURCE_DIMENSION_TEXTURE1D, + D3D10_RESOURCE_DIMENSION_TEXTURE2D, + D3D10_RESOURCE_DIMENSION_TEXTURE3D, +} D3D10_RESOURCE_DIMENSION; + +typedef enum D3D10_USAGE { + D3D10_USAGE_DEFAULT, + D3D10_USAGE_IMMUTABLE, + D3D10_USAGE_DYNAMIC, + D3D10_USAGE_STAGING, +} D3D10_USAGE; + +typedef enum D3D10_BIND_FLAG { + D3D10_BIND_VERTEX_BUFFER = 0x1, + D3D10_BIND_INDEX_BUFFER = 0x2, + D3D10_BIND_CONSTANT_BUFFER = 0x4, + D3D10_BIND_SHADER_RESOURCE = 0x8, + D3D10_BIND_STREAM_OUTPUT = 0x10, + D3D10_BIND_RENDER_TARGET = 0x20, + D3D10_BIND_DEPTH_STENCIL = 0x40 +} D3D10_BIND_FLAG; + +typedef struct D3D10_BUFFER_DESC { + UINT ByteWidth; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D10_BUFFER_DESC; + +cpp_quote("#if !defined(D3D10_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D10_BUFFER_DESC : public D3D10_BUFFER_DESC {") +cpp_quote(" CD3D10_BUFFER_DESC() {}" ) +cpp_quote(" explicit CD3D10_BUFFER_DESC(const D3D10_BUFFER_DESC &o) : D3D10_BUFFER_DESC(o) {}") +cpp_quote(" explicit CD3D10_BUFFER_DESC(UINT byteWidth, UINT bindFlags, D3D10_USAGE usage = D3D10_USAGE_DEFAULT, UINT cpuaccessFlags = 0, UINT miscFlags = 0 ) {") +cpp_quote(" ByteWidth = byteWidth;") +cpp_quote(" Usage = usage;") +cpp_quote(" BindFlags = bindFlags;") +cpp_quote(" CPUAccessFlags = cpuaccessFlags;") +cpp_quote(" MiscFlags = miscFlags;") +cpp_quote(" }") +cpp_quote(" ~CD3D10_BUFFER_DESC() {}") +cpp_quote(" operator const D3D10_BUFFER_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + +typedef enum D3D10_MAP { + D3D10_MAP_READ = 1, + D3D10_MAP_WRITE, + D3D10_MAP_READ_WRITE, + D3D10_MAP_WRITE_DISCARD, + D3D10_MAP_WRITE_NO_OVERWRITE, +} D3D10_MAP; + +typedef struct D3D10_TEXTURE1D_DESC { + UINT Width; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D10_TEXTURE1D_DESC; + +cpp_quote("#if !defined(D3D10_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D10_TEXTURE1D_DESC : public D3D10_TEXTURE1D_DESC {") +cpp_quote(" CD3D10_TEXTURE1D_DESC() {}") +cpp_quote(" explicit CD3D10_TEXTURE1D_DESC(const D3D10_TEXTURE1D_DESC &o) : D3D10_TEXTURE1D_DESC(o) {}") +cpp_quote(" explicit CD3D10_TEXTURE1D_DESC(DXGI_FORMAT format, UINT width, UINT arraySize = 1, UINT mipLevels = 0,") +cpp_quote(" UINT bindFlags = D3D10_BIND_SHADER_RESOURCE, D3D10_USAGE usage = D3D10_USAGE_DEFAULT, UINT cpuaccessFlags = 0,") +cpp_quote(" UINT miscFlags = 0) {") +cpp_quote(" Width = width;") +cpp_quote(" MipLevels = mipLevels;") +cpp_quote(" ArraySize = arraySize;") +cpp_quote(" Format = format;") +cpp_quote(" Usage = usage;") +cpp_quote(" BindFlags = bindFlags;") +cpp_quote(" CPUAccessFlags = cpuaccessFlags;") +cpp_quote(" MiscFlags = miscFlags;") +cpp_quote(" }") +cpp_quote(" ~CD3D10_TEXTURE1D_DESC() {}") +cpp_quote(" operator const D3D10_TEXTURE1D_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D10_TEXTURE2D_DESC { + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D10_TEXTURE2D_DESC; + +cpp_quote("#if !defined(D3D10_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D10_TEXTURE2D_DESC : public D3D10_TEXTURE2D_DESC {") +cpp_quote(" CD3D10_TEXTURE2D_DESC() {}" ) +cpp_quote(" explicit CD3D10_TEXTURE2D_DESC(const D3D10_TEXTURE2D_DESC &o) : D3D10_TEXTURE2D_DESC(o) {}") +cpp_quote(" explicit CD3D10_TEXTURE2D_DESC(DXGI_FORMAT format, UINT width, UINT height,") +cpp_quote(" UINT arraySize = 1,") +cpp_quote(" UINT mipLevels = 0,") +cpp_quote(" UINT bindFlags = D3D10_BIND_SHADER_RESOURCE,") +cpp_quote(" D3D10_USAGE usage = D3D10_USAGE_DEFAULT,") +cpp_quote(" UINT cpuaccessFlags = 0,") +cpp_quote(" UINT sampleCount = 1,") +cpp_quote(" UINT sampleQuality = 0,") +cpp_quote(" UINT miscFlags = 0) {") +cpp_quote(" Width = width;" ) +cpp_quote(" Height = height;" ) +cpp_quote(" MipLevels = mipLevels;" ) +cpp_quote(" ArraySize = arraySize;" ) +cpp_quote(" Format = format;" ) +cpp_quote(" SampleDesc.Count = sampleCount;" ) +cpp_quote(" SampleDesc.Quality = sampleQuality;" ) +cpp_quote(" Usage = usage;" ) +cpp_quote(" BindFlags = bindFlags;" ) +cpp_quote(" CPUAccessFlags = cpuaccessFlags;" ) +cpp_quote(" MiscFlags = miscFlags;" ) +cpp_quote(" }") +cpp_quote(" ~CD3D10_TEXTURE2D_DESC() {}") +cpp_quote(" operator const D3D10_TEXTURE2D_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D10_TEXTURE3D_DESC { + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + DXGI_FORMAT Format; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D10_TEXTURE3D_DESC; + +typedef enum D3D10_DSV_DIMENSION +{ + D3D10_DSV_DIMENSION_UNKNOWN, + D3D10_DSV_DIMENSION_TEXTURE1D, + D3D10_DSV_DIMENSION_TEXTURE1DARRAY, + D3D10_DSV_DIMENSION_TEXTURE2D, + D3D10_DSV_DIMENSION_TEXTURE2DARRAY, + D3D10_DSV_DIMENSION_TEXTURE2DMS, + D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY, +} D3D10_DSV_DIMENSION; + +typedef struct D3D10_TEX1D_DSV { + UINT MipSlice; +} D3D10_TEX1D_DSV; + +typedef struct D3D10_TEX1D_ARRAY_DSV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX1D_ARRAY_DSV; + +typedef struct D3D10_TEX2D_DSV { + UINT MipSlice; +} D3D10_TEX2D_DSV; + +typedef struct D3D10_TEX2D_ARRAY_DSV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX2D_ARRAY_DSV; + +typedef struct D3D10_TEX2DMS_DSV { + UINT UnusedField_NothingToDefine; +} D3D10_TEX2DMS_DSV; + +typedef struct D3D10_TEX2DMS_ARRAY_DSV { + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX2DMS_ARRAY_DSV; + +typedef struct D3D10_DEPTH_STENCIL_VIEW_DESC { + DXGI_FORMAT Format; + D3D10_DSV_DIMENSION ViewDimension; + union { + D3D10_TEX1D_DSV Texture1D; + D3D10_TEX1D_ARRAY_DSV Texture1DArray; + D3D10_TEX2D_DSV Texture2D; + D3D10_TEX2D_ARRAY_DSV Texture2DArray; + D3D10_TEX2DMS_DSV Texture2DMS; + D3D10_TEX2DMS_ARRAY_DSV Texture2DMSArray; + }; +} D3D10_DEPTH_STENCIL_VIEW_DESC; + +typedef enum D3D10_RTV_DIMENSION { + D3D10_RTV_DIMENSION_UNKNOWN, + D3D10_RTV_DIMENSION_BUFFER, + D3D10_RTV_DIMENSION_TEXTURE1D, + D3D10_RTV_DIMENSION_TEXTURE1DARRAY, + D3D10_RTV_DIMENSION_TEXTURE2D, + D3D10_RTV_DIMENSION_TEXTURE2DARRAY, + D3D10_RTV_DIMENSION_TEXTURE2DMS, + D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_RTV_DIMENSION_TEXTURE3D, +} D3D10_RTV_DIMENSION; + +typedef struct D3D10_BUFFER_RTV { + union { + UINT FirstElement; + UINT ElementOffset; + }; + union { + UINT NumElements; + UINT ElementWidth; + }; +} D3D10_BUFFER_RTV; + +typedef struct D3D10_TEX1D_RTV { + UINT MipSlice; +} D3D10_TEX1D_RTV; + +typedef struct D3D10_TEX1D_ARRAY_RTV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX1D_ARRAY_RTV; + +typedef struct D3D10_TEX2D_RTV { + UINT MipSlice; +} D3D10_TEX2D_RTV; + +typedef struct D3D10_TEX2D_ARRAY_RTV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX2D_ARRAY_RTV; + +typedef struct D3D10_TEX2DMS_RTV { + UINT UnusedField_NothingToDefine; +} D3D10_TEX2DMS_RTV; + +typedef struct D3D10_TEX2DMS_ARRAY_RTV { + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX2DMS_ARRAY_RTV; + +typedef struct D3D10_TEX3D_RTV { + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D10_TEX3D_RTV; + +typedef struct D3D10_RENDER_TARGET_VIEW_DESC { + DXGI_FORMAT Format; + D3D10_RTV_DIMENSION ViewDimension; + union { + D3D10_BUFFER_RTV Buffer; + D3D10_TEX1D_RTV Texture1D; + D3D10_TEX1D_ARRAY_RTV Texture1DArray; + D3D10_TEX2D_RTV Texture2D; + D3D10_TEX2D_ARRAY_RTV Texture2DArray; + D3D10_TEX2DMS_RTV Texture2DMS; + D3D10_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D10_TEX3D_RTV Texture3D; + }; +} D3D10_RENDER_TARGET_VIEW_DESC; + +typedef D3D_SRV_DIMENSION D3D10_SRV_DIMENSION; + +typedef struct D3D10_BUFFER_SRV { + union { + UINT FirstElement; + UINT ElementOffset; + }; + union { + UINT NumElements; + UINT ElementWidth; + }; +} D3D10_BUFFER_SRV; + +typedef struct D3D10_TEX1D_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} D3D10_TEX1D_SRV; + +typedef struct D3D10_TEX1D_ARRAY_SRV { + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX1D_ARRAY_SRV; + +typedef struct D3D10_TEX2D_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} D3D10_TEX2D_SRV; + +typedef struct D3D10_TEX2D_ARRAY_SRV { + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX2D_ARRAY_SRV; + +typedef struct D3D10_TEX2DMS_SRV { + UINT UnusedField_NothingToDefine; +} D3D10_TEX2DMS_SRV; + +typedef struct D3D10_TEX2DMS_ARRAY_SRV { + UINT FirstArraySlice; + UINT ArraySize; +} D3D10_TEX2DMS_ARRAY_SRV; + +typedef struct D3D10_TEX3D_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} D3D10_TEX3D_SRV; + +typedef struct D3D10_TEXCUBE_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} D3D10_TEXCUBE_SRV; + +typedef struct D3D10_SHADER_RESOURCE_VIEW_DESC { + DXGI_FORMAT Format; + D3D10_SRV_DIMENSION ViewDimension; + union { + D3D10_BUFFER_SRV Buffer; + D3D10_TEX1D_SRV Texture1D; + D3D10_TEX1D_ARRAY_SRV Texture1DArray; + D3D10_TEX2D_SRV Texture2D; + D3D10_TEX2D_ARRAY_SRV Texture2DArray; + D3D10_TEX2DMS_SRV Texture2DMS; + D3D10_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D10_TEX3D_SRV Texture3D; + D3D10_TEXCUBE_SRV TextureCube; + }; +} D3D10_SHADER_RESOURCE_VIEW_DESC; + +typedef struct D3D10_BOX { + UINT left; + UINT top; + UINT front; + UINT right; + UINT bottom; + UINT back; +} D3D10_BOX; + +typedef struct D3D10_SUBRESOURCE_DATA { + const void *pSysMem; + UINT SysMemPitch; + UINT SysMemSlicePitch; +} D3D10_SUBRESOURCE_DATA; + +typedef struct D3D10_SO_DECLARATION_ENTRY +{ + const char *SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; +} D3D10_SO_DECLARATION_ENTRY; + +typedef enum D3D10_INPUT_CLASSIFICATION { + D3D10_INPUT_PER_VERTEX_DATA, + D3D10_INPUT_PER_INSTANCE_DATA, +} D3D10_INPUT_CLASSIFICATION; + +typedef struct D3D10_INPUT_ELEMENT_DESC +{ + const char *SemanticName; + UINT SemanticIndex; + DXGI_FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + D3D10_INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; +} D3D10_INPUT_ELEMENT_DESC; + +typedef enum D3D10_QUERY { + D3D10_QUERY_EVENT, + D3D10_QUERY_OCCLUSION, + D3D10_QUERY_TIMESTAMP, + D3D10_QUERY_TIMESTAMP_DISJOINT, + D3D10_QUERY_PIPELINE_STATISTICS, + D3D10_QUERY_OCCLUSION_PREDICATE, + D3D10_QUERY_SO_STATISTICS, + D3D10_QUERY_SO_OVERFLOW_PREDICATE, +} D3D10_QUERY; + +typedef struct D3D10_QUERY_DESC { + D3D10_QUERY Query; + UINT MiscFlags; +} D3D10_QUERY_DESC; + +typedef D3D_PRIMITIVE_TOPOLOGY D3D10_PRIMITIVE_TOPOLOGY; + +typedef D3D_PRIMITIVE D3D10_PRIMITIVE; + +typedef RECT D3D10_RECT; + +typedef struct D3D10_VIEWPORT { + INT TopLeftX; + INT TopLeftY; + UINT Width; + UINT Height; + FLOAT MinDepth; + FLOAT MaxDepth; +} D3D10_VIEWPORT; + +typedef struct D3D10_MAPPED_TEXTURE2D { + void *pData; + UINT RowPitch; +} D3D10_MAPPED_TEXTURE2D; + +typedef struct D3D10_MAPPED_TEXTURE3D { + void *pData; + UINT RowPitch; + UINT DepthPitch; +} D3D10_MAPPED_TEXTURE3D; + +typedef enum D3D10_CPU_ACCESS_FLAG { + D3D10_CPU_ACCESS_WRITE = 0x10000, + D3D10_CPU_ACCESS_READ = 0x20000 +} D3D10_CPU_ACCESS_FLAG; + +typedef enum D3D10_RESOURCE_MISC_FLAG { + D3D10_RESOURCE_MISC_GENERATE_MIPS = 0x0001, + D3D10_RESOURCE_MISC_SHARED = 0x0002, + D3D10_RESOURCE_MISC_TEXTURECUBE = 0x0004, + D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX = 0x0010, + D3D10_RESOURCE_MISC_GDI_COMPATIBLE = 0x0020 +} D3D10_RESOURCE_MISC_FLAG; + +typedef enum D3D10_MAP_FLAG { + D3D10_MAP_FLAG_DO_NOT_WAIT = 0x100000, +} D3D10_MAP_FLAG; + +typedef enum D3D10_RAISE_FLAG { + D3D10_RAISE_FLAG_DRIVER_INTERNAL_ERROR = 0x1, +} D3D10_RAISE_FLAG; + +typedef enum D3D10_CLEAR_FLAG { + D3D10_CLEAR_DEPTH = 0x1, + D3D10_CLEAR_STENCIL = 0x2 +} D3D10_CLEAR_FLAG; + +typedef enum D3D10_COLOR_WRITE_ENABLE { + D3D10_COLOR_WRITE_ENABLE_RED = 0x1, + D3D10_COLOR_WRITE_ENABLE_GREEN = 0x2, + D3D10_COLOR_WRITE_ENABLE_BLUE = 0x4, + D3D10_COLOR_WRITE_ENABLE_ALPHA = 0x8, + D3D10_COLOR_WRITE_ENABLE_ALL = (D3D10_COLOR_WRITE_ENABLE_RED | D3D10_COLOR_WRITE_ENABLE_GREEN | + D3D10_COLOR_WRITE_ENABLE_BLUE | D3D10_COLOR_WRITE_ENABLE_ALPHA) +} D3D10_COLOR_WRITE_ENABLE; + +typedef enum D3D10_FORMAT_SUPPORT +{ + D3D10_FORMAT_SUPPORT_BUFFER = 0x00000001, + D3D10_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x00000002, + D3D10_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x00000004, + D3D10_FORMAT_SUPPORT_SO_BUFFER = 0x00000008, + D3D10_FORMAT_SUPPORT_TEXTURE1D = 0x00000010, + D3D10_FORMAT_SUPPORT_TEXTURE2D = 0x00000020, + D3D10_FORMAT_SUPPORT_TEXTURE3D = 0x00000040, + D3D10_FORMAT_SUPPORT_TEXTURECUBE = 0x00000080, + D3D10_FORMAT_SUPPORT_SHADER_LOAD = 0x00000100, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE = 0x00000200, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x00000400, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x00000800, + D3D10_FORMAT_SUPPORT_MIP = 0x00001000, + D3D10_FORMAT_SUPPORT_MIP_AUTOGEN = 0x00002000, + D3D10_FORMAT_SUPPORT_RENDER_TARGET = 0x00004000, + D3D10_FORMAT_SUPPORT_BLENDABLE = 0x00008000, + D3D10_FORMAT_SUPPORT_DEPTH_STENCIL = 0x00010000, + D3D10_FORMAT_SUPPORT_CPU_LOCKABLE = 0x00020000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x00040000, + D3D10_FORMAT_SUPPORT_DISPLAY = 0x00080000, + D3D10_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT = 0x00100000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET = 0x00200000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_LOAD = 0x00400000, + D3D10_FORMAT_SUPPORT_SHADER_GATHER = 0x00800000, + D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST = 0x01000000, +} D3D10_FORMAT_SUPPORT; + +typedef enum D3D10_TEXTURECUBE_FACE { + D3D10_TEXTURECUBE_FACE_POSITIVE_X, + D3D10_TEXTURECUBE_FACE_NEGATIVE_X, + D3D10_TEXTURECUBE_FACE_POSITIVE_Y, + D3D10_TEXTURECUBE_FACE_NEGATIVE_Y, + D3D10_TEXTURECUBE_FACE_POSITIVE_Z, + D3D10_TEXTURECUBE_FACE_NEGATIVE_Z, +} D3D10_TEXTURECUBE_FACE; + +typedef enum D3D10_ASYNC_GETDATA_FLAG { + D3D10_ASYNC_GETDATA_DONOTFLUSH = 0x1, +} D3D10_ASYNC_GETDATA_FLAG; + +typedef enum D3D10_FILTER_TYPE { + D3D10_FILTER_TYPE_POINT, + D3D10_FILTER_TYPE_LINEAR +} D3D10_FILTER_TYPE; + +typedef enum D3D10_QUERY_MISC_FLAG { + D3D10_QUERY_MISC_PREDICATEHINT = 0x1 +} D3D10_QUERY_MISC_FLAG; + +typedef struct D3D10_QUERY_DATA_TIMESTAMP_DISJOINT { + UINT64 Frequency; + BOOL Disjoint; +} D3D10_QUERY_DATA_TIMESTAMP_DISJOINT; + +typedef struct D3D10_QUERY_DATA_PIPELINE_STATISTICS { + UINT64 IAVertices; + UINT64 IAPrimitives; + UINT64 VSInvocations; + UINT64 GSInvocations; + UINT64 GSPrimitives; + UINT64 CInvocations; + UINT64 CPrimitives; + UINT64 PSInvocations; +} D3D10_QUERY_DATA_PIPELINE_STATISTICS; + +typedef struct D3D10_QUERY_DATA_SO_STATISTICS { + UINT64 NumPrimitivesWritten; + UINT64 PrimitivesStorageNeeded; +} D3D10_QUERY_DATA_SO_STATISTICS; + +typedef enum D3D10_CREATE_DEVICE_FLAG { + D3D10_CREATE_DEVICE_SINGLETHREADED = 0x1, + D3D10_CREATE_DEVICE_DEBUG = 0x2, + D3D10_CREATE_DEVICE_SWITCH_TO_REF = 0x4, + D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x8, + D3D10_CREATE_DEVICE_ALLOW_NULL_FROM_MAP = 0x10, + D3D10_CREATE_DEVICE_BGRA_SUPPORT = 0x20, + D3D10_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x80, + D3D10_CREATE_DEVICE_STRICT_VALIDATION = 0x200, + D3D10_CREATE_DEVICE_DEBUGGABLE = 0x400, +} D3D10_CREATE_DEVICE_FLAG; + +/* Core */ + +interface ID3D10Device; + +[ + object, + local, + uuid(9b7e4c00-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10DeviceChild : IUnknown +{ + void GetDevice( + [out] ID3D10Device **ppDevice); + HRESULT GetPrivateData( + [in] REFGUID guid, + [in, out] UINT *pDataSize, + [out] void *pData); + HRESULT SetPrivateData( + [in] REFGUID guid, + [in] UINT DataSize, + [in] const void *pData); + HRESULT SetPrivateDataInterface( + [in] REFGUID guid, + [in] const IUnknown *pData); +} + +/* Resource */ + +[ + object, + local, + uuid(9b7e4c01-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Resource : ID3D10DeviceChild +{ + void GetType( + [out] D3D10_RESOURCE_DIMENSION *rType); + void SetEvictionPriority( + [in] UINT EvictionPriority); + UINT GetEvictionPriority(); +} + +[ + object, + local, + uuid(9b7e4c02-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Buffer : ID3D10Resource +{ + HRESULT Map( + [in] D3D10_MAP MapType, + [in] UINT MapFlags, + [out] void **ppData); + void Unmap(); + void GetDesc( + [out] D3D10_BUFFER_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c03-342c-4106-a19f-4f2704f689F0) +] +interface ID3D10Texture1D : ID3D10Resource +{ + HRESULT Map( + [in] UINT Subresource, + [in] D3D10_MAP MapType, + [in] UINT MapFlags, + [out] void **ppData); + void Unmap( + [in] UINT Subresource); + void GetDesc( + [out] D3D10_TEXTURE1D_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c04-342c-4106-a19f-4f2704f689F0) +] +interface ID3D10Texture2D : ID3D10Resource +{ + HRESULT Map( + [in] UINT Subresource, + [in] D3D10_MAP MapType, + [in] UINT MapFlags, + [out] D3D10_MAPPED_TEXTURE2D *pMappedTex2D); + void Unmap( + [in] UINT Subresource); + void GetDesc( + [out] D3D10_TEXTURE2D_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c05-342c-4106-a19f-4f2704f689F0) +] +interface ID3D10Texture3D : ID3D10Resource +{ + HRESULT Map( + [in] UINT Subresource, + [in] D3D10_MAP MapType, + [in] UINT MapFlags, + [out] D3D10_MAPPED_TEXTURE3D *pMappedTex3D); + void Unmap( + [in] UINT Subresource); + void GetDesc( + [out] D3D10_TEXTURE3D_DESC *pDesc); +} + +[ + object, + local, + uuid(c902b03f-60a7-49ba-9936-2a3ab37a7e33) +] +interface ID3D10View : ID3D10DeviceChild +{ + void GetResource( + [out] ID3D10Resource **ppResource); +} + +[ + object, + local, + uuid(9b7e4c09-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10DepthStencilView : ID3D10View +{ + void GetDesc( + [out] D3D10_DEPTH_STENCIL_VIEW_DESC *pDesc); +} + + +[ + object, + local, + uuid(9b7e4c08-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10RenderTargetView : ID3D10View +{ + void GetDesc( + [out] D3D10_RENDER_TARGET_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c07-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10ShaderResourceView : ID3D10View +{ + void GetDesc( + [out] D3D10_SHADER_RESOURCE_VIEW_DESC *pDesc); +} + +/* Resource End */ + +[ + object, + local, + uuid(edad8d19-8a35-4d6d-8566-2ea276cde161) +] +interface ID3D10BlendState : ID3D10DeviceChild +{ + void GetDesc( + [out] D3D10_BLEND_DESC *pDesc); +} + +[ + object, + local, + uuid(2b4b1cc8-a4ad-41f8-8322-ca86fc3ec675) +] +interface ID3D10DepthStencilState : ID3D10DeviceChild +{ + void GetDesc( + [out] D3D10_DEPTH_STENCIL_DESC *pDesc); +} + +[ + object, + local, + uuid(6316be88-54cd-4040-ab44-20461bc81f68) +] +interface ID3D10GeometryShader : ID3D10DeviceChild +{ +} + +[ + object, + local, + uuid(9b7e4c0b-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10InputLayout : ID3D10DeviceChild +{ +} + +[ + object, + local, + uuid(4968b601-9d00-4cde-8346-8e7f675819b6) +] +interface ID3D10PixelShader : ID3D10DeviceChild +{ +} + +[ + object, + local, + uuid(a2a07292-89af-4345-be2e-c53d9fbb6e9f) +] +interface ID3D10RasterizerState : ID3D10DeviceChild +{ + void GetDesc( + [out] D3D10_RASTERIZER_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c0c-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10SamplerState : ID3D10DeviceChild +{ + void GetDesc( + [out] D3D10_SAMPLER_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c0a-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10VertexShader : ID3D10DeviceChild +{ +} + +[ + object, + local, + uuid(9b7e4c0d-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Asynchronous : ID3D10DeviceChild +{ + void Begin(); + void End(); + HRESULT GetData( + [out] void *pData, + [in] UINT DataSize, + [in] UINT GetDataFlags); + UINT GetDataSize(); +} + +[ + object, + local, + uuid(9b7e4c11-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Counter : ID3D10Asynchronous +{ + void GetDesc( + [out] D3D10_COUNTER_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4C0e-342C-4106-a19f-4f2704f689f0) +] +interface ID3D10Query : ID3D10Asynchronous +{ + void GetDesc( + [out] D3D10_QUERY_DESC *pDesc); +} + +[ + object, + local, + uuid(9b7e4c10-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Predicate : ID3D10Query +{ +} + +[ + object, + local, + uuid(9b7e4c0f-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Device : IUnknown +{ + void VSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D10Buffer *const *ppConstantBuffers); + void PSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D10ShaderResourceView *const *ppShaderResourceViews); + void PSSetShader( + [in] ID3D10PixelShader *pPixelShader); + void PSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in]ID3D10SamplerState *const *ppSamplers); + void VSSetShader( + [in] ID3D10VertexShader *pVertexShader); + void DrawIndexed( + [in] UINT IndexCount, + [in] UINT StartIndexLocation, + [in] INT BaseVertexLocation); + void Draw( + [in] UINT VertexCount, + [in] UINT StartVertexLocation); + void PSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D10Buffer *const *ppConstantBuffers); + void IASetInputLayout( + [in] ID3D10InputLayout *pInputLayout); + void IASetVertexBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D10Buffer *const *ppVertexBuffers, + [in] const UINT *pStrides, + [in] const UINT *pOffsets); + void IASetIndexBuffer( + [in] ID3D10Buffer *pIndexBuffer, + [in] DXGI_FORMAT Format, + [in] UINT Offset); + void DrawIndexedInstanced( + [in] UINT IndexCountPerInstance, + [in] UINT InstanceCount, + [in] UINT StartIndexLocation, + [in] INT BaseVertexLocation, + [in] UINT StartInstanceLocation); + void DrawInstanced( + [in] UINT VertexCountPerInstance, + [in] UINT InstanceCount, + [in] UINT StartVertexLocation, + [in] UINT StartInstanceLocation); + void GSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D10Buffer *const *ppConstantBuffers); + void GSSetShader( + [in] ID3D10GeometryShader *pShader); + void IASetPrimitiveTopology( + [in] D3D10_PRIMITIVE_TOPOLOGY Topology); + void VSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D10ShaderResourceView *const *ppShaderResourceViews); + void VSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D10SamplerState *const *ppSamplers); + void SetPredication( + [in] ID3D10Predicate *pPredicate, + [in] BOOL PredicateValue); + void GSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D10ShaderResourceView * const *ppShaderResourceViews); + void GSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D10SamplerState *const *ppSamplers); + void OMSetRenderTargets( + [in] UINT NumViews, + [in] ID3D10RenderTargetView *const *ppRenderTargetViews, + [in] ID3D10DepthStencilView *pDepthStencilView); + void OMSetBlendState( + [in] ID3D10BlendState *pBlendState, + [in] const FLOAT BlendFactor[4], + [in] UINT SampleMask); + void OMSetDepthStencilState( + [in] ID3D10DepthStencilState *pDepthStencilState, + [in] UINT StencilRef); + void SOSetTargets( + [in] UINT NumBuffers, + [in] ID3D10Buffer *const *ppSOTargets, + [in] const UINT *pOffsets); + void DrawAuto(); + void RSSetState( + [in] ID3D10RasterizerState *pRasterizerState); + void RSSetViewports( + [in] UINT NumViewports, + [in] const D3D10_VIEWPORT *pViewports); + void RSSetScissorRects( + [in] UINT NumRects, + [in] const D3D10_RECT *pRects); + void CopySubresourceRegion( + [in] ID3D10Resource *pDstResource, + [in] UINT DstSubresource, + [in] UINT DstX, + [in] UINT DstY, + [in] UINT DstZ, + [in] ID3D10Resource *pSrcResource, + [in] UINT SrcSubresource, + [in] const D3D10_BOX *pSrcBox); + void CopyResource( + [in] ID3D10Resource *pDstResource, + [in] ID3D10Resource *pSrcResource); + void UpdateSubresource( + [in] ID3D10Resource *pDstResource, + [in] UINT DstSubresource, + [in] const D3D10_BOX *pDstBox, + [in] const void *pSrcData, + [in] UINT SrcRowPitch, + [in] UINT SrcDepthPitch); + void ClearRenderTargetView( + [in] ID3D10RenderTargetView *pRenderTargetView, + [in] const FLOAT ColorRGBA[4]); + void ClearDepthStencilView( + [in] ID3D10DepthStencilView *pDepthStencilView, + [in] UINT ClearFlags, + [in] FLOAT Depth, + [in] UINT8 Stencil); + void GenerateMips( + [in] ID3D10ShaderResourceView *pShaderResourceView); + void ResolveSubresource( + [in] ID3D10Resource *pDstResource, + [in] UINT DstSubresource, + [in] ID3D10Resource *pSrcResource, + [in] UINT SrcSubresource, + [in] DXGI_FORMAT Format); + void VSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D10Buffer **ppConstantBuffers); + void PSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D10ShaderResourceView **ppShaderResourceViews); + void PSGetShader( + [out] ID3D10PixelShader **ppPixelShader); + void PSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D10SamplerState **ppSamplers); + void VSGetShader( + [out] ID3D10VertexShader **ppVertexShader); + void PSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D10Buffer **ppConstantBuffers); + void IAGetInputLayout( + [out] ID3D10InputLayout **ppInputLayout); + void IAGetVertexBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D10Buffer **ppVertexBuffers, + [out] UINT *pStrides, + [out] UINT *pOffsets); + void IAGetIndexBuffer( + [out] ID3D10Buffer **pIndexBuffer, + [out] DXGI_FORMAT *Format, + [out] UINT *Offset); + void GSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D10Buffer **ppConstantBuffers); + void GSGetShader( + [out] ID3D10GeometryShader **ppGeometryShader); + void IAGetPrimitiveTopology( + [out] D3D10_PRIMITIVE_TOPOLOGY *pTopology); + void VSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D10ShaderResourceView **ppShaderResourceViews); + void VSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D10SamplerState **ppSamplers); + void GetPredication( + [out] ID3D10Predicate **ppPredicate, + [out] BOOL *pPredicateValue); + void GSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D10ShaderResourceView **ppShaderResourceViews); + void GSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D10SamplerState **ppSamplers); + void OMGetRenderTargets( + [in] UINT NumViews, + [out] ID3D10RenderTargetView **ppRenderTargetViews, + [out] ID3D10DepthStencilView **ppDepthStencilView); + void OMGetBlendState( + [out] ID3D10BlendState **ppBlendState, + [out] FLOAT BlendFactor[4], + [out] UINT *pSampleMask); + void OMGetDepthStencilState( + [out] ID3D10DepthStencilState **ppDepthStencilState, + [out] UINT *pStencilRef); + void SOGetTargets( + [in] UINT NumBuffers, + [out] ID3D10Buffer **ppSOTargets, + [out] UINT *pOffsets); + void RSGetState( + [out] ID3D10RasterizerState **ppRasterizerState); + void RSGetViewports( + [in, out] UINT *NumViewports, + [out] D3D10_VIEWPORT *pViewports); + void RSGetScissorRects( + [in, out] UINT *NumRects, + [out] D3D10_RECT *pRects); + HRESULT GetDeviceRemovedReason(); + HRESULT SetExceptionMode( + [in] UINT RaiseFlags); + UINT GetExceptionMode(); + HRESULT GetPrivateData( + [in] REFGUID guid, + [in, out] UINT *pDataSize, + [out] void *pData); + HRESULT SetPrivateData( + [in] REFGUID guid, + [in] UINT DataSize, + [in] const void *pData); + HRESULT SetPrivateDataInterface( + [in] REFGUID guid, + [in] const IUnknown *pData); + void ClearState(); + void Flush(); + HRESULT CreateBuffer( + [in] const D3D10_BUFFER_DESC *pDesc, + [in] const D3D10_SUBRESOURCE_DATA *pInitialData, + [out] ID3D10Buffer **ppBuffer); + HRESULT CreateTexture1D( + [in] const D3D10_TEXTURE1D_DESC *pDesc, + [in] const D3D10_SUBRESOURCE_DATA *pInitialData, + [out] ID3D10Texture1D **ppTexture1D); + HRESULT CreateTexture2D( + [in] const D3D10_TEXTURE2D_DESC *pDesc, + [in] const D3D10_SUBRESOURCE_DATA *pInitialData, + [out] ID3D10Texture2D **ppTexture2D); + HRESULT CreateTexture3D( + [in] const D3D10_TEXTURE3D_DESC *pDesc, + [in] const D3D10_SUBRESOURCE_DATA *pInitialData, + [out] ID3D10Texture3D **ppTexture3D); + HRESULT CreateShaderResourceView( + [in] ID3D10Resource *pResource, + [in] const D3D10_SHADER_RESOURCE_VIEW_DESC *pDesc, + [out] ID3D10ShaderResourceView **ppSRView); + HRESULT CreateRenderTargetView( + [in] ID3D10Resource *pResource, + [in] const D3D10_RENDER_TARGET_VIEW_DESC *pDesc, + [out] ID3D10RenderTargetView **ppRTView); + HRESULT CreateDepthStencilView( + [in] ID3D10Resource *pResource, + [in] const D3D10_DEPTH_STENCIL_VIEW_DESC *pDesc, + [out] ID3D10DepthStencilView **ppDepthStencilView); + HRESULT CreateInputLayout( + [in] const D3D10_INPUT_ELEMENT_DESC *pInputElementDescs, + [in] UINT NumElements, + [in] const void *pShaderBytecodeWithInputSignature, + [in] SIZE_T BytecodeLength, + [out] ID3D10InputLayout **ppInputLayout); + HRESULT CreateVertexShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [out] ID3D10VertexShader **ppVertexShader); + HRESULT CreateGeometryShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [out] ID3D10GeometryShader **ppGeometryShader); + HRESULT CreateGeometryShaderWithStreamOutput( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] const D3D10_SO_DECLARATION_ENTRY *pSODeclaration, + [in] UINT NumEntries, + [in] UINT OutputStreamStride, + [out] ID3D10GeometryShader **ppGeometryShader); + HRESULT CreatePixelShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [out] ID3D10PixelShader **ppPixelShader); + HRESULT CreateBlendState( + [in] const D3D10_BLEND_DESC *pBlendStateDesc, + [out] ID3D10BlendState **ppBlendState); + HRESULT CreateDepthStencilState( + [in] const D3D10_DEPTH_STENCIL_DESC *pDepthStencilDesc, + [out] ID3D10DepthStencilState **ppDepthStencilState); + HRESULT CreateRasterizerState( + [in] const D3D10_RASTERIZER_DESC *pRasterizerDesc, + [out] ID3D10RasterizerState **ppRasterizerState); + HRESULT CreateSamplerState( + [in] const D3D10_SAMPLER_DESC *pSamplerDesc, + [out] ID3D10SamplerState **ppSamplerState); + HRESULT CreateQuery( + [in] const D3D10_QUERY_DESC *pQueryDesc, + [out] ID3D10Query **ppQuery); + HRESULT CreatePredicate( + [in] const D3D10_QUERY_DESC *pPredicateDesc, + [out] ID3D10Predicate **ppPredicate); + HRESULT CreateCounter( + [in] const D3D10_COUNTER_DESC *pCounterDesc, + [out] ID3D10Counter **ppCounter); + HRESULT CheckFormatSupport( + [in] DXGI_FORMAT Format, + [out] UINT *pFormatSupport); + HRESULT CheckMultisampleQualityLevels( + [in] DXGI_FORMAT Format, + [in] UINT SampleCount, + [out] UINT *pNumQualityLevels); + void CheckCounterInfo( + [out] D3D10_COUNTER_INFO *pCounterInfo); + HRESULT CheckCounter( + [in] const D3D10_COUNTER_DESC *pDesc, + [out] D3D10_COUNTER_TYPE *pType, + [out] UINT *pActiveCounters, + [out] char *name, + [in, out] UINT *pNameLength, + [out] char *units, + [in, out] UINT *pUnitsLength, + [out] char *description, + [in, out] UINT *pDescriptionLength); + UINT GetCreationFlags(); + HRESULT OpenSharedResource( + [in] HANDLE hResource, + [in] REFIID ReturnedInterface, + [out] void **ppResource); + void SetTextFilterSize( + [in] UINT Width, + [in] UINT Height); + void GetTextFilterSize( + [out] UINT *pWidth, + [out] UINT *pHeight); +} + +[ + object, + local, + uuid(9b7e4e00-342c-4106-a19f-4f2704f689f0) +] +interface ID3D10Multithread : IUnknown +{ + void Enter(); + void Leave(); + BOOL SetMultithreadProtected( + [in] BOOL bMTProtect); + BOOL GetMultithreadProtected(); +} + +cpp_quote("#ifndef D3D10_IGNORE_SDK_LAYERS") +cpp_quote("#include \"d3d10sdklayers.h\"") +cpp_quote("#endif") +cpp_quote("#include \"d3d10misc.h\"") +cpp_quote("#include \"d3d10shader.h\"") +cpp_quote("#include \"d3d10effect.h\"") diff --git a/WineFix/lib/d2d1/include/windows/d3d10_1.idl b/WineFix/lib/d2d1/include/windows/d3d10_1.idl new file mode 100644 index 0000000..a37ff9e --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10_1.idl @@ -0,0 +1,157 @@ +/* + * Copyright 2010 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; + +cpp_quote("#ifndef _D3D10_1_CONSTANTS") +cpp_quote("#define _D3D10_1_CONSTANTS") +const UINT D3D10_1_DEFAULT_SAMPLE_MASK = 0xffffffff; +const UINT D3D10_1_GS_INPUT_REGISTER_COUNT = 32; +const UINT D3D10_1_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32; +const UINT D3D10_1_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128; +const UINT D3D10_1_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32; +const UINT D3D10_1_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1; +const UINT D3D10_1_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D10_1_PS_OUTPUT_MASK_REGISTER_COUNT = 1; +const UINT D3D10_1_SHADER_MAJOR_VERSION = 4; +const UINT D3D10_1_SHADER_MINOR_VERSION = 1; +const UINT D3D10_1_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; +const UINT D3D10_1_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 256; +const UINT D3D10_1_SO_BUFFER_SLOT_COUNT = 4; +const UINT D3D10_1_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER = 1; +const UINT D3D10_1_SO_SINGLE_BUFFER_COMPONENT_LIMIT = 64; +const UINT D3D10_1_STANDARD_VERTEX_ELEMENT_COUNT = 32; +const UINT D3D10_1_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; +const UINT D3D10_1_VS_INPUT_REGISTER_COUNT = 32; +const UINT D3D10_1_VS_OUTPUT_REGISTER_COUNT = 32; +cpp_quote("#endif") + +cpp_quote("#define D3D10_1_FLOAT16_FUSED_TOLERANCE_IN_ULP (0.6)") +cpp_quote("#define D3D10_1_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP (0.6f)") + +import "d3d10.idl"; +cpp_quote("#include ") + + +typedef enum D3D10_FEATURE_LEVEL1 +{ + D3D10_FEATURE_LEVEL_10_0 = 0xa000, + D3D10_FEATURE_LEVEL_10_1 = 0xa100, + D3D10_FEATURE_LEVEL_9_1 = 0x9100, + D3D10_FEATURE_LEVEL_9_2 = 0x9200, + D3D10_FEATURE_LEVEL_9_3 = 0x9300 +} D3D10_FEATURE_LEVEL1; + +typedef struct D3D10_RENDER_TARGET_BLEND_DESC1 +{ + BOOL BlendEnable; + D3D10_BLEND SrcBlend; + D3D10_BLEND DestBlend; + D3D10_BLEND_OP BlendOp; + D3D10_BLEND SrcBlendAlpha; + D3D10_BLEND DestBlendAlpha; + D3D10_BLEND_OP BlendOpAlpha; + UINT8 RenderTargetWriteMask; +} D3D10_RENDER_TARGET_BLEND_DESC1; + +typedef struct D3D10_BLEND_DESC1 +{ + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + D3D10_RENDER_TARGET_BLEND_DESC1 RenderTarget[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT]; +} D3D10_BLEND_DESC1; + +[ + uuid(edad8d99-8a35-4d6d-8566-2ea276cde161), + object, + local, + pointer_default(unique) +] +interface ID3D10BlendState1 : ID3D10BlendState +{ + void GetDesc1([out] D3D10_BLEND_DESC1 *pDesc); +} + +typedef struct D3D10_TEXCUBE_ARRAY_SRV1 +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT First2DArrayFace; + UINT NumCubes; +} D3D10_TEXCUBE_ARRAY_SRV1; + +typedef D3D_SRV_DIMENSION D3D10_SRV_DIMENSION1; + +typedef struct D3D10_SHADER_RESOURCE_VIEW_DESC1 +{ + DXGI_FORMAT Format; + D3D10_SRV_DIMENSION1 ViewDimension; + union { + D3D10_BUFFER_SRV Buffer; + D3D10_TEX1D_SRV Texture1D; + D3D10_TEX1D_ARRAY_SRV Texture1DArray; + D3D10_TEX2D_SRV Texture2D; + D3D10_TEX2D_ARRAY_SRV Texture2DArray; + D3D10_TEX2DMS_SRV Texture2DMS; + D3D10_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D10_TEX3D_SRV Texture3D; + D3D10_TEXCUBE_SRV TextureCube; + D3D10_TEXCUBE_ARRAY_SRV1 TextureCubeArray; + }; +} D3D10_SHADER_RESOURCE_VIEW_DESC1; + +[ + uuid(9b7e4c87-342c-4106-a19f-4f2704f689f0), + object, + local, + pointer_default(unique) +] +interface ID3D10ShaderResourceView1 : ID3D10ShaderResourceView +{ + void GetDesc1([out] D3D10_SHADER_RESOURCE_VIEW_DESC1 *pDesc); +} + +[ + uuid(9b7e4c8f-342c-4106-a19f-4f2704f689f0), + object, + local, + pointer_default(unique) +] +interface ID3D10Device1 : ID3D10Device +{ + HRESULT CreateShaderResourceView1( + [in] ID3D10Resource *pResource, + [in, out] const D3D10_SHADER_RESOURCE_VIEW_DESC1 *pDesc, + [out] ID3D10ShaderResourceView1 **ppSRView); + + HRESULT CreateBlendState1( + [in] const D3D10_BLEND_DESC1 *pBlendStateDesc, + [out] ID3D10BlendState1 **ppBlendState); + + D3D10_FEATURE_LEVEL1 GetFeatureLevel(); +} + +const UINT D3D10_1_SDK_VERSION = 0x20; + +cpp_quote("HRESULT WINAPI D3D10CreateDevice1(IDXGIAdapter*,D3D10_DRIVER_TYPE,") +cpp_quote(" HMODULE,UINT,D3D10_FEATURE_LEVEL1,UINT,ID3D10Device1**);") + +[local] HRESULT __stdcall D3D10CreateDeviceAndSwapChain1(IDXGIAdapter *adapter, enum D3D10_DRIVER_TYPE driver_type, + HMODULE swrast, UINT flags, D3D10_FEATURE_LEVEL1 feature_level, UINT sdk_version, + DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, ID3D10Device1 **device); diff --git a/WineFix/lib/d2d1/include/windows/d3d10_1shader.h b/WineFix/lib/d2d1/include/windows/d3d10_1shader.h new file mode 100644 index 0000000..06dded7 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10_1shader.h @@ -0,0 +1,52 @@ +/* + * Copyright 2010 Rico Schüller + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3D10_1SHADER_H__ +#define __D3D10_1SHADER_H__ + +#include "d3d10shader.h" + +DEFINE_GUID(IID_ID3D10ShaderReflection1, 0xc3457783, 0xa846, 0x47ce, 0x95, 0x20, 0xce, 0xa6, 0xf6, 0x6e, 0x74, 0x47); + +#define INTERFACE ID3D10ShaderReflection1 +DECLARE_INTERFACE_(ID3D10ShaderReflection1, IUnknown) +{ + /* IUnknown methods */ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /* ID3D10ShaderReflection1 methods */ + STDMETHOD(GetDesc)(THIS_ D3D10_SHADER_DESC *desc) PURE; + STDMETHOD_(struct ID3D10ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ UINT index) PURE; + STDMETHOD_(struct ID3D10ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ const char *name) PURE; + STDMETHOD(GetResourceBindingDesc)(THIS_ UINT index, D3D10_SHADER_INPUT_BIND_DESC *desc) PURE; + STDMETHOD(GetInputParameterDesc)(THIS_ UINT index, D3D10_SIGNATURE_PARAMETER_DESC *desc) PURE; + STDMETHOD(GetOutputParameterDesc)(THIS_ UINT index, D3D10_SIGNATURE_PARAMETER_DESC *desc) PURE; + STDMETHOD_(struct ID3D10ShaderReflectionVariable *, GetVariableByName)(THIS_ const char *name) PURE; + STDMETHOD(GetResourceBindingDescByName)(THIS_ const char *name, D3D10_SHADER_INPUT_BIND_DESC *desc) PURE; + STDMETHOD(GetMovInstructionCount)(THIS_ UINT *count) PURE; + STDMETHOD(GetMovcInstructionCount)(THIS_ UINT *count) PURE; + STDMETHOD(GetConversionInstructionCount)(THIS_ UINT *count) PURE; + STDMETHOD(GetBitwiseInstructionCount)(THIS_ UINT *count) PURE; + STDMETHOD(GetGSInputPrimitive)(THIS_ D3D10_PRIMITIVE *prim) PURE; + STDMETHOD(IsLevel9Shader)(THIS_ BOOL *level9shader) PURE; + STDMETHOD(IsSampleFrequencyShader)(THIS_ BOOL *samplefrequency) PURE; +}; +#undef INTERFACE + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3d10effect.idl b/WineFix/lib/d2d1/include/windows/d3d10effect.idl new file mode 100644 index 0000000..fe526aa --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10effect.idl @@ -0,0 +1,512 @@ +/* + * Copyright 2009 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d3d10.idl"; +import "d3d10shader.idl"; + +interface ID3D10EffectConstantBuffer; +interface ID3D10EffectBlendVariable; +interface ID3D10EffectDepthStencilVariable; +interface ID3D10EffectDepthStencilViewVariable; +interface ID3D10EffectMatrixVariable; +interface ID3D10EffectPass; +interface ID3D10EffectRasterizerVariable; +interface ID3D10EffectRenderTargetViewVariable; +interface ID3D10EffectSamplerVariable; +interface ID3D10EffectScalarVariable; +interface ID3D10EffectShaderVariable; +interface ID3D10EffectShaderResourceVariable; +interface ID3D10EffectStringVariable; +interface ID3D10EffectVectorVariable; + +#ifndef D3D10_BYTES_FROM_BITS +#define D3D10_BYTES_FROM_BITS(x) (((x) + 7) >> 3) +#endif +cpp_quote("#ifndef D3D10_BYTES_FROM_BITS") +cpp_quote("#define D3D10_BYTES_FROM_BITS(x) (((x) + 7) >> 3)") +cpp_quote("#endif") + +const unsigned int D3D10_EFFECT_VARIABLE_POOLED = 0x1; +const unsigned int D3D10_EFFECT_VARIABLE_ANNOTATION = 0x2; +const unsigned int D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT = 0x4; + +typedef enum _D3D10_DEVICE_STATE_TYPES +{ + D3D10_DST_SO_BUFFERS = 1, + D3D10_DST_OM_RENDER_TARGETS, + D3D10_DST_OM_DEPTH_STENCIL_STATE, + D3D10_DST_OM_BLEND_STATE, + D3D10_DST_VS, + D3D10_DST_VS_SAMPLERS, + D3D10_DST_VS_SHADER_RESOURCES, + D3D10_DST_VS_CONSTANT_BUFFERS, + D3D10_DST_GS, + D3D10_DST_GS_SAMPLERS, + D3D10_DST_GS_SHADER_RESOURCES, + D3D10_DST_GS_CONSTANT_BUFFERS, + D3D10_DST_PS, + D3D10_DST_PS_SAMPLERS, + D3D10_DST_PS_SHADER_RESOURCES, + D3D10_DST_PS_CONSTANT_BUFFERS, + D3D10_DST_IA_VERTEX_BUFFERS, + D3D10_DST_IA_INDEX_BUFFER, + D3D10_DST_IA_INPUT_LAYOUT, + D3D10_DST_IA_PRIMITIVE_TOPOLOGY, + D3D10_DST_RS_VIEWPORTS, + D3D10_DST_RS_SCISSOR_RECTS, + D3D10_DST_RS_RASTERIZER_STATE, + D3D10_DST_PREDICATION, +} D3D10_DEVICE_STATE_TYPES; + +typedef struct _D3D10_EFFECT_TYPE_DESC +{ + const char *TypeName; + D3D10_SHADER_VARIABLE_CLASS Class; + D3D10_SHADER_VARIABLE_TYPE Type; + UINT Elements; + UINT Members; + UINT Rows; + UINT Columns; + UINT PackedSize; + UINT UnpackedSize; + UINT Stride; +} D3D10_EFFECT_TYPE_DESC; + +typedef struct _D3D10_EFFECT_VARIABLE_DESC +{ + const char *Name; + const char *Semantic; + UINT Flags; + UINT Annotations; + UINT BufferOffset; + UINT ExplicitBindPoint; +} D3D10_EFFECT_VARIABLE_DESC; + +typedef struct _D3D10_TECHNIQUE_DESC +{ + const char *Name; + UINT Passes; + UINT Annotations; +} D3D10_TECHNIQUE_DESC; + +typedef struct _D3D10_STATE_BLOCK_MASK +{ + BYTE VS; + BYTE VSSamplers[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)]; + BYTE VSShaderResources[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)]; + BYTE VSConstantBuffers[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)]; + BYTE GS; + BYTE GSSamplers[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)]; + BYTE GSShaderResources[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)]; + BYTE GSConstantBuffers[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)]; + BYTE PS; + BYTE PSSamplers[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)]; + BYTE PSShaderResources[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)]; + BYTE PSConstantBuffers[D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)]; + BYTE IAVertexBuffers[D3D10_BYTES_FROM_BITS(D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT)]; + BYTE IAIndexBuffer; + BYTE IAInputLayout; + BYTE IAPrimitiveTopology; + BYTE OMRenderTargets; + BYTE OMDepthStencilState; + BYTE OMBlendState; + BYTE RSViewports; + BYTE RSScissorRects; + BYTE RSRasterizerState; + BYTE SOBuffers; + BYTE Predication; +} D3D10_STATE_BLOCK_MASK; + +typedef struct _D3D10_EFFECT_DESC +{ + BOOL IsChildEffect; + UINT ConstantBuffers; + UINT SharedConstantBuffers; + UINT GlobalVariables; + UINT SharedGlobalVariables; + UINT Techniques; +} D3D10_EFFECT_DESC; + +typedef struct _D3D10_EFFECT_SHADER_DESC +{ + const BYTE *pInputSignature; + BOOL IsInline; + const BYTE *pBytecode; + UINT BytecodeLength; + const char *SODecl; + UINT NumInputSignatureEntries; + UINT NumOutputSignatureEntries; +} D3D10_EFFECT_SHADER_DESC; + +typedef struct _D3D10_PASS_DESC +{ + const char *Name; + UINT Annotations; + BYTE *pIAInputSignature; + SIZE_T IAInputSignatureSize; + UINT StencilRef; + UINT SampleMask; + FLOAT BlendFactor[4]; +} D3D10_PASS_DESC; + +typedef struct _D3D10_PASS_SHADER_DESC +{ + ID3D10EffectShaderVariable *pShaderVariable; + UINT ShaderIndex; +} D3D10_PASS_SHADER_DESC; + +const unsigned int D3D10_EFFECT_COMPILE_CHILD_EFFECT = 0x0001; +const unsigned int D3D10_EFFECT_COMPILE_ALLOW_SLOW_OPS = 0x0002; +const unsigned int D3D10_EFFECT_SINGLE_THREADED = 0x0008; + +[ + local, + object, + uuid(4e9e1ddc-cd9d-4772-a837-00180b9b88fd), +] +interface ID3D10EffectType +{ + BOOL IsValid(); + HRESULT GetDesc(D3D10_EFFECT_TYPE_DESC *desc); + ID3D10EffectType *GetMemberTypeByIndex(UINT index); + ID3D10EffectType *GetMemberTypeByName(const char *name); + ID3D10EffectType *GetMemberTypeBySemantic(const char *semantic); + const char *GetMemberName(UINT index); + const char *GetMemberSemantic(UINT index); +} + +[ + local, + object, + uuid(ae897105-00e6-45bf-bb8e-281dd6db8e1b), +] +interface ID3D10EffectVariable +{ + BOOL IsValid(); + ID3D10EffectType *GetType(); + HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC *desc); + ID3D10EffectVariable *GetAnnotationByIndex(UINT index); + ID3D10EffectVariable *GetAnnotationByName(const char *name); + ID3D10EffectVariable *GetMemberByIndex(UINT index); + ID3D10EffectVariable *GetMemberByName(const char *name); + ID3D10EffectVariable *GetMemberBySemantic(const char *semantic); + ID3D10EffectVariable *GetElement(UINT index); + ID3D10EffectConstantBuffer *GetParentConstantBuffer(); + ID3D10EffectScalarVariable *AsScalar(); + ID3D10EffectVectorVariable *AsVector(); + ID3D10EffectMatrixVariable *AsMatrix(); + ID3D10EffectStringVariable *AsString(); + ID3D10EffectShaderResourceVariable *AsShaderResource(); + ID3D10EffectRenderTargetViewVariable *AsRenderTargetView(); + ID3D10EffectDepthStencilViewVariable *AsDepthStencilView(); + ID3D10EffectConstantBuffer *AsConstantBuffer(); + ID3D10EffectShaderVariable *AsShader(); + ID3D10EffectBlendVariable *AsBlend(); + ID3D10EffectDepthStencilVariable *AsDepthStencil(); + ID3D10EffectRasterizerVariable *AsRasterizer(); + ID3D10EffectSamplerVariable *AsSampler(); + HRESULT SetRawValue(void *data, UINT offset, UINT count); + HRESULT GetRawValue(void *data, UINT offset, UINT count); +} + +[ + local, + object, + uuid(56648f4d-cc8b-4444-a5ad-b5a3d76e91b3), +] +interface ID3D10EffectConstantBuffer : ID3D10EffectVariable +{ + HRESULT SetConstantBuffer(ID3D10Buffer *buffer); + HRESULT GetConstantBuffer(ID3D10Buffer **buffer); + HRESULT SetTextureBuffer(ID3D10ShaderResourceView *view); + HRESULT GetTextureBuffer(ID3D10ShaderResourceView **view); +} + +[ + local, + object, + uuid(00e48f7b-d2c8-49e8-a86c-022dee53431f), +] +interface ID3D10EffectScalarVariable : ID3D10EffectVariable +{ + HRESULT SetFloat(float value); + HRESULT GetFloat(float *value); + HRESULT SetFloatArray(float *values, UINT offset, UINT count); + HRESULT GetFloatArray(float *values, UINT offset, UINT count); + HRESULT SetInt(int value); + HRESULT GetInt(int *value); + HRESULT SetIntArray(int *values, UINT offset, UINT count); + HRESULT GetIntArray(int *values, UINT offset, UINT count); + HRESULT SetBool(BOOL value); + HRESULT GetBool(BOOL *value); + HRESULT SetBoolArray(BOOL *values, UINT offset, UINT count); + HRESULT GetBoolArray(BOOL *values, UINT offset, UINT count); +} + +[ + local, + object, + uuid(62b98c44-1f82-4c67-bcd0-72cf8f217e81), +] +interface ID3D10EffectVectorVariable : ID3D10EffectVariable +{ + HRESULT SetBoolVector(BOOL *value); + HRESULT SetIntVector(int *value); + HRESULT SetFloatVector(float *value); + HRESULT GetBoolVector(BOOL *value); + HRESULT GetIntVector(int *value); + HRESULT GetFloatVector(float *value); + HRESULT SetBoolVectorArray(BOOL *values, UINT offset, UINT count); + HRESULT SetIntVectorArray(int *values, UINT offset, UINT count); + HRESULT SetFloatVectorArray(float *values, UINT offset, UINT count); + HRESULT GetBoolVectorArray(BOOL *values, UINT offset, UINT count); + HRESULT GetIntVectorArray(int *values, UINT offset, UINT count); + HRESULT GetFloatVectorArray(float *values, UINT offset, UINT count); +} + +[ + local, + object, + uuid(50666c24-b82f-4eed-a172-5b6e7e8522e0), +] +interface ID3D10EffectMatrixVariable : ID3D10EffectVariable +{ + HRESULT SetMatrix(float *data); + HRESULT GetMatrix(float *data); + HRESULT SetMatrixArray(float *data, UINT offset, UINT count); + HRESULT GetMatrixArray(float *data, UINT offset, UINT count); + HRESULT SetMatrixTranspose(float *data); + HRESULT GetMatrixTranspose(float *data); + HRESULT SetMatrixTransposeArray(float *data, UINT offset, UINT count); + HRESULT GetMatrixTransposeArray(float *data, UINT offset, UINT count); +} + +[ + local, + object, + uuid(71417501-8df9-4e0a-a78a-255f9756baff), +] +interface ID3D10EffectStringVariable : ID3D10EffectVariable +{ + HRESULT GetString(const char **str); + HRESULT GetStringArray(const char **strs, UINT offset, UINT count); +} + +[ + local, + object, + uuid(c0a7157b-d872-4b1d-8073-efc2acd4b1fc), +] +interface ID3D10EffectShaderResourceVariable : ID3D10EffectVariable +{ + HRESULT SetResource(ID3D10ShaderResourceView *resource); + HRESULT GetResource(ID3D10ShaderResourceView **resource); + HRESULT SetResourceArray(ID3D10ShaderResourceView **resources, UINT offset, UINT count); + HRESULT GetResourceArray(ID3D10ShaderResourceView **resources, UINT offset, UINT count); +} + +[ + local, + object, + uuid(28ca0cc3-c2c9-40bb-b57f-67b737122b17), +] +interface ID3D10EffectRenderTargetViewVariable : ID3D10EffectVariable +{ + HRESULT SetRenderTarget(ID3D10RenderTargetView *view); + HRESULT GetRenderTarget(ID3D10RenderTargetView **view); + HRESULT SetRenderTargetArray(ID3D10RenderTargetView **views, UINT offset, UINT count); + HRESULT GetRenderTargetArray(ID3D10RenderTargetView **views, UINT offset, UINT count); +} + +[ + local, + object, + uuid(3e02c918-cc79-4985-b622-2d92ad701623), +] +interface ID3D10EffectDepthStencilViewVariable : ID3D10EffectVariable +{ + HRESULT SetDepthStencil(ID3D10DepthStencilView *view); + HRESULT GetDepthStencil(ID3D10DepthStencilView **view); + HRESULT SetDepthStencilArray(ID3D10DepthStencilView **views, UINT offset, UINT count); + HRESULT GetDepthStencilArray(ID3D10DepthStencilView **views, UINT offset, UINT count); +} + +[ + local, + object, + uuid(80849279-c799-4797-8c33-0407a07d9e06), +] +interface ID3D10EffectShaderVariable : ID3D10EffectVariable +{ + HRESULT GetShaderDesc(UINT index, D3D10_EFFECT_SHADER_DESC *desc); + HRESULT GetVertexShader(UINT index, ID3D10VertexShader **shader); + HRESULT GetGeometryShader(UINT index, ID3D10GeometryShader **shader); + HRESULT GetPixelShader(UINT index, ID3D10PixelShader **shader); + HRESULT GetInputSignatureElementDesc(UINT shader_index, UINT element_index, + D3D10_SIGNATURE_PARAMETER_DESC *desc); + HRESULT GetOutputSignatureElementDesc(UINT shader_index, UINT element_index, + D3D10_SIGNATURE_PARAMETER_DESC *desc); +} + +[ + local, + object, + uuid(1fcd2294-df6d-4eae-86b3-0e9160cfb07b), +] +interface ID3D10EffectBlendVariable : ID3D10EffectVariable +{ + HRESULT GetBlendState(UINT index, ID3D10BlendState **blend_state); + HRESULT GetBackingStore(UINT index, D3D10_BLEND_DESC *desc); +} + +[ + local, + object, + uuid(af482368-330a-46a5-9a5c-01c71af24c8d), +] +interface ID3D10EffectDepthStencilVariable : ID3D10EffectVariable +{ + HRESULT GetDepthStencilState(UINT index, ID3D10DepthStencilState **depth_stencil_state); + HRESULT GetBackingStore(UINT index, D3D10_DEPTH_STENCIL_DESC *desc); +} + +[ + local, + object, + uuid(21af9f0e-4d94-4ea9-9785-2cb76b8c0b34), +] +interface ID3D10EffectRasterizerVariable : ID3D10EffectVariable +{ + HRESULT GetRasterizerState(UINT index, ID3D10RasterizerState **rasterizer_state); + HRESULT GetBackingStore(UINT index, D3D10_RASTERIZER_DESC *desc); +} + +[ + local, + object, + uuid(6530d5c7-07e9-4271-a418-e7ce4bd1e480), +] +interface ID3D10EffectSamplerVariable : ID3D10EffectVariable +{ + HRESULT GetSampler(UINT index, ID3D10SamplerState **sampler); + HRESULT GetBackingStore(UINT index, D3D10_SAMPLER_DESC *desc); +} + +[ + local, + object, + uuid(db122ce8-d1c9-4292-b237-24ed3de8b175), +] +interface ID3D10EffectTechnique +{ + BOOL IsValid(); + HRESULT GetDesc(D3D10_TECHNIQUE_DESC *desc); + ID3D10EffectVariable *GetAnnotationByIndex(UINT index); + ID3D10EffectVariable *GetAnnotationByName(const char *name); + ID3D10EffectPass *GetPassByIndex(UINT index); + ID3D10EffectPass *GetPassByName(const char *name); + HRESULT ComputeStateBlockMask(D3D10_STATE_BLOCK_MASK *mask); +} + +[ + local, + object, + uuid(51b0ca8b-ec0b-4519-870d-8ee1cb5017c7), +] +interface ID3D10Effect : IUnknown +{ + BOOL IsValid(); + BOOL IsPool(); + HRESULT GetDevice(ID3D10Device **device); + HRESULT GetDesc(D3D10_EFFECT_DESC *desc); + ID3D10EffectConstantBuffer *GetConstantBufferByIndex(UINT index); + ID3D10EffectConstantBuffer *GetConstantBufferByName(const char *name); + ID3D10EffectVariable *GetVariableByIndex(UINT index); + ID3D10EffectVariable *GetVariableByName(const char *name); + ID3D10EffectVariable *GetVariableBySemantic(const char *semantic); + ID3D10EffectTechnique *GetTechniqueByIndex(UINT index); + ID3D10EffectTechnique *GetTechniqueByName(const char *name); + HRESULT Optimize(); + BOOL IsOptimized(); +} + +[ + local, + object, + uuid(9537ab04-3250-412e-8213-fcd2f8677933), +] +interface ID3D10EffectPool : IUnknown +{ + ID3D10Effect *AsEffect(); +} + +[ + local, + object, + uuid(5cfbeb89-1a06-46e0-b282-e3f9bfa36a54), +] +interface ID3D10EffectPass +{ + BOOL IsValid(); + HRESULT GetDesc(D3D10_PASS_DESC *desc); + HRESULT GetVertexShaderDesc(D3D10_PASS_SHADER_DESC *desc); + HRESULT GetGeometryShaderDesc(D3D10_PASS_SHADER_DESC *desc); + HRESULT GetPixelShaderDesc(D3D10_PASS_SHADER_DESC *desc); + ID3D10EffectVariable *GetAnnotationByIndex(UINT index); + ID3D10EffectVariable *GetAnnotationByName(const char *name); + HRESULT Apply(UINT flags); + HRESULT ComputeStateBlockMask(D3D10_STATE_BLOCK_MASK *mask); +} + +[ + local, + object, + uuid(0803425a-57f5-4dd6-9465-a87570834a08), +] +interface ID3D10StateBlock : IUnknown +{ + HRESULT Capture(); + HRESULT Apply(); + HRESULT ReleaseAllDeviceObjects(); + HRESULT GetDevice(ID3D10Device **device); +} + +HRESULT __stdcall D3D10CompileEffectFromMemory(void *data, SIZE_T data_size, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3D10Include *include, UINT hlsl_flags, UINT fx_flags, + ID3D10Blob **effect, ID3D10Blob **errors); +HRESULT __stdcall D3D10CreateEffectFromMemory(void *data, SIZE_T data_size, UINT flags, + ID3D10Device *device, ID3D10EffectPool *effect_pool, ID3D10Effect **effect); +HRESULT __stdcall D3D10CreateEffectPoolFromMemory(void *data, SIZE_T data_size, UINT fx_flags, + ID3D10Device *device, ID3D10EffectPool **effect_pool); +HRESULT __stdcall D3D10CreateStateBlock(ID3D10Device *device, + D3D10_STATE_BLOCK_MASK *mask, ID3D10StateBlock **stateblock); + +HRESULT __stdcall D3D10StateBlockMaskDifference(D3D10_STATE_BLOCK_MASK *mask_x, + D3D10_STATE_BLOCK_MASK *mask_y, D3D10_STATE_BLOCK_MASK *result); +HRESULT __stdcall D3D10StateBlockMaskDisableAll(D3D10_STATE_BLOCK_MASK *mask); +HRESULT __stdcall D3D10StateBlockMaskDisableCapture(D3D10_STATE_BLOCK_MASK *mask, + D3D10_DEVICE_STATE_TYPES state_type, UINT start_idx, UINT count); +HRESULT __stdcall D3D10StateBlockMaskEnableAll(D3D10_STATE_BLOCK_MASK *mask); +HRESULT __stdcall D3D10StateBlockMaskEnableCapture(D3D10_STATE_BLOCK_MASK *mask, + D3D10_DEVICE_STATE_TYPES state_type, UINT start_idx, UINT count); +BOOL __stdcall D3D10StateBlockMaskGetSetting(D3D10_STATE_BLOCK_MASK *mask, + D3D10_DEVICE_STATE_TYPES state_type, UINT idx); +HRESULT __stdcall D3D10StateBlockMaskIntersect(D3D10_STATE_BLOCK_MASK *mask_x, + D3D10_STATE_BLOCK_MASK *mask_y, D3D10_STATE_BLOCK_MASK *result); +HRESULT __stdcall D3D10StateBlockMaskUnion(D3D10_STATE_BLOCK_MASK *mask_x, + D3D10_STATE_BLOCK_MASK *mask_y, D3D10_STATE_BLOCK_MASK *result); diff --git a/WineFix/lib/d2d1/include/windows/d3d10misc.h b/WineFix/lib/d2d1/include/windows/d3d10misc.h new file mode 100644 index 0000000..f8f5617 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10misc.h @@ -0,0 +1,49 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3D10MISC_H__ +#define __D3D10MISC_H__ + +#include "d3d10.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum D3D10_DRIVER_TYPE { + D3D10_DRIVER_TYPE_HARDWARE = 0, + D3D10_DRIVER_TYPE_REFERENCE = 1, + D3D10_DRIVER_TYPE_NULL = 2, + D3D10_DRIVER_TYPE_SOFTWARE = 3, + D3D10_DRIVER_TYPE_WARP = 5, +} D3D10_DRIVER_TYPE; + +HRESULT WINAPI D3D10CreateDevice(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, + HMODULE swrast, UINT flags, UINT sdk_version, ID3D10Device **device); + +HRESULT WINAPI D3D10CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, + HMODULE swrast, UINT flags, UINT sdk_version, DXGI_SWAP_CHAIN_DESC *swapchain_desc, + IDXGISwapChain **swapchain, ID3D10Device **device); + +HRESULT WINAPI D3D10CreateBlob(SIZE_T data_size, ID3D10Blob **blob); + +#ifdef __cplusplus +} +#endif + +#endif /* __D3D10MISC_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3d10sdklayers.idl b/WineFix/lib/d2d1/include/windows/d3d10sdklayers.idl new file mode 100644 index 0000000..317f7c2 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10sdklayers.idl @@ -0,0 +1,719 @@ +/* + * Copyright 2016 Alistair Leslie-Hughes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi.idl"; + +cpp_quote("#ifdef WINE_NO_UNICODE_MACROS") +cpp_quote("#undef GetMessage") +cpp_quote("#endif") + +const UINT D3D10_DEBUG_FEATURE_FLUSH_PER_RENDER_OP = 0x1; +const UINT D3D10_DEBUG_FEATURE_FINISH_PER_RENDER_OP = 0x2; +const UINT D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP = 0x4; + +typedef enum D3D10_MESSAGE_CATEGORY +{ + D3D10_MESSAGE_CATEGORY_APPLICATION_DEFINED, + D3D10_MESSAGE_CATEGORY_MISCELLANEOUS, + D3D10_MESSAGE_CATEGORY_INITIALIZATION, + D3D10_MESSAGE_CATEGORY_CLEANUP, + D3D10_MESSAGE_CATEGORY_COMPILATION, + D3D10_MESSAGE_CATEGORY_STATE_CREATION, + D3D10_MESSAGE_CATEGORY_STATE_SETTING, + D3D10_MESSAGE_CATEGORY_STATE_GETTING, + D3D10_MESSAGE_CATEGORY_RESOURCE_MANIPULATION, + D3D10_MESSAGE_CATEGORY_EXECUTION, + D3D10_MESSAGE_CATEGORY_SHADER, +} D3D10_MESSAGE_CATEGORY; + +typedef enum D3D10_MESSAGE_SEVERITY +{ + D3D10_MESSAGE_SEVERITY_CORRUPTION, + D3D10_MESSAGE_SEVERITY_ERROR, + D3D10_MESSAGE_SEVERITY_WARNING, + D3D10_MESSAGE_SEVERITY_INFO, + D3D10_MESSAGE_SEVERITY_MESSAGE, +} D3D10_MESSAGE_SEVERITY; + +typedef enum D3D10_MESSAGE_ID +{ + D3D10_MESSAGE_ID_UNKNOWN = 0, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_HAZARD, + D3D10_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_HAZARD, + D3D10_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_HAZARD, + D3D10_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_HAZARD, + D3D10_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_OMSETRENDERTARGETS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_SOSETTARGETS_HAZARD, + D3D10_MESSAGE_ID_STRING_FROM_APPLICATION, + D3D10_MESSAGE_ID_CORRUPTED_THIS, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER1, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER2, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER3, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER4, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER5, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER6, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER7, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER8, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER9, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER10, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER11, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER12, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER13, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER14, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER15, + D3D10_MESSAGE_ID_CORRUPTED_MULTITHREADING, + D3D10_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY, + D3D10_MESSAGE_ID_IASETINPUTLAYOUT_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_IASETINDEXBUFFER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETSHADER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETSHADER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_SOSETTARGETS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETSHADER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_RSSETSTATE_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_OMSETBLENDSTATE_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_OMSETDEPTHSTENCILSTATE_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_SETPREDICATION_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GETPRIVATEDATA_MOREDATA, + D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA, + D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN, + D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS, + D3D10_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS, + D3D10_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATEBUFFER_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEBUFFER_NULLDESC, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDCONSTANTBUFFERBINDINGS, + D3D10_MESSAGE_ID_CREATEBUFFER_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE1D_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE1D_NULLDESC, + D3D10_MESSAGE_ID_CREATETEXTURE1D_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE2D_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE2D_NULLDESC, + D3D10_MESSAGE_ID_CREATETEXTURE2D_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE3D_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE3D_NULLDESC, + D3D10_MESSAGE_ID_CREATETEXTURE3D_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_NULLDESC, + D3D10_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE, + D3D10_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDQUERY, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_UNEXPECTEDMISCFLAG, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_NULLDESC, + D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED, + D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED, + D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_OFFSET_TOO_LARGE, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_IASETINDEXBUFFER_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_FORMAT_INVALID, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_TOO_LARGE, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSSETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSSETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_SOSETTARGETS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_SOSETTARGETS_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSSETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT, + D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR, + D3D10_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH, + D3D10_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH, + D3D10_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID, + D3D10_MESSAGE_ID_DEVICE_IAGETVERTEXBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSGETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSGETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_SOGETTARGETS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSGETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_RSGETVIEWPORTS_VIEWPORTS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_RSGETSCISSORRECTS_RECTS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GENERATEMIPS_RESOURCE_INVALID, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSUBRESOURCE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESUBRESOURCE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCEBOX, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSTATE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESTATE, + D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE, + D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE, + D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE, + D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE, + D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX, + D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID, + D3D10_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED, + D3D10_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED, + D3D10_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS, + D3D10_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE, + D3D10_MESSAGE_ID_REF_THREADING_MODE, + D3D10_MESSAGE_ID_REF_UMDRIVER_EXCEPTION, + D3D10_MESSAGE_ID_REF_KMDRIVER_EXCEPTION, + D3D10_MESSAGE_ID_REF_HARDWARE_EXCEPTION, + D3D10_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE, + D3D10_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER, + D3D10_MESSAGE_ID_REF_OUT_OF_MEMORY, + D3D10_MESSAGE_ID_REF_INFO, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_INPUTLAYOUT_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_SHADERRESOURCEVIEW_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_VIEW_DIMENSION_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_FORMAT_INVALID, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_GS_INPUT_PRIMITIVE_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_RETURN_TYPE_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_POSITION_NOT_PRESENT, + D3D10_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_BOUND_RESOURCE_MAPPED, + D3D10_MESSAGE_ID_DEVICE_DRAW_INVALID_PRIMITIVETOPOLOGY, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_STRIDE_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE, + D3D10_MESSAGE_ID_DEVICE_DRAW_SO_STRIDE_LARGER_THAN_BUFFER, + D3D10_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING, + D3D10_MESSAGE_ID_DEVICE_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0, + D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT, + D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT, + D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT, + D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN, + D3D10_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC, + D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW, + D3D10_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH, + D3D10_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY, + D3D10_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY, + D3D10_MESSAGE_ID_CREATEQUERY_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEPREDICATE_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATECOUNTER_OUTOFRANGE_COUNTER, + D3D10_MESSAGE_ID_CREATECOUNTER_SIMULTANEOUS_ACTIVE_COUNTERS_EXHAUSTED, + D3D10_MESSAGE_ID_CREATECOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER, + D3D10_MESSAGE_ID_CREATECOUNTER_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATECOUNTER_NONEXCLUSIVE_RETURN, + D3D10_MESSAGE_ID_CREATECOUNTER_NULLDESC, + D3D10_MESSAGE_ID_CHECKCOUNTER_OUTOFRANGE_COUNTER, + D3D10_MESSAGE_ID_CHECKCOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER, + D3D10_MESSAGE_ID_SETPREDICATION_INVALID_PREDICATE_STATE, + D3D10_MESSAGE_ID_QUERY_BEGIN_UNSUPPORTED, + D3D10_MESSAGE_ID_PREDICATE_BEGIN_DURING_PREDICATION, + D3D10_MESSAGE_ID_QUERY_BEGIN_DUPLICATE, + D3D10_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS, + D3D10_MESSAGE_ID_PREDICATE_END_DURING_PREDICATION, + D3D10_MESSAGE_ID_QUERY_END_ABANDONING_PREVIOUS_RESULTS, + D3D10_MESSAGE_ID_QUERY_END_WITHOUT_BEGIN, + D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_DATASIZE, + D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_FLAGS, + D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_CALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH, + D3D10_MESSAGE_ID_LIVE_OBJECT_SUMMARY, + D3D10_MESSAGE_ID_LIVE_BUFFER, + D3D10_MESSAGE_ID_LIVE_TEXTURE1D, + D3D10_MESSAGE_ID_LIVE_TEXTURE2D, + D3D10_MESSAGE_ID_LIVE_TEXTURE3D, + D3D10_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW, + D3D10_MESSAGE_ID_LIVE_RENDERTARGETVIEW, + D3D10_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW, + D3D10_MESSAGE_ID_LIVE_VERTEXSHADER, + D3D10_MESSAGE_ID_LIVE_GEOMETRYSHADER, + D3D10_MESSAGE_ID_LIVE_PIXELSHADER, + D3D10_MESSAGE_ID_LIVE_INPUTLAYOUT, + D3D10_MESSAGE_ID_LIVE_SAMPLER, + D3D10_MESSAGE_ID_LIVE_BLENDSTATE, + D3D10_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE, + D3D10_MESSAGE_ID_LIVE_RASTERIZERSTATE, + D3D10_MESSAGE_ID_LIVE_QUERY, + D3D10_MESSAGE_ID_LIVE_PREDICATE, + D3D10_MESSAGE_ID_LIVE_COUNTER, + D3D10_MESSAGE_ID_LIVE_DEVICE, + D3D10_MESSAGE_ID_LIVE_SWAPCHAIN, + D3D10_MESSAGE_ID_D3D10_MESSAGES_END, + + D3D10_MESSAGE_ID_D3D10L9_MESSAGES_START = 0x00100000, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_STENCIL_NO_TWO_SIDED, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_DepthBiasClamp_NOT_SUPPORTED, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NO_COMPARISON_SUPPORT, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_EXCESSIVE_ANISOTROPY, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_OUT_OF_RANGE, + D3D10_MESSAGE_ID_VSSETSAMPLERS_NOT_SUPPORTED, + D3D10_MESSAGE_ID_VSSETSAMPLERS_TOO_MANY_SAMPLERS, + D3D10_MESSAGE_ID_PSSETSAMPLERS_TOO_MANY_SAMPLERS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_ARRAYS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_VB_AND_IB_BIND, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_TEXTURE_1D, + D3D10_MESSAGE_ID_CREATERESOURCE_DIMENSION_OUT_OF_RANGE, + D3D10_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_SHADER_RESOURCE, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_TOO_MANY_RENDER_TARGETS, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_NO_DIFFERING_BIT_DEPTHS, + D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_BAD_BUFFER_INDEX, + D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_TOO_MANY_VIEWPORTS, + D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_ADJACENCY_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_TOO_MANY_SCISSORS, + D3D10_MESSAGE_ID_COPYRESOURCE_ONLY_TEXTURE_2D_WITHIN_GPU_MEMORY, + D3D10_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_3D_READBACK, + D3D10_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_ONLY_READBACK, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_UNSUPPORTED_FORMAT, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_ALPHA_TO_COVERAGE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_DepthClipEnable_MUST_BE_TRUE, + D3D10_MESSAGE_ID_DRAWINDEXED_STARTINDEXLOCATION_MUST_BE_POSITIVE, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_MUST_USE_LOWEST_LOD, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_MINLOD_MUST_NOT_BE_FRACTIONAL, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_MAXLOD_MUST_BE_FLT_MAX, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_FIRSTARRAYSLICE_MUST_BE_ZERO, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_CUBES_MUST_HAVE_6_SIDES, + D3D10_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_RENDER_TARGET, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_DWORD_INDEX_BUFFER, + D3D10_MESSAGE_ID_CREATERESOURCE_MSAA_PRECLUDES_SHADER_RESOURCE, + D3D10_MESSAGE_ID_CREATERESOURCE_PRESENTATION_PRECLUDES_SHADER_RESOURCE, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_BLEND_ENABLE, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_WRITE_MASKS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_STREAM_OUT, + D3D10_MESSAGE_ID_CREATERESOURCE_ONLY_VB_IB_FOR_BUFFERS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_AUTOGEN_FOR_VOLUMES, + D3D10_MESSAGE_ID_CREATERESOURCE_DXGI_FORMAT_R8G8B8A8_CANNOT_BE_SHARED, + D3D10_MESSAGE_ID_VSSHADERRESOURCES_NOT_SUPPORTED, + D3D10_MESSAGE_ID_GEOMETRY_SHADER_NOT_SUPPORTED, + D3D10_MESSAGE_ID_STREAM_OUT_NOT_SUPPORTED, + D3D10_MESSAGE_ID_TEXT_FILTER_NOT_SUPPORTED, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_SEPARATE_ALPHA_BLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_MRT_BLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_OPERATION_NOT_SUPPORTED, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NO_MIRRORONCE, + D3D10_MESSAGE_ID_DRAWINSTANCED_NOT_SUPPORTED, + D3D10_MESSAGE_ID_DRAWINDEXEDINSTANCED_NOT_SUPPORTED_BELOW_9_3, + D3D10_MESSAGE_ID_DRAWINDEXED_POINTLIST_UNSUPPORTED, + D3D10_MESSAGE_ID_SETBLENDSTATE_SAMPLE_MASK_CANNOT_BE_ZERO, + D3D10_MESSAGE_ID_CREATERESOURCE_DIMENSION_EXCEEDS_FEATURE_LEVEL_DEFINITION, + D3D10_MESSAGE_ID_CREATERESOURCE_ONLY_SINGLE_MIP_LEVEL_DEPTH_STENCIL_SUPPORTED, + D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_NEGATIVESCISSOR, + D3D10_MESSAGE_ID_SLOT_ZERO_MUST_BE_D3D10_INPUT_PER_VERTEX_DATA, + D3D10_MESSAGE_ID_CREATERESOURCE_NON_POW_2_MIPMAP, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_NOT_SUPPORTED, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_NO_SRGB_MRT, + D3D10_MESSAGE_ID_COPYRESOURCE_NO_3D_MISMATCHED_UPDATES, + D3D10_MESSAGE_ID_D3D10L9_MESSAGES_END, +} D3D10_MESSAGE_ID; + +typedef struct D3D10_MESSAGE +{ + D3D10_MESSAGE_CATEGORY Category; + D3D10_MESSAGE_SEVERITY Severity; + D3D10_MESSAGE_ID ID; + const char *pDescription; + SIZE_T DescriptionByteLength; +} D3D10_MESSAGE; + +typedef struct D3D10_INFO_QUEUE_FILTER_DESC +{ + UINT NumCategories; + D3D10_MESSAGE_CATEGORY *pCategoryList; + UINT NumSeverities; + D3D10_MESSAGE_SEVERITY *pSeverityList; + UINT NumIDs; + D3D10_MESSAGE_ID *pIDList; +} D3D10_INFO_QUEUE_FILTER_DESC; + +typedef struct D3D10_INFO_QUEUE_FILTER +{ + D3D10_INFO_QUEUE_FILTER_DESC AllowList; + D3D10_INFO_QUEUE_FILTER_DESC DenyList; +} D3D10_INFO_QUEUE_FILTER; + +[ + local, + object, + uuid(9b7e4e01-342c-4106-a19f-4f2704f689f0), + pointer_default(unique) +] +interface ID3D10Debug : IUnknown +{ + HRESULT SetFeatureMask( + [in] UINT mask + ); + UINT GetFeatureMask(); + HRESULT SetPresentPerRenderOpDelay( + [in] UINT milliseconds + ); + UINT GetPresentPerRenderOpDelay(); + HRESULT SetSwapChain( + [in] IDXGISwapChain *swapchain + ); + HRESULT GetSwapChain( + [out] IDXGISwapChain **swapchain + ); + HRESULT Validate(); +} + +[ + local, + object, + uuid(9b7e4e02-342c-4106-a19f-4f2704f689f0), + pointer_default(unique) +] +interface ID3D10SwitchToRef : IUnknown +{ + BOOL SetUseRef( + [in] BOOL useref + ); + BOOL GetUseRef(); +} + +[ + local, + object, + uuid(1b940b17-2642-4d1f-ab1f-b99bad0c395f), + pointer_default(unique) +] +interface ID3D10InfoQueue : IUnknown +{ + HRESULT SetMessageCountLimit( + [in] UINT64 limit + ); + void ClearStoredMessages(); + HRESULT GetMessage( + [in] UINT64 message_idx, + [out] D3D10_MESSAGE *message, + [in, out] SIZE_T *message_size + ); + UINT64 GetNumMessagesAllowedByStorageFilter(); + UINT64 GetNumMessagesDeniedByStorageFilter(); + UINT64 GetNumStoredMessages(); + UINT64 GetNumStoredMessagesAllowedByRetrievalFilter(); + UINT64 GetNumMessagesDiscardedByMessageCountLimit(); + UINT64 GetMessageCountLimit(); + HRESULT AddStorageFilterEntries( + [in] D3D10_INFO_QUEUE_FILTER *filter + ); + HRESULT GetStorageFilter( + [out] D3D10_INFO_QUEUE_FILTER *filter, + [in, out] SIZE_T *filter_size + ); + void ClearStorageFilter(); + HRESULT PushEmptyStorageFilter(); + HRESULT PushCopyOfStorageFilter(); + HRESULT PushStorageFilter( + [in] D3D10_INFO_QUEUE_FILTER *filter + ); + void PopStorageFilter(); + UINT GetStorageFilterStackSize(); + HRESULT AddRetrievalFilterEntries( + [in] D3D10_INFO_QUEUE_FILTER *filter + ); + HRESULT GetRetrievalFilter( + [out] D3D10_INFO_QUEUE_FILTER *filter, + [in, out] SIZE_T *filterbytelength + ); + void ClearRetrievalFilter(); + HRESULT PushEmptyRetrievalFilter(); + HRESULT PushCopyOfRetrievalFilter(); + HRESULT PushRetrievalFilter( + [in] D3D10_INFO_QUEUE_FILTER *filter + ); + void PopRetrievalFilter(); + UINT GetRetrievalFilterStackSize(); + HRESULT AddMessage( + [in] D3D10_MESSAGE_CATEGORY category, + [in] D3D10_MESSAGE_SEVERITY severity, + [in] D3D10_MESSAGE_ID id, + [in] const char *description + ); + HRESULT AddApplicationMessage( + [in] D3D10_MESSAGE_SEVERITY severity, + [in] const char *description + ); + HRESULT SetBreakOnCategory( + [in] D3D10_MESSAGE_CATEGORY category, + [in] BOOL enable + ); + HRESULT SetBreakOnSeverity( + [in] D3D10_MESSAGE_SEVERITY severity, + [in] BOOL enable + ); + HRESULT SetBreakOnID( + [in] D3D10_MESSAGE_ID id, + [in] BOOL enable + ); + BOOL GetBreakOnCategory( + [in] D3D10_MESSAGE_CATEGORY category + ); + BOOL GetBreakOnSeverity( + [in] D3D10_MESSAGE_SEVERITY severity + ); + BOOL GetBreakOnID( + [in] D3D10_MESSAGE_ID id + ); + void SetMuteDebugOutput( + [in] BOOL mute + ); + BOOL GetMuteDebugOutput(); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d10shader.idl b/WineFix/lib/d2d1/include/windows/d3d10shader.idl new file mode 100644 index 0000000..91f453d --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d10shader.idl @@ -0,0 +1,217 @@ +/* + * Copyright 2009 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d3d10.idl"; + +const unsigned int D3D10_SHADER_DEBUG = 0x00001; +const unsigned int D3D10_SHADER_SKIP_VALIDATION = 0x00002; +const unsigned int D3D10_SHADER_SKIP_OPTIMIZATION = 0x00004; +const unsigned int D3D10_SHADER_PACK_MATRIX_ROW_MAJOR = 0x00008; +const unsigned int D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR = 0x00010; +const unsigned int D3D10_SHADER_PARTIAL_PRECISION = 0x00020; +const unsigned int D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT = 0x00040; +const unsigned int D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT = 0x00080; +const unsigned int D3D10_SHADER_NO_PRESHADER = 0x00100; +const unsigned int D3D10_SHADER_AVOID_FLOW_CONTROL = 0x00200; +const unsigned int D3D10_SHADER_PREFER_FLOW_CONTROL = 0x00400; +const unsigned int D3D10_SHADER_ENABLE_STRICTNESS = 0x00800; +const unsigned int D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY = 0x01000; +const unsigned int D3D10_SHADER_IEEE_STRICTNESS = 0x02000; +const unsigned int D3D10_SHADER_WARNINGS_ARE_ERRORS = 0x40000; + +const unsigned int D3D10_SHADER_OPTIMIZATION_LEVEL0 = 0x04000; +const unsigned int D3D10_SHADER_OPTIMIZATION_LEVEL1 = 0x00000; +const unsigned int D3D10_SHADER_OPTIMIZATION_LEVEL2 = 0x0c000; +const unsigned int D3D10_SHADER_OPTIMIZATION_LEVEL3 = 0x08000; + +typedef D3D_SHADER_MACRO D3D10_SHADER_MACRO; +typedef D3D_SHADER_MACRO *LPD3D10_SHADER_MACRO; + +typedef D3D_SHADER_VARIABLE_CLASS D3D10_SHADER_VARIABLE_CLASS; +typedef D3D_SHADER_VARIABLE_CLASS *LPD3D10_SHADER_VARIABLE_CLASS; + +typedef D3D_CBUFFER_TYPE D3D10_CBUFFER_TYPE; +typedef D3D_CBUFFER_TYPE *LPD3D10_CBUFFER_TYPE; + +typedef D3D_REGISTER_COMPONENT_TYPE D3D10_REGISTER_COMPONENT_TYPE; + +typedef D3D_RESOURCE_RETURN_TYPE D3D10_RESOURCE_RETURN_TYPE; + +typedef D3D_NAME D3D10_NAME; + +typedef D3D_SHADER_INPUT_TYPE D3D10_SHADER_INPUT_TYPE; +typedef D3D_SHADER_INPUT_TYPE *LPD3D10_SHADER_INPUT_TYPE; + +typedef D3D_SHADER_VARIABLE_TYPE D3D10_SHADER_VARIABLE_TYPE; +typedef D3D_SHADER_VARIABLE_TYPE *LPD3D10_SHADER_VARIABLE_TYPE; + +typedef D3D_INCLUDE_TYPE D3D10_INCLUDE_TYPE; +typedef ID3DInclude ID3D10Include; +typedef ID3DInclude *LPD3D10INCLUDE; +cpp_quote("#define IID_ID3D10Include IID_ID3DInclude") + +typedef struct _D3D10_SHADER_INPUT_BIND_DESC +{ + const char *Name; + D3D10_SHADER_INPUT_TYPE Type; + UINT BindPoint; + UINT BindCount; + UINT uFlags; + D3D10_RESOURCE_RETURN_TYPE ReturnType; + D3D10_SRV_DIMENSION Dimension; + UINT NumSamples; +} D3D10_SHADER_INPUT_BIND_DESC; + +typedef struct _D3D10_SIGNATURE_PARAMETER_DESC +{ + const char *SemanticName; + UINT SemanticIndex; + UINT Register; + D3D10_NAME SystemValueType; + D3D10_REGISTER_COMPONENT_TYPE ComponentType; + BYTE Mask; + BYTE ReadWriteMask; +} D3D10_SIGNATURE_PARAMETER_DESC; + +typedef struct _D3D10_SHADER_DESC +{ + UINT Version; + const char *Creator; + UINT Flags; + UINT ConstantBuffers; + UINT BoundResources; + UINT InputParameters; + UINT OutputParameters; + UINT InstructionCount; + UINT TempRegisterCount; + UINT TempArrayCount; + UINT DefCount; + UINT DclCount; + UINT TextureNormalInstructions; + UINT TextureLoadInstructions; + UINT TextureCompInstructions; + UINT TextureBiasInstructions; + UINT TextureGradientInstructions; + UINT FloatInstructionCount; + UINT IntInstructionCount; + UINT UintInstructionCount; + UINT StaticFlowControlCount; + UINT DynamicFlowControlCount; + UINT MacroInstructionCount; + UINT ArrayInstructionCount; + UINT CutInstructionCount; + UINT EmitInstructionCount; + D3D10_PRIMITIVE_TOPOLOGY GSOutputTopology; + UINT GSMaxOutputVertexCount; +} D3D10_SHADER_DESC; + +typedef struct _D3D10_SHADER_BUFFER_DESC +{ + const char *Name; + D3D10_CBUFFER_TYPE Type; + UINT Variables; + UINT Size; + UINT uFlags; +} D3D10_SHADER_BUFFER_DESC; + +typedef struct _D3D10_SHADER_VARIABLE_DESC +{ + const char *Name; + UINT StartOffset; + UINT Size; + UINT uFlags; + void *DefaultValue; +} D3D10_SHADER_VARIABLE_DESC; + +typedef struct _D3D10_SHADER_TYPE_DESC +{ + D3D10_SHADER_VARIABLE_CLASS Class; + D3D10_SHADER_VARIABLE_TYPE Type; + UINT Rows; + UINT Columns; + UINT Elements; + UINT Members; + UINT Offset; +} D3D10_SHADER_TYPE_DESC; + +[ + local, + object, + uuid(c530ad7d-9b16-4395-a979-ba2ecff83add), +] +interface ID3D10ShaderReflectionType +{ + HRESULT GetDesc(D3D10_SHADER_TYPE_DESC *desc); + ID3D10ShaderReflectionType *GetMemberTypeByIndex(UINT index); + ID3D10ShaderReflectionType *GetMemberTypeByName(const char *name); + const char *GetMemberTypeName(UINT index); +}; + +[ + local, + object, + uuid(1bf63c95-2650-405d-99c1-3636bd1da0a1), +] +interface ID3D10ShaderReflectionVariable +{ + HRESULT GetDesc(D3D10_SHADER_VARIABLE_DESC *desc); + ID3D10ShaderReflectionType *GetType(); +}; + +[ + local, + object, + uuid(66c66a94-dddd-4b62-a66a-f0da33c2b4d0), +] +interface ID3D10ShaderReflectionConstantBuffer +{ + HRESULT GetDesc(D3D10_SHADER_BUFFER_DESC *desc); + ID3D10ShaderReflectionVariable *GetVariableByIndex(UINT index); + ID3D10ShaderReflectionVariable *GetVariableByName(const char *name); +}; + +[ + local, + object, + uuid(d40e20b6-f8f7-42ad-ab20-4baf8f15dfaa), +] +interface ID3D10ShaderReflection : IUnknown +{ + HRESULT GetDesc(D3D10_SHADER_DESC *desc); + ID3D10ShaderReflectionConstantBuffer *GetConstantBufferByIndex(UINT index); + ID3D10ShaderReflectionConstantBuffer *GetConstantBufferByName(const char *name); + HRESULT GetResourceBindingDesc(UINT index, D3D10_SHADER_INPUT_BIND_DESC *desc); + HRESULT GetInputParameterDesc(UINT index, D3D10_SIGNATURE_PARAMETER_DESC *desc); + HRESULT GetOutputParameterDesc(UINT index, D3D10_SIGNATURE_PARAMETER_DESC *desc); +}; + + +HRESULT __stdcall D3D10CompileShader(const char *data, SIZE_T data_size, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entrypoint, + const char *profile, UINT flags, ID3D10Blob **shader, ID3D10Blob **error_messages); +HRESULT __stdcall D3D10DisassembleShader(const void *data, SIZE_T data_size, + BOOL color_code, const char *comments, ID3D10Blob **disassembly); +const char * __stdcall D3D10GetVertexShaderProfile(ID3D10Device *device); +const char * __stdcall D3D10GetGeometryShaderProfile(ID3D10Device *device); +const char * __stdcall D3D10GetPixelShaderProfile(ID3D10Device *device); + +HRESULT __stdcall D3D10ReflectShader(const void *data, SIZE_T data_size, ID3D10ShaderReflection **reflector); +HRESULT __stdcall D3D10GetInputSignatureBlob(const void *data, SIZE_T data_size, ID3D10Blob **blob); +HRESULT __stdcall D3D10GetOutputSignatureBlob(const void *data, SIZE_T data_size, ID3D10Blob **blob); +HRESULT __stdcall D3D10GetInputAndOutputSignatureBlob(const void *data, SIZE_T data_size, ID3D10Blob **blob); +HRESULT __stdcall D3D10GetShaderDebugInfo(const void *data, SIZE_T data_size, ID3D10Blob **blob); diff --git a/WineFix/lib/d2d1/include/windows/d3d11.idl b/WineFix/lib/d2d1/include/windows/d3d11.idl new file mode 100644 index 0000000..9a246fa --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11.idl @@ -0,0 +1,4028 @@ +/* + * Copyright 2010 Rico Schüller + * Copyright 2013 Austin English + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi.idl"; +import "d3dcommon.idl"; + +typedef D3D_PRIMITIVE D3D11_PRIMITIVE; +typedef D3D_PRIMITIVE_TOPOLOGY D3D11_PRIMITIVE_TOPOLOGY; +typedef D3D_SRV_DIMENSION D3D11_SRV_DIMENSION; +typedef RECT D3D11_RECT; + +interface ID3D11Device; +interface ID3D11ClassLinkage; +interface ID3D11Resource; +interface ID3D11VideoProcessorInputView; + +cpp_quote("#ifndef _D3D11_CONSTANTS") +cpp_quote("#define _D3D11_CONSTANTS") + +const UINT D3D11_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff; +const UINT D3D11_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff; +const UINT D3D11_8BIT_INDEX_STRIP_CUT_VALUE = 0xff; + +const UINT D3D11_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; + +const UINT D3D11_CLIP_OR_CULL_DISTANCE_COUNT = 8; +const UINT D3D11_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; + +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const UINT D3D11_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; +const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; +const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const UINT D3D11_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; +const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; +const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; +const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; +const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; +const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; +const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; +const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; +const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; +const UINT D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; +const UINT D3D11_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; +const UINT D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; +const UINT D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; +const UINT D3D11_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; +const UINT D3D11_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; +const UINT D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; +const INT D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; +const INT D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; +const UINT D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; + +const UINT D3D11_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256; +const UINT D3D11_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64; +const UINT D3D11_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240; +const UINT D3D11_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68; +const UINT D3D11_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224; +const UINT D3D11_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72; +const UINT D3D11_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208; +const UINT D3D11_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76; +const UINT D3D11_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192; +const UINT D3D11_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84; +const UINT D3D11_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176; +const UINT D3D11_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92; +const UINT D3D11_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160; +const UINT D3D11_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100; +const UINT D3D11_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144; +const UINT D3D11_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112; +const UINT D3D11_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128; +const UINT D3D11_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128; +const UINT D3D11_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112; +const UINT D3D11_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144; +const UINT D3D11_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96; +const UINT D3D11_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168; +const UINT D3D11_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80; +const UINT D3D11_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204; +const UINT D3D11_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64; +const UINT D3D11_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256; +const UINT D3D11_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48; +const UINT D3D11_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340; +const UINT D3D11_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32; +const UINT D3D11_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512; +const UINT D3D11_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16; +const UINT D3D11_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768; +const UINT D3D11_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1; +const UINT D3D11_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256; +const UINT D3D11_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768; +const UINT D3D11_CS_4_X_THREAD_GROUP_MAX_X = 768; +const UINT D3D11_CS_4_X_THREAD_GROUP_MAX_Y = 768; +const UINT D3D11_CS_4_X_UAV_REGISTER_COUNT = 1; +const UINT D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535; +const UINT D3D11_CS_TGSM_REGISTER_COUNT = 8192; +const UINT D3D11_CS_TGSM_REGISTER_READS_PER_INST = 1; +const UINT D3D11_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1; +const UINT D3D11_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1; +const UINT D3D11_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024; +const UINT D3D11_CS_THREAD_GROUP_MAX_X = 1024; +const UINT D3D11_CS_THREAD_GROUP_MAX_Y = 1024; +const UINT D3D11_CS_THREAD_GROUP_MAX_Z = 64; +const UINT D3D11_CS_THREAD_GROUP_MIN_X = 1; +const UINT D3D11_CS_THREAD_GROUP_MIN_Y = 1; +const UINT D3D11_CS_THREAD_GROUP_MIN_Z = 1; +const UINT D3D11_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384; + +const UINT D3D11_DEFAULT_DEPTH_BIAS = 0; +cpp_quote("#define D3D11_DEFAULT_DEPTH_BIAS_CLAMP 0.0f") +const UINT D3D11_DEFAULT_MAX_ANISOTROPY = 16; +cpp_quote("#define D3D11_DEFAULT_MIP_LOD_BIAS 0.0f") +const UINT D3D11_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; +const UINT D3D11_DEFAULT_SAMPLE_MASK = 0xffffffff; +const UINT D3D11_DEFAULT_SCISSOR_ENDX = 0; +const UINT D3D11_DEFAULT_SCISSOR_ENDY = 0; +const UINT D3D11_DEFAULT_SCISSOR_STARTX = 0; +const UINT D3D11_DEFAULT_SCISSOR_STARTY = 0; +cpp_quote("#define D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS 0.0f") +const UINT D3D11_DEFAULT_STENCIL_READ_MASK = 0xff; +const UINT D3D11_DEFAULT_STENCIL_REFERENCE = 0; +const UINT D3D11_DEFAULT_STENCIL_WRITE_MASK = 0xff; +const UINT D3D11_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; +const UINT D3D11_DEFAULT_VIEWPORT_HEIGHT = 0; +cpp_quote("#define D3D11_DEFAULT_VIEWPORT_MAX_DEPTH 0.0f") +cpp_quote("#define D3D11_DEFAULT_VIEWPORT_MIN_DEPTH 0.0f") +const UINT D3D11_DEFAULT_VIEWPORT_TOPLEFTX = 0; +const UINT D3D11_DEFAULT_VIEWPORT_TOPLEFTY = 0; +const UINT D3D11_DEFAULT_VIEWPORT_WIDTH = 0; + +cpp_quote("#define D3D11_FLOAT32_MAX (3.402823466e+38f)") + +const UINT D3D11_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; +const UINT D3D11_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; +const UINT D3D11_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; +const UINT D3D11_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; +const UINT D3D11_IA_INSTANCE_ID_BIT_COUNT = 32; +const UINT D3D11_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; +const UINT D3D11_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32; +const UINT D3D11_IA_PRIMITIVE_ID_BIT_COUNT = 32; +const UINT D3D11_IA_VERTEX_ID_BIT_COUNT = 32; +const UINT D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32; +const UINT D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128; +const UINT D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32; + +const unsigned int D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; + +const UINT D3D11_MAX_MAXANISOTROPY = 16; +const UINT D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; +const UINT D3D11_VIEWPORT_BOUNDS_MAX = 32767; +const INT D3D11_VIEWPORT_BOUNDS_MIN = -32768; +const UINT D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; +const UINT D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; + +const UINT D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 0xffffffff; +const UINT D3D11_KEEP_UNORDERED_ACCESS_VIEWS = 0xffffffff; + +const UINT D3D11_SHADER_MAJOR_VERSION = 5; +const UINT D3D11_SHADER_MAX_INSTANCES = 65535; +const UINT D3D11_SHADER_MAX_INTERFACES = 253; +const UINT D3D11_SHADER_MAX_INTERFACE_CALL_SITES = 4096; +const UINT D3D11_SHADER_MAX_TYPES = 65535; +const UINT D3D11_SHADER_MINOR_VERSION = 0; +const UINT D3D11_VS_OUTPUT_REGISTER_COUNT = 32; + +const UINT D3D11_OMAC_SIZE = 16; + +const UINT D3D11_PS_CS_UAV_REGISTER_COMPONENTS = 1; +const UINT D3D11_PS_CS_UAV_REGISTER_COUNT = 8; +const UINT D3D11_PS_CS_UAV_REGISTER_READS_PER_INST = 1; +const UINT D3D11_PS_CS_UAV_REGISTER_READ_PORTS = 1; +const UINT D3D11_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff; +const UINT D3D11_PS_FRONTFACING_FALSE_VALUE = 0; +const UINT D3D11_PS_FRONTFACING_TRUE_VALUE = 0xffffffff; +const UINT D3D11_PS_INPUT_REGISTER_COMPONENTS = 4; +const UINT D3D11_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_PS_INPUT_REGISTER_COUNT = 32; +const UINT D3D11_PS_INPUT_REGISTER_READS_PER_INST = 2; +const UINT D3D11_PS_INPUT_REGISTER_READ_PORTS = 1; +cpp_quote("#define D3D11_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.0f)") +const UINT D3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; +const UINT D3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; +const UINT D3D11_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1; +const UINT D3D11_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_PS_OUTPUT_MASK_REGISTER_COUNT = 1; +const UINT D3D11_PS_OUTPUT_REGISTER_COMPONENTS = 4; +const UINT D3D11_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_PS_OUTPUT_REGISTER_COUNT = 8; +cpp_quote("#define D3D11_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.5f)") + +const UINT D3D11_RAW_UAV_SRV_BYTE_ALIGNMENT = 16; + +const UINT D3D11_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D11_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; +const UINT D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const UINT D3D11_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; +const UINT D3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; +const UINT D3D11_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384; +const UINT D3D11_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; +const UINT D3D11_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const UINT D3D11_REQ_MAXANISOTROPY = 16; +const UINT D3D11_REQ_MIP_LEVELS = 15; +const UINT D3D11_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; +const UINT D3D11_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D11_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384; +const UINT D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128; +cpp_quote("#define D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM (0.25f)") +const UINT D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048; +const UINT D3D11_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20; +const UINT D3D11_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048; +const UINT D3D11_REQ_TEXTURE1D_U_DIMENSION = 16384; +const UINT D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048; +const UINT D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384; +const UINT D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; +const UINT D3D11_REQ_TEXTURECUBE_DIMENSION = 16384; + +const UINT D3D11_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; + +const UINT D3D11_SHIFT_INSTRUCTION_PAD_VALUE = 0; +const UINT D3D11_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; + +const UINT D3D11_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; +const UINT D3D11_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512; +const UINT D3D11_SO_BUFFER_SLOT_COUNT = 4; +const UINT D3D11_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff; +const UINT D3D11_SO_NO_RASTERIZED_STREAM = 0xffffffff; +const UINT D3D11_SO_OUTPUT_COMPONENT_COUNT = 128; +const UINT D3D11_SO_STREAM_COUNT = 4; + +const UINT D3D11_SPEC_DATE_DAY = 16; +const UINT D3D11_SPEC_DATE_MONTH = 05; +const UINT D3D11_SPEC_DATE_YEAR = 2011; + +cpp_quote("#define D3D11_SPEC_VERSION (1.07)") +cpp_quote("#define D3D11_SRGB_GAMMA (2.2f)") +cpp_quote("#define D3D11_SRGB_TO_FLOAT_DENOMINATOR_1 (12.92f)") +cpp_quote("#define D3D11_SRGB_TO_FLOAT_DENOMINATOR_2 (1.055f)") +cpp_quote("#define D3D11_SRGB_TO_FLOAT_EXPONENT (2.4f)") +cpp_quote("#define D3D11_SRGB_TO_FLOAT_OFFSET (0.055f)") +cpp_quote("#define D3D11_SRGB_TO_FLOAT_THRESHOLD (0.04045f)") +cpp_quote("#define D3D11_SRGB_TO_FLOAT_TOLERANCE_IN_ULP (0.5f)") + +const UINT D3D11_STANDARD_COMPONENT_BIT_COUNT = 32; +const UINT D3D11_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; +const UINT D3D11_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; +const UINT D3D11_STANDARD_PIXEL_COMPONENT_COUNT = 128; +const UINT D3D11_STANDARD_PIXEL_ELEMENT_COUNT = 32; +const UINT D3D11_STANDARD_VECTOR_SIZE = 4; +const UINT D3D11_STANDARD_VERTEX_ELEMENT_COUNT = 32; +const UINT D3D11_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; + +cpp_quote("#endif") + +cpp_quote("#ifndef _D3D11_1_CONSTANTS") +cpp_quote("#define _D3D11_1_CONSTANTS") +const UINT D3D11_1_UAV_SLOT_COUNT = 64; +cpp_quote("#endif") + +cpp_quote("#ifndef _D3D11_2_CONSTANTS") +cpp_quote("#define _D3D11_2_CONSTANTS") +const UINT D3D11_2_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 0x10000; +cpp_quote("#endif") + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_DEFAULT {};") +cpp_quote("extern const DECLSPEC_SELECTANY CD3D11_DEFAULT D3D11_DEFAULT;") +cpp_quote("#endif") + +typedef enum D3D11_BLEND +{ + D3D11_BLEND_ZERO = 1, + D3D11_BLEND_ONE = 2, + D3D11_BLEND_SRC_COLOR = 3, + D3D11_BLEND_INV_SRC_COLOR = 4, + D3D11_BLEND_SRC_ALPHA = 5, + D3D11_BLEND_INV_SRC_ALPHA = 6, + D3D11_BLEND_DEST_ALPHA = 7, + D3D11_BLEND_INV_DEST_ALPHA = 8, + D3D11_BLEND_DEST_COLOR = 9, + D3D11_BLEND_INV_DEST_COLOR = 10, + D3D11_BLEND_SRC_ALPHA_SAT = 11, + D3D11_BLEND_BLEND_FACTOR = 14, + D3D11_BLEND_INV_BLEND_FACTOR = 15, + D3D11_BLEND_SRC1_COLOR = 16, + D3D11_BLEND_INV_SRC1_COLOR = 17, + D3D11_BLEND_SRC1_ALPHA = 18, + D3D11_BLEND_INV_SRC1_ALPHA = 19, +} D3D11_BLEND; + +typedef enum D3D11_BLEND_OP +{ + D3D11_BLEND_OP_ADD = 1, + D3D11_BLEND_OP_SUBTRACT, + D3D11_BLEND_OP_REV_SUBTRACT, + D3D11_BLEND_OP_MIN, + D3D11_BLEND_OP_MAX +} D3D11_BLEND_OP; + +typedef enum D3D11_VIDEO_DECODER_BUFFER_TYPE +{ + D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS = 0, + D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL = 1, + D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE = 2, + D3D11_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL = 3, + D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX = 4, + D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL = 5, + D3D11_VIDEO_DECODER_BUFFER_BITSTREAM = 6, + D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR = 7, + D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN = 8, +} D3D11_VIDEO_DECODER_BUFFER_TYPE; + +typedef enum D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE +{ + D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE = 0, + D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_BACKGROUND = 1, + D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_DESTINATION = 2, + D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM = 3, +} D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE; + +typedef enum D3D11_VIDEO_PROCESSOR_OUTPUT_RATE +{ + D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL = 0, + D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_HALF = 1, + D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM = 2, +} D3D11_VIDEO_PROCESSOR_OUTPUT_RATE; + +typedef enum D3D11_VIDEO_PROCESSOR_STEREO_FORMAT +{ + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO = 0, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_HORIZONTAL = 1, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_VERTICAL = 2, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE = 3, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET = 4, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_ROW_INTERLEAVED = 5, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_COLUMN_INTERLEAVED = 6, + D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_CHECKERBOARD = 7, +} D3D11_VIDEO_PROCESSOR_STEREO_FORMAT; + +typedef enum D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE +{ + D3D11_VIDEO_PROCESSOR_STEREO_FLIP_NONE = 0, + D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME0 = 1, + D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME1 = 2, +} D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE; + +typedef enum D3D11_VIDEO_PROCESSOR_ROTATION +{ + D3D11_VIDEO_PROCESSOR_ROTATION_IDENTITY = 0, + D3D11_VIDEO_PROCESSOR_ROTATION_90 = 1, + D3D11_VIDEO_PROCESSOR_ROTATION_180 = 2, + D3D11_VIDEO_PROCESSOR_ROTATION_270 = 3, +} D3D11_VIDEO_PROCESSOR_ROTATION; + +typedef enum D3D11_VIDEO_PROCESSOR_DEVICE_CAPS +{ + D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_LINEAR_SPACE = 0x00000001, + D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_xvYCC = 0x00000002, + D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_RGB_RANGE_CONVERSION = 0x00000004, + D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_YCbCr_MATRIX_CONVERSION = 0x00000008, + D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_NOMINAL_RANGE = 0x00000010, +} D3D11_VIDEO_PROCESSOR_DEVICE_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_FEATURE_CAPS +{ + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_FILL = 0x00000001, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_CONSTRICTION = 0x00000002, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LUMA_KEY = 0x00000004, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_PALETTE = 0x00000008, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LEGACY = 0x00000010, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_STEREO = 0x00000020, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ROTATION = 0x00000040, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_STREAM = 0x00000080, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_PIXEL_ASPECT_RATIO = 0x00000100, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_MIRROR = 0x00000200, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_SHADER_USAGE = 0x00000400, + D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_METADATA_HDR10 = 0x00000800, +} D3D11_VIDEO_PROCESSOR_FEATURE_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_FILTER_CAPS +{ + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_BRIGHTNESS = 0x00000001, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_CONTRAST = 0x00000002, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_HUE = 0x00000004, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_SATURATION = 0x00000008, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_NOISE_REDUCTION = 0x00000010, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_EDGE_ENHANCEMENT = 0x00000020, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_ANAMORPHIC_SCALING = 0x00000040, + D3D11_VIDEO_PROCESSOR_FILTER_CAPS_STEREO_ADJUSTMENT = 0x00000080, +} D3D11_VIDEO_PROCESSOR_FILTER_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_FORMAT_CAPS +{ + D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_INTERLACED = 0x00000001, + D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_PROCAMP = 0x00000002, + D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_LUMA_KEY = 0x00000004, + D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_PALETTE_INTERLACED = 0x00000008, +} D3D11_VIDEO_PROCESSOR_FORMAT_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS +{ + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DENOISE = 0x00000001, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DERINGING = 0x00000002, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_EDGE_ENHANCEMENT = 0x00000004, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_COLOR_CORRECTION = 0x00000008, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_FLESH_TONE_MAPPING = 0x00000010, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_IMAGE_STABILIZATION = 0x00000020, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_SUPER_RESOLUTION = 0x00000040, + D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_ANAMORPHIC_SCALING = 0x00000080, +} D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_STEREO_CAPS +{ + D3D11_VIDEO_PROCESSOR_STEREO_CAPS_MONO_OFFSET = 0x00000001, + D3D11_VIDEO_PROCESSOR_STEREO_CAPS_ROW_INTERLEAVED = 0x00000002, + D3D11_VIDEO_PROCESSOR_STEREO_CAPS_COLUMN_INTERLEAVED = 0x00000004, + D3D11_VIDEO_PROCESSOR_STEREO_CAPS_CHECKERBOARD = 0x00000008, + D3D11_VIDEO_PROCESSOR_STEREO_CAPS_FLIP_MODE = 0x00000010, +} D3D11_VIDEO_PROCESSOR_STEREO_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS +{ + D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND = 0x01, + D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB = 0x02, + D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE = 0x04, + D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION = 0x08, + D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_INVERSE_TELECINE = 0x10, + D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_FRAME_RATE_CONVERSION = 0x20, +} D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS +{ + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32 = 0x00000001, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_22 = 0x00000002, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2224 = 0x00000004, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2332 = 0x00000008, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32322 = 0x00000010, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_55 = 0x00000020, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_64 = 0x00000040, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_87 = 0x00000080, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_222222222223 = 0x00000100, + D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_OTHER = 0x80000000, +} D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS; + +typedef enum D3D11_CONTENT_PROTECTION_CAPS +{ + D3D11_CONTENT_PROTECTION_CAPS_SOFTWARE = 0x00000001, + D3D11_CONTENT_PROTECTION_CAPS_HARDWARE = 0x00000002, + D3D11_CONTENT_PROTECTION_CAPS_PROTECTION_ALWAYS_ON = 0x00000004, + D3D11_CONTENT_PROTECTION_CAPS_PARTIAL_DECRYPTION = 0x00000008, + D3D11_CONTENT_PROTECTION_CAPS_CONTENT_KEY = 0x00000010, + D3D11_CONTENT_PROTECTION_CAPS_FRESHEN_SESSION_KEY = 0x00000020, + D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK = 0x00000040, + D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK_KEY = 0x00000080, + D3D11_CONTENT_PROTECTION_CAPS_SEQUENTIAL_CTR_IV = 0x00000100, + D3D11_CONTENT_PROTECTION_CAPS_ENCRYPT_SLICEDATA_ONLY = 0x00000200, + D3D11_CONTENT_PROTECTION_CAPS_DECRYPTION_BLT = 0x00000400, + D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_PROTECT_UNCOMPRESSED = 0x00000800, + D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_PROTECTED_MEMORY_PAGEABLE = 0x00001000, + D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_TEARDOWN = 0x00002000, + D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_DRM_COMMUNICATION = 0x00004000, +} D3D11_CONTENT_PROTECTION_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE +{ + D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_UNDEFINED = 0x00000000, + D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_16_235 = 0x00000001, + D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255 = 0x00000002, +} D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE; + +typedef enum D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE +{ + D3D11_PROCESSIDTYPE_UNKNOWN = 0x00000000, + D3D11_PROCESSIDTYPE_DWM = 0x00000001, + D3D11_PROCESSIDTYPE_HANDLE = 0x00000002, +} D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE; + +typedef enum D3D11_BUS_TYPE +{ + D3D11_BUS_TYPE_OTHER = 0x00000000, + D3D11_BUS_TYPE_PCI = 0x00000001, + D3D11_BUS_TYPE_PCIX = 0x00000002, + D3D11_BUS_TYPE_PCIEXPRESS = 0x00000003, + D3D11_BUS_TYPE_AGP = 0x00000004, + D3D11_BUS_IMPL_MODIFIER_INSIDE_OF_CHIPSET = 0x00010000, + D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_CHIP = 0x00020000, + D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_SOCKET = 0x00030000, + D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR = 0x00040000, + D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE = 0x00050000, + D3D11_BUS_IMPL_MODIFIER_NON_STANDARD = 0x80000000, +} D3D11_BUS_TYPE; + +typedef struct D3D11_BOX +{ + UINT left; + UINT top; + UINT front; + UINT right; + UINT bottom; + UINT back; +} D3D11_BOX; + +typedef struct D3D11_BUFFER_RTV +{ + union + { + UINT FirstElement; + UINT ElementOffset; + }; + union + { + UINT NumElements; + UINT ElementWidth; + }; +} D3D11_BUFFER_RTV; + +typedef struct D3D11_BUFFER_SRV +{ + union + { + UINT FirstElement; + UINT ElementOffset; + }; + union + { + UINT NumElements; + UINT ElementWidth; + }; +} D3D11_BUFFER_SRV; + +typedef struct D3D11_BUFFER_UAV +{ + UINT FirstElement; + UINT NumElements; + UINT Flags; +} D3D11_BUFFER_UAV; + +typedef struct D3D11_BUFFEREX_SRV +{ + UINT FirstElement; + UINT NumElements; + UINT Flags; +} D3D11_BUFFEREX_SRV; + +typedef struct D3D11_CLASS_INSTANCE_DESC +{ + UINT InstanceId; + UINT InstanceIndex; + UINT TypeId; + UINT ConstantBuffer; + UINT BaseConstantBufferOffset; + UINT BaseTexture; + UINT BaseSampler; + BOOL Created; +} D3D11_CLASS_INSTANCE_DESC; + +typedef enum D3D11_COMPARISON_FUNC +{ + D3D11_COMPARISON_NEVER = 1, + D3D11_COMPARISON_LESS, + D3D11_COMPARISON_EQUAL, + D3D11_COMPARISON_LESS_EQUAL, + D3D11_COMPARISON_GREATER, + D3D11_COMPARISON_NOT_EQUAL, + D3D11_COMPARISON_GREATER_EQUAL, + D3D11_COMPARISON_ALWAYS +} D3D11_COMPARISON_FUNC; + +typedef enum D3D11_COUNTER +{ + D3D11_COUNTER_DEVICE_DEPENDENT_0 = 0x40000000, +} D3D11_COUNTER; + +typedef struct D3D11_COUNTER_DESC +{ + D3D11_COUNTER Counter; + UINT MiscFlags; +} D3D11_COUNTER_DESC; + +typedef struct D3D11_COUNTER_INFO +{ + D3D11_COUNTER LastDeviceDependentCounter; + UINT NumSimultaneousCounters; + UINT8 NumDetectableParallelUnits; +} D3D11_COUNTER_INFO; + +typedef enum D3D11_COUNTER_TYPE +{ + D3D11_COUNTER_TYPE_FLOAT32, + D3D11_COUNTER_TYPE_UINT16, + D3D11_COUNTER_TYPE_UINT32, + D3D11_COUNTER_TYPE_UINT64, +} D3D11_COUNTER_TYPE; + +typedef enum D3D11_CULL_MODE +{ + D3D11_CULL_NONE = 1, + D3D11_CULL_FRONT, + D3D11_CULL_BACK +} D3D11_CULL_MODE; + +typedef enum D3D11_DEPTH_WRITE_MASK +{ + D3D11_DEPTH_WRITE_MASK_ZERO, + D3D11_DEPTH_WRITE_MASK_ALL, +} D3D11_DEPTH_WRITE_MASK; + +typedef enum D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS +{ + D3D11_STANDARD_MULTISAMPLE_PATTERN = 0xffffffff, + D3D11_CENTER_MULTISAMPLE_PATTERN = 0xfffffffe, +} D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS; + +typedef enum D3D11_DEVICE_CONTEXT_TYPE +{ + D3D11_DEVICE_CONTEXT_IMMEDIATE, + D3D11_DEVICE_CONTEXT_DEFERRED, +} D3D11_DEVICE_CONTEXT_TYPE; + +typedef enum D3D11_DSV_DIMENSION +{ + D3D11_DSV_DIMENSION_UNKNOWN, + D3D11_DSV_DIMENSION_TEXTURE1D, + D3D11_DSV_DIMENSION_TEXTURE1DARRAY, + D3D11_DSV_DIMENSION_TEXTURE2D, + D3D11_DSV_DIMENSION_TEXTURE2DARRAY, + D3D11_DSV_DIMENSION_TEXTURE2DMS, + D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY, +} D3D11_DSV_DIMENSION; + +typedef enum D3D11_FEATURE +{ + D3D11_FEATURE_THREADING, + D3D11_FEATURE_DOUBLES, + D3D11_FEATURE_FORMAT_SUPPORT, + D3D11_FEATURE_FORMAT_SUPPORT2, + D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, + D3D11_FEATURE_D3D11_OPTIONS, + D3D11_FEATURE_ARCHITECTURE_INFO, + D3D11_FEATURE_D3D9_OPTIONS, + D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT, + D3D11_FEATURE_D3D9_SHADOW_SUPPORT, + D3D11_FEATURE_D3D11_OPTIONS1, + D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT, + D3D11_FEATURE_MARKER_SUPPORT, + D3D11_FEATURE_D3D9_OPTIONS1, + D3D11_FEATURE_D3D11_OPTIONS2, + D3D11_FEATURE_D3D11_OPTIONS3, + D3D11_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT, + D3D11_FEATURE_D3D11_OPTIONS4, + D3D11_FEATURE_SHADER_CACHE, + D3D11_FEATURE_D3D11_OPTIONS5, +} D3D11_FEATURE; + +typedef struct D3D11_FEATURE_DATA_THREADING +{ + BOOL DriverConcurrentCreates; + BOOL DriverCommandLists; +} D3D11_FEATURE_DATA_THREADING; + +typedef struct D3D11_FEATURE_DATA_DOUBLES +{ + BOOL DoublePrecisionFloatShaderOps; +} D3D11_FEATURE_DATA_DOUBLES; + +typedef struct D3D11_FEATURE_DATA_FORMAT_SUPPORT +{ + DXGI_FORMAT InFormat; + UINT OutFormatSupport; +} D3D11_FEATURE_DATA_FORMAT_SUPPORT; + +typedef struct D3D11_FEATURE_DATA_FORMAT_SUPPORT2 +{ + DXGI_FORMAT InFormat; + UINT OutFormatSupport2; +} D3D11_FEATURE_DATA_FORMAT_SUPPORT2; + +typedef struct D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS +{ + BOOL ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x; +} D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS; + +typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS +{ + BOOL OutputMergerLogicOp; + BOOL UAVOnlyRenderingForcedSampleCount; + BOOL DiscardAPIsSeenByDriver; + BOOL FlagsForUpdateAndCopySeenByDriver; + BOOL ClearView; + BOOL CopyWithOverlap; + BOOL ConstantBufferPartialUpdate; + BOOL ConstantBufferOffsetting; + BOOL MapNoOverwriteOnDynamicConstantBuffer; + BOOL MapNoOverwriteOnDynamicBufferSRV; + BOOL MultisampleRTVWithForcedSampleCountOne; + BOOL SAD4ShaderInstructions; + BOOL ExtendedDoublesShaderInstructions; + BOOL ExtendedResourceSharing; +} D3D11_FEATURE_DATA_D3D11_OPTIONS; + +typedef struct D3D11_FEATURE_DATA_ARCHITECTURE_INFO +{ + BOOL TileBasedDeferredRenderer; +} D3D11_FEATURE_DATA_ARCHITECTURE_INFO; + +typedef struct D3D11_FEATURE_DATA_D3D9_OPTIONS +{ + BOOL FullNonPow2TextureSupport; +} D3D11_FEATURE_DATA_D3D9_OPTIONS; + +typedef struct D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT +{ + BOOL SupportsDepthAsTextureWithLessEqualComparisonFilter; +} D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT; + +typedef enum D3D11_SHADER_MIN_PRECISION_SUPPORT +{ + D3D11_SHADER_MIN_PRECISION_10_BIT = 0x1, + D3D11_SHADER_MIN_PRECISION_16_BIT = 0x2, +} D3D11_SHADER_MIN_PRECISION_SUPPORT; + +typedef struct D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT +{ + UINT PixelShaderMinPrecision; + UINT AllOtherShaderStagesMinPrecision; +} D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT; + +typedef enum D3D11_TILED_RESOURCES_TIER +{ + D3D11_TILED_RESOURCES_NOT_SUPPORTED = 0x0, + D3D11_TILED_RESOURCES_TIER_1 = 0x1, + D3D11_TILED_RESOURCES_TIER_2 = 0x2, + D3D11_TILED_RESOURCES_TIER_3 = 0x3, +} D3D11_TILED_RESOURCES_TIER; + +typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS1 +{ + D3D11_TILED_RESOURCES_TIER TiledResourcesTier; + BOOL MinMaxFiltering; + BOOL ClearViewAlsoSupportsDepthOnlyFormats; + BOOL MapOnDefaultBuffers; +} D3D11_FEATURE_DATA_D3D11_OPTIONS1; + +typedef struct D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT +{ + BOOL SimpleInstancingSupported; +} D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT; + +typedef struct D3D11_FEATURE_DATA_MARKER_SUPPORT +{ + BOOL Profile; +} D3D11_FEATURE_DATA_MARKER_SUPPORT; + +typedef struct D3D11_FEATURE_DATA_D3D9_OPTIONS1 +{ + BOOL FullNonPow2TextureSupported; + BOOL DepthAsTextureWithLessEqualComparisonFilterSupported; + BOOL SimpleInstancingSupported; + BOOL TextureCubeFaceRenderTargetWithNonCubeDepthStencilSupported; +} D3D11_FEATURE_DATA_D3D9_OPTIONS1; + +typedef enum D3D11_CONSERVATIVE_RASTERIZATION_TIER +{ + D3D11_CONSERVATIVE_RASTERIZATION_NOT_SUPPORTED = 0x0, + D3D11_CONSERVATIVE_RASTERIZATION_TIER_1 = 0x1, + D3D11_CONSERVATIVE_RASTERIZATION_TIER_2 = 0x2, + D3D11_CONSERVATIVE_RASTERIZATION_TIER_3 = 0x3, +} D3D11_CONSERVATIVE_RASTERIZATION_TIER; + +typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS2 +{ + BOOL PSSpecifiedStencilRefSupported; + BOOL TypedUAVLoadAdditionalFormats; + BOOL ROVsSupported; + D3D11_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier; + D3D11_TILED_RESOURCES_TIER TiledResourcesTier; + BOOL MapOnDefaultTextures; + BOOL StandardSwizzle; + BOOL UnifiedMemoryArchitecture; +} D3D11_FEATURE_DATA_D3D11_OPTIONS2; + +typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS3 +{ + BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizer; +} D3D11_FEATURE_DATA_D3D11_OPTIONS3; + +typedef struct D3D11_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT +{ + UINT MaxGPUVirtualAddressBitsPerResource; + UINT MaxGPUVirtualAddressBitsPerProcess; +} D3D11_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT; + +typedef enum D3D11_SHADER_CACHE_SUPPORT_FLAGS +{ + D3D11_SHADER_CACHE_SUPPORT_NONE = 0x0, + D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x1, + D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x2, +} D3D11_SHADER_CACHE_SUPPORT_FLAGS; + +typedef struct D3D11_FEATURE_DATA_SHADER_CACHE +{ + UINT SupportFlags; +} D3D11_FEATURE_DATA_SHADER_CACHE; + +typedef enum D3D11_SHARED_RESOURCE_TIER +{ + D3D11_SHARED_RESOURCE_TIER_0, + D3D11_SHARED_RESOURCE_TIER_1, + D3D11_SHARED_RESOURCE_TIER_2, + D3D11_SHARED_RESOURCE_TIER_3, +} D3D11_SHARED_RESOURCE_TIER; + +typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS5 +{ + D3D11_SHARED_RESOURCE_TIER SharedResourceTier; +} D3D11_FEATURE_DATA_D3D11_OPTIONS5; + +typedef enum D3D11_FILL_MODE +{ + D3D11_FILL_WIREFRAME = 2, + D3D11_FILL_SOLID +} D3D11_FILL_MODE; + +typedef enum D3D11_FILTER_TYPE +{ + D3D11_FILTER_TYPE_POINT = 0, + D3D11_FILTER_TYPE_LINEAR = 1 +} D3D11_FILTER_TYPE; + +const UINT D3D11_MIN_FILTER_SHIFT = 4; +const UINT D3D11_MAG_FILTER_SHIFT = 2; +const UINT D3D11_MIP_FILTER_SHIFT = 0; +const UINT D3D11_FILTER_TYPE_MASK = 0x00000003; +const UINT D3D11_COMPARISON_FILTERING_BIT = 0x00000080; +const UINT D3D11_ANISOTROPIC_FILTERING_BIT = 0x00000040; + +cpp_quote("#define D3D11_ENCODE_BASIC_FILTER(min, mag, mip, bComparison) \\") +cpp_quote(" ((D3D11_FILTER)(((bComparison) ? D3D11_COMPARISON_FILTERING_BIT : 0 ) | \\") +cpp_quote(" (((min)&D3D11_FILTER_TYPE_MASK) << D3D11_MIN_FILTER_SHIFT) | \\") +cpp_quote(" (((mag)&D3D11_FILTER_TYPE_MASK) << D3D11_MAG_FILTER_SHIFT) | \\") +cpp_quote(" (((mip)&D3D11_FILTER_TYPE_MASK) << D3D11_MIP_FILTER_SHIFT)))") + +cpp_quote("#define D3D11_ENCODE_ANISOTROPIC_FILTER(bComparison) \\") +cpp_quote(" ((D3D11_FILTER)(D3D11_ANISOTROPIC_FILTERING_BIT | \\" ) +cpp_quote(" D3D11_ENCODE_BASIC_FILTER(D3D11_FILTER_TYPE_LINEAR,D3D11_FILTER_TYPE_LINEAR, \\" ) +cpp_quote(" D3D11_FILTER_TYPE_LINEAR,bComparison)))" ) + +cpp_quote("#define D3D11_DECODE_MIN_FILTER(d3d11Filter) \\") +cpp_quote(" ((D3D11_FILTER_TYPE)(((d3d11Filter) >> D3D11_MIN_FILTER_SHIFT) & D3D11_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D11_DECODE_MAG_FILTER(d3d11Filter) \\") +cpp_quote(" ((D3D11_FILTER_TYPE)(((d3d11Filter) >> D3D11_MAG_FILTER_SHIFT) & D3D11_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D11_DECODE_MIP_FILTER(d3d11Filter) \\") +cpp_quote(" ((D3D11_FILTER_TYPE)(((d3d11Filter) >> D3D11_MIP_FILTER_SHIFT) & D3D11_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D11_DECODE_IS_COMPARISON_FILTER(d3d11Filter) ((d3d11Filter) & D3D11_COMPARISON_FILTERING_BIT)") + +cpp_quote("#define D3D11_DECODE_IS_ANISOTROPIC_FILTER(d3d11Filter) \\") +cpp_quote(" (((d3d11Filter) & D3D11_ANISOTROPIC_FILTERING_BIT ) \\" ) +cpp_quote(" && (D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MIN_FILTER(d3d11Filter)) \\" ) +cpp_quote(" && (D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MAG_FILTER(d3d11Filter)) \\" ) +cpp_quote(" && (D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MIP_FILTER(d3d11Filter)))") + +typedef enum D3D11_FILTER +{ + D3D11_FILTER_MIN_MAG_MIP_POINT = 0x00, + D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01, + D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04, + D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05, + D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D3D11_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D11_FILTER_ANISOTROPIC = 0x55, + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, + D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, + D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, + D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, + D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, + D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, + D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D11_FILTER_COMPARISON_ANISOTROPIC = 0xd5, + D3D11_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100, + D3D11_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101, + D3D11_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104, + D3D11_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105, + D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110, + D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111, + D3D11_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114, + D3D11_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115, + D3D11_FILTER_MINIMUM_ANISOTROPIC = 0x155, + D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180, + D3D11_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181, + D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184, + D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185, + D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190, + D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191, + D3D11_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194, + D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195, + D3D11_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5 +} D3D11_FILTER; + +typedef enum D3D11_DSV_FLAG +{ + D3D11_DSV_READ_ONLY_DEPTH = 0x1, + D3D11_DSV_READ_ONLY_STENCIL = 0x2, +} D3D11_DSV_FLAG; + +typedef enum D3D11_BUFFEREX_SRV_FLAG +{ + D3D11_BUFFEREX_SRV_FLAG_RAW = 0x1, +} D3D11_BUFFEREX_SRV_FLAG; + +typedef enum D3D11_UAV_FLAG +{ + D3D11_BUFFER_UAV_FLAG_RAW = 0x1, + D3D11_BUFFER_UAV_FLAG_APPEND = 0x2, + D3D11_BUFFER_UAV_FLAG_COUNTER = 0x4, +} D3D11_UAV_FLAG; + +typedef enum D3D11_INPUT_CLASSIFICATION +{ + D3D11_INPUT_PER_VERTEX_DATA, + D3D11_INPUT_PER_INSTANCE_DATA, +} D3D11_INPUT_CLASSIFICATION; + +const UINT D3D11_APPEND_ALIGNED_ELEMENT = 0xffffffff; + +typedef struct D3D11_INPUT_ELEMENT_DESC +{ + LPCSTR SemanticName; + UINT SemanticIndex; + DXGI_FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + D3D11_INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; +} D3D11_INPUT_ELEMENT_DESC; + +typedef enum D3D11_MAP +{ + D3D11_MAP_READ = 1, + D3D11_MAP_WRITE, + D3D11_MAP_READ_WRITE, + D3D11_MAP_WRITE_DISCARD, + D3D11_MAP_WRITE_NO_OVERWRITE +} D3D11_MAP; + +typedef enum D3D11_MAP_FLAG +{ + D3D11_MAP_FLAG_DO_NOT_WAIT = 0x00100000 +} D3D11_MAP_FLAG; + +typedef enum D3D11_RAISE_FLAG +{ + D3D11_RAISE_FLAG_DRIVER_INTERNAL_ERROR = 0x1, +} D3D11_RAISE_FLAG; + +typedef struct D3D11_QUERY_DATA_SO_STATISTICS +{ + UINT64 NumPrimitivesWritten; + UINT64 PrimitivesStorageNeeded; +} D3D11_QUERY_DATA_SO_STATISTICS; + +typedef struct D3D11_MAPPED_SUBRESOURCE +{ + void *pData; + UINT RowPitch; + UINT DepthPitch; +} D3D11_MAPPED_SUBRESOURCE; + +typedef enum D3D11_QUERY +{ + D3D11_QUERY_EVENT, + D3D11_QUERY_OCCLUSION, + D3D11_QUERY_TIMESTAMP, + D3D11_QUERY_TIMESTAMP_DISJOINT, + D3D11_QUERY_PIPELINE_STATISTICS, + D3D11_QUERY_OCCLUSION_PREDICATE, + D3D11_QUERY_SO_STATISTICS, + D3D11_QUERY_SO_OVERFLOW_PREDICATE, + D3D11_QUERY_SO_STATISTICS_STREAM0, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0, + D3D11_QUERY_SO_STATISTICS_STREAM1, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1, + D3D11_QUERY_SO_STATISTICS_STREAM2, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2, + D3D11_QUERY_SO_STATISTICS_STREAM3, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3, +} D3D11_QUERY; + +typedef enum D3D11_QUERY_MISC_FLAG +{ + D3D11_QUERY_MISC_PREDICATEHINT = 0x1, +} D3D11_QUERY_MISC_FLAG; + +typedef enum D3D11_ASYNC_GETDATA_FLAG +{ + D3D11_ASYNC_GETDATA_DONOTFLUSH = 0x0001, +} D3D11_ASYNC_GETDATA_FLAG; + +typedef enum D3D11_RESOURCE_MISC_FLAG +{ + D3D11_RESOURCE_MISC_GENERATE_MIPS = 0x00000001L, + D3D11_RESOURCE_MISC_SHARED = 0x00000002L, + D3D11_RESOURCE_MISC_TEXTURECUBE = 0x00000004L, + D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS = 0x00000010L, + D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS = 0x00000020L, + D3D11_RESOURCE_MISC_BUFFER_STRUCTURED = 0x00000040L, + D3D11_RESOURCE_MISC_RESOURCE_CLAMP = 0x00000080L, + D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX = 0x00000100L, + D3D11_RESOURCE_MISC_GDI_COMPATIBLE = 0x00000200L, + D3D11_RESOURCE_MISC_SHARED_NTHANDLE = 0x00000800L, + D3D11_RESOURCE_MISC_RESTRICTED_CONTENT = 0x00001000L, + D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE = 0x00002000L, + D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER = 0x00004000L, + D3D11_RESOURCE_MISC_GUARDED = 0x00008000L, + D3D11_RESOURCE_MISC_TILE_POOL = 0x00020000L, + D3D11_RESOURCE_MISC_TILED = 0x00040000L, + D3D11_RESOURCE_MISC_HW_PROTECTED = 0x00080000L, + D3D11_RESOURCE_MISC_SHARED_DISPLAYABLE = 0x00100000L, + D3D11_RESOURCE_MISC_SHARED_EXCLUSIVE_WRITER = 0x00200000L +} D3D11_RESOURCE_MISC_FLAG; + +typedef struct D3D11_QUERY_DESC +{ + D3D11_QUERY Query; + UINT MiscFlags; +} D3D11_QUERY_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_QUERY_DESC : public D3D11_QUERY_DESC {") +cpp_quote(" CD3D11_QUERY_DESC() {}") +cpp_quote(" ~CD3D11_QUERY_DESC() {}") +cpp_quote(" explicit CD3D11_QUERY_DESC(const D3D11_QUERY_DESC &other) : D3D11_QUERY_DESC(other) {}") +cpp_quote(" explicit CD3D11_QUERY_DESC(D3D11_QUERY query, UINT misc_flags = 0) {") +cpp_quote(" Query = query;") +cpp_quote(" MiscFlags = misc_flags;") +cpp_quote(" }") +cpp_quote(" operator const D3D11_QUERY_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_RASTERIZER_DESC +{ + D3D11_FILL_MODE FillMode; + D3D11_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; +} D3D11_RASTERIZER_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_RASTERIZER_DESC : public D3D11_RASTERIZER_DESC {") +cpp_quote(" CD3D11_RASTERIZER_DESC() {}") +cpp_quote(" explicit CD3D11_RASTERIZER_DESC(const D3D11_RASTERIZER_DESC &o) : D3D11_RASTERIZER_DESC(o) {}") +cpp_quote(" explicit CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT) {") +cpp_quote(" FillMode = D3D11_FILL_SOLID;") +cpp_quote(" CullMode = D3D11_CULL_BACK;") +cpp_quote(" FrontCounterClockwise = FALSE;") +cpp_quote(" DepthBias = D3D11_DEFAULT_DEPTH_BIAS;") +cpp_quote(" DepthBiasClamp = D3D11_DEFAULT_DEPTH_BIAS_CLAMP;") +cpp_quote(" SlopeScaledDepthBias = D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;") +cpp_quote(" DepthClipEnable = TRUE;") +cpp_quote(" ScissorEnable = FALSE;") +cpp_quote(" MultisampleEnable = FALSE;") +cpp_quote(" AntialiasedLineEnable = FALSE;") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_RASTERIZER_DESC(D3D11_FILL_MODE fillMode, D3D11_CULL_MODE cullMode," ) +cpp_quote(" BOOL frontCounterClockwise, INT depthBias, FLOAT depthBiasClamp, FLOAT slopeScaledDepthBias,") +cpp_quote(" BOOL depthClipEnable, BOOL scissorEnable, BOOL multisampleEnable, BOOL antialiasedLineEnable) {") +cpp_quote(" FillMode = fillMode;") +cpp_quote(" CullMode = cullMode;") +cpp_quote(" FrontCounterClockwise = frontCounterClockwise;") +cpp_quote(" DepthBias = depthBias;") +cpp_quote(" DepthBiasClamp = depthBiasClamp;") +cpp_quote(" SlopeScaledDepthBias = slopeScaledDepthBias;") +cpp_quote(" DepthClipEnable = depthClipEnable;") +cpp_quote(" ScissorEnable = scissorEnable;") +cpp_quote(" MultisampleEnable = multisampleEnable;") +cpp_quote(" AntialiasedLineEnable = antialiasedLineEnable;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_RASTERIZER_DESC() {}") +cpp_quote(" operator const D3D11_RASTERIZER_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef enum D3D11_RESOURCE_DIMENSION +{ + D3D11_RESOURCE_DIMENSION_UNKNOWN, + D3D11_RESOURCE_DIMENSION_BUFFER, + D3D11_RESOURCE_DIMENSION_TEXTURE1D, + D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3D11_RESOURCE_DIMENSION_TEXTURE3D, +} D3D11_RESOURCE_DIMENSION; + +typedef enum D3D11_RTV_DIMENSION +{ + D3D11_RTV_DIMENSION_UNKNOWN, + D3D11_RTV_DIMENSION_BUFFER, + D3D11_RTV_DIMENSION_TEXTURE1D, + D3D11_RTV_DIMENSION_TEXTURE1DARRAY, + D3D11_RTV_DIMENSION_TEXTURE2D, + D3D11_RTV_DIMENSION_TEXTURE2DARRAY, + D3D11_RTV_DIMENSION_TEXTURE2DMS, + D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY, + D3D11_RTV_DIMENSION_TEXTURE3D, +} D3D11_RTV_DIMENSION; + +typedef struct D3D11_SO_DECLARATION_ENTRY +{ + UINT Stream; + LPCSTR SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; +} D3D11_SO_DECLARATION_ENTRY; + +typedef enum D3D11_STENCIL_OP +{ + D3D11_STENCIL_OP_KEEP = 1, + D3D11_STENCIL_OP_ZERO, + D3D11_STENCIL_OP_REPLACE, + D3D11_STENCIL_OP_INCR_SAT, + D3D11_STENCIL_OP_DECR_SAT, + D3D11_STENCIL_OP_INVERT, + D3D11_STENCIL_OP_INCR, + D3D11_STENCIL_OP_DECR +} D3D11_STENCIL_OP; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("}") +cpp_quote("inline UINT D3D11CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT MipLevels) {") +cpp_quote(" return MipSlice + ArraySlice * MipLevels;") +cpp_quote("}") +cpp_quote("extern \"C\"{") +cpp_quote("#endif") + +typedef struct D3D11_SUBRESOURCE_DATA +{ + const void *pSysMem; + UINT SysMemPitch; + UINT SysMemSlicePitch; +} D3D11_SUBRESOURCE_DATA; + +typedef struct D3D11_TEX1D_ARRAY_DSV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_DSV; + +typedef struct D3D11_TEX1D_ARRAY_RTV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_RTV; + +typedef struct D3D11_TEX1D_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_SRV; + +typedef struct D3D11_TEX1D_ARRAY_UAV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_UAV; + +typedef struct D3D11_TEX1D_DSV +{ + UINT MipSlice; +} D3D11_TEX1D_DSV; + +typedef struct D3D11_TEX1D_RTV +{ + UINT MipSlice; +} D3D11_TEX1D_RTV; + +typedef struct D3D11_TEX1D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + } D3D11_TEX1D_SRV; + +typedef struct D3D11_TEX1D_UAV +{ + UINT MipSlice; +} D3D11_TEX1D_UAV; + +typedef struct D3D11_TEX2D_ARRAY_DSV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_DSV; + +typedef struct D3D11_TEX2D_ARRAY_RTV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_RTV; + +typedef struct D3D11_TEX2D_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_SRV; + +typedef struct D3D11_TEX2D_ARRAY_UAV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_UAV; + +typedef struct D3D11_TEX2D_DSV +{ + UINT MipSlice; +} D3D11_TEX2D_DSV; + +typedef struct D3D11_TEX2D_RTV +{ + UINT MipSlice; +} D3D11_TEX2D_RTV; + +typedef struct D3D11_TEX2D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; +} D3D11_TEX2D_SRV; + +typedef struct D3D11_TEX2D_UAV +{ + UINT MipSlice; +} D3D11_TEX2D_UAV; + +typedef struct D3D11_TEX2DMS_ARRAY_DSV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2DMS_ARRAY_DSV; + +typedef struct D3D11_TEX2DMS_ARRAY_RTV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2DMS_ARRAY_RTV; + +typedef struct D3D11_TEX2DMS_ARRAY_SRV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2DMS_ARRAY_SRV; + +typedef struct D3D11_TEX2DMS_DSV +{ + UINT UnusedField_NothingToDefine; +} D3D11_TEX2DMS_DSV; + +typedef struct D3D11_TEX2DMS_RTV +{ + UINT UnusedField_NothingToDefine; +} D3D11_TEX2DMS_RTV; + +typedef struct D3D11_TEX2DMS_SRV +{ + UINT UnusedField_NothingToDefine; +} D3D11_TEX2DMS_SRV; + +typedef struct D3D11_TEX3D_RTV +{ + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D11_TEX3D_RTV; + +typedef struct D3D11_TEX3D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; +} D3D11_TEX3D_SRV; + +typedef struct D3D11_TEX3D_UAV +{ + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D11_TEX3D_UAV; + +typedef struct D3D11_TEXCUBE_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT First2DArrayFace; + UINT NumCubes; +} D3D11_TEXCUBE_ARRAY_SRV; + +typedef struct D3D11_TEXCUBE_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; +} D3D11_TEXCUBE_SRV; + +typedef enum D3D11_TEXTURE_ADDRESS_MODE +{ + D3D11_TEXTURE_ADDRESS_WRAP = 1, + D3D11_TEXTURE_ADDRESS_MIRROR, + D3D11_TEXTURE_ADDRESS_CLAMP, + D3D11_TEXTURE_ADDRESS_BORDER, + D3D11_TEXTURE_ADDRESS_MIRROR_ONCE +} D3D11_TEXTURE_ADDRESS_MODE; + +typedef enum D3D11_UAV_DIMENSION +{ + D3D11_UAV_DIMENSION_UNKNOWN, + D3D11_UAV_DIMENSION_BUFFER, + D3D11_UAV_DIMENSION_TEXTURE1D, + D3D11_UAV_DIMENSION_TEXTURE1DARRAY, + D3D11_UAV_DIMENSION_TEXTURE2D, + D3D11_UAV_DIMENSION_TEXTURE2DARRAY, + D3D11_UAV_DIMENSION_TEXTURE3D = 8, +} D3D11_UAV_DIMENSION; + +typedef struct D3D11_UNORDERED_ACCESS_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_UAV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_UAV Buffer; + D3D11_TEX1D_UAV Texture1D; + D3D11_TEX1D_ARRAY_UAV Texture1DArray; + D3D11_TEX2D_UAV Texture2D; + D3D11_TEX2D_ARRAY_UAV Texture2DArray; + D3D11_TEX3D_UAV Texture3D; + }; +} D3D11_UNORDERED_ACCESS_VIEW_DESC; + +typedef enum D3D11_USAGE +{ + D3D11_USAGE_DEFAULT, + D3D11_USAGE_IMMUTABLE, + D3D11_USAGE_DYNAMIC, + D3D11_USAGE_STAGING, +} D3D11_USAGE; + +typedef enum D3D11_BIND_FLAG +{ + D3D11_BIND_VERTEX_BUFFER = 0x0001, + D3D11_BIND_INDEX_BUFFER = 0x0002, + D3D11_BIND_CONSTANT_BUFFER = 0x0004, + D3D11_BIND_SHADER_RESOURCE = 0x0008, + D3D11_BIND_STREAM_OUTPUT = 0x0010, + D3D11_BIND_RENDER_TARGET = 0x0020, + D3D11_BIND_DEPTH_STENCIL = 0x0040, + D3D11_BIND_UNORDERED_ACCESS = 0x0080, + D3D11_BIND_DECODER = 0x0200, + D3D11_BIND_VIDEO_ENCODER = 0x0400 +} D3D11_BIND_FLAG; + +typedef enum D3D11_CPU_ACCESS_FLAG +{ + D3D11_CPU_ACCESS_WRITE = 0x00010000, + D3D11_CPU_ACCESS_READ = 0x00020000 +} D3D11_CPU_ACCESS_FLAG; + +typedef struct D3D11_VIEWPORT +{ + FLOAT TopLeftX; + FLOAT TopLeftY; + FLOAT Width; + FLOAT Height; + FLOAT MinDepth; + FLOAT MaxDepth; +} D3D11_VIEWPORT; + +typedef enum D3D11_COLOR_WRITE_ENABLE +{ + D3D11_COLOR_WRITE_ENABLE_RED = 1, + D3D11_COLOR_WRITE_ENABLE_GREEN = 2, + D3D11_COLOR_WRITE_ENABLE_BLUE = 4, + D3D11_COLOR_WRITE_ENABLE_ALPHA = 8, + D3D11_COLOR_WRITE_ENABLE_ALL = + (D3D11_COLOR_WRITE_ENABLE_RED|D3D11_COLOR_WRITE_ENABLE_GREEN|D3D11_COLOR_WRITE_ENABLE_BLUE|D3D11_COLOR_WRITE_ENABLE_ALPHA) +} D3D11_COLOR_WRITE_ENABLE; + +typedef enum D3D11_FORMAT_SUPPORT +{ + D3D11_FORMAT_SUPPORT_BUFFER = 0x00000001, + D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x00000002, + D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x00000004, + D3D11_FORMAT_SUPPORT_SO_BUFFER = 0x00000008, + D3D11_FORMAT_SUPPORT_TEXTURE1D = 0x00000010, + D3D11_FORMAT_SUPPORT_TEXTURE2D = 0x00000020, + D3D11_FORMAT_SUPPORT_TEXTURE3D = 0x00000040, + D3D11_FORMAT_SUPPORT_TEXTURECUBE = 0x00000080, + D3D11_FORMAT_SUPPORT_SHADER_LOAD = 0x00000100, + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE = 0x00000200, + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x00000400, + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x00000800, + D3D11_FORMAT_SUPPORT_MIP = 0x00001000, + D3D11_FORMAT_SUPPORT_MIP_AUTOGEN = 0x00002000, + D3D11_FORMAT_SUPPORT_RENDER_TARGET = 0x00004000, + D3D11_FORMAT_SUPPORT_BLENDABLE = 0x00008000, + D3D11_FORMAT_SUPPORT_DEPTH_STENCIL = 0x00010000, + D3D11_FORMAT_SUPPORT_CPU_LOCKABLE = 0x00020000, + D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x00040000, + D3D11_FORMAT_SUPPORT_DISPLAY = 0x00080000, + D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT = 0x00100000, + D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET = 0x00200000, + D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD = 0x00400000, + D3D11_FORMAT_SUPPORT_SHADER_GATHER = 0x00800000, + D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST = 0x01000000, + D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW = 0x02000000, + D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON = 0x04000000, + D3D11_FORMAT_SUPPORT_DECODER_OUTPUT = 0x08000000, + D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT = 0x10000000, + D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_INPUT = 0x20000000, + D3D11_FORMAT_SUPPORT_VIDEO_ENCODER = 0x40000000, +} D3D11_FORMAT_SUPPORT; + +typedef enum D3D11_FORMAT_SUPPORT2 +{ + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x00000001, + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x00000002, + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x00000004, + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x00000008, + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x00000010, + D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x00000020, + D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x00000040, + D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x00000080, + D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x00000100, + D3D11_FORMAT_SUPPORT2_TILED = 0x00000200, + D3D11_FORMAT_SUPPORT2_SHAREABLE = 0x00000400, + D3D11_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x00004000, +} D3D11_FORMAT_SUPPORT2; + +typedef enum D3D11_CLEAR_FLAG +{ + D3D11_CLEAR_DEPTH = 0x0001L, + D3D11_CLEAR_STENCIL = 0x0002L +} D3D11_CLEAR_FLAG; + +typedef struct D3D11_RENDER_TARGET_BLEND_DESC +{ + BOOL BlendEnable; + D3D11_BLEND SrcBlend; + D3D11_BLEND DestBlend; + D3D11_BLEND_OP BlendOp; + D3D11_BLEND SrcBlendAlpha; + D3D11_BLEND DestBlendAlpha; + D3D11_BLEND_OP BlendOpAlpha; + UINT8 RenderTargetWriteMask; +} D3D11_RENDER_TARGET_BLEND_DESC; + +typedef struct D3D11_BLEND_DESC +{ + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + D3D11_RENDER_TARGET_BLEND_DESC RenderTarget[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT]; +} D3D11_BLEND_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_BLEND_DESC : public D3D11_BLEND_DESC {") +cpp_quote(" CD3D11_BLEND_DESC() {}") +cpp_quote(" explicit CD3D11_BLEND_DESC(const D3D11_BLEND_DESC &o) : D3D11_BLEND_DESC(o) {}") +cpp_quote(" explicit CD3D11_BLEND_DESC(CD3D11_DEFAULT) {") +cpp_quote(" AlphaToCoverageEnable = FALSE;") +cpp_quote(" IndependentBlendEnable = FALSE;") +cpp_quote(" for(D3D11_RENDER_TARGET_BLEND_DESC *target = RenderTarget;") +cpp_quote(" target < RenderTarget + D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT;") +cpp_quote(" target++) {") +cpp_quote(" target->BlendEnable = FALSE;") +cpp_quote(" target->SrcBlend = target->SrcBlendAlpha = D3D11_BLEND_ONE;") +cpp_quote(" target->DestBlend = target->DestBlendAlpha = D3D11_BLEND_ZERO;") +cpp_quote(" target->BlendOp = target->BlendOpAlpha = D3D11_BLEND_OP_ADD;") +cpp_quote(" target->RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;") +cpp_quote(" }") +cpp_quote(" }") +cpp_quote(" ~CD3D11_BLEND_DESC() {}") +cpp_quote(" operator const D3D11_BLEND_DESC&() const { return *this; }") +cpp_quote("};" ) +cpp_quote("#endif" ) + +typedef struct D3D11_BUFFER_DESC +{ + UINT ByteWidth; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + UINT StructureByteStride; +} D3D11_BUFFER_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_BUFFER_DESC : public D3D11_BUFFER_DESC {") +cpp_quote(" CD3D11_BUFFER_DESC() {}" ) +cpp_quote(" explicit CD3D11_BUFFER_DESC(const D3D11_BUFFER_DESC &o) : D3D11_BUFFER_DESC(o) {}") +cpp_quote(" explicit CD3D11_BUFFER_DESC(UINT byteWidth,UINT bindFlags,") +cpp_quote(" D3D11_USAGE usage = D3D11_USAGE_DEFAULT, UINT cpuaccessFlags = 0,") +cpp_quote(" UINT miscFlags = 0, UINT structureByteStride = 0 ) {") +cpp_quote(" ByteWidth = byteWidth;") +cpp_quote(" Usage = usage;") +cpp_quote(" BindFlags = bindFlags;") +cpp_quote(" CPUAccessFlags = cpuaccessFlags;") +cpp_quote(" MiscFlags = miscFlags;" ) +cpp_quote(" StructureByteStride = structureByteStride;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_BUFFER_DESC() {}") +cpp_quote(" operator const D3D11_BUFFER_DESC&() const { return *this; }") +cpp_quote("};" ) +cpp_quote("#endif" ) + +typedef struct D3D11_DEPTH_STENCIL_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_DSV_DIMENSION ViewDimension; + UINT Flags; + + union + { + D3D11_TEX1D_DSV Texture1D; + D3D11_TEX1D_ARRAY_DSV Texture1DArray; + D3D11_TEX2D_DSV Texture2D; + D3D11_TEX2D_ARRAY_DSV Texture2DArray; + D3D11_TEX2DMS_DSV Texture2DMS; + D3D11_TEX2DMS_ARRAY_DSV Texture2DMSArray; + }; +} D3D11_DEPTH_STENCIL_VIEW_DESC; + +typedef struct D3D11_DEPTH_STENCILOP_DESC +{ + D3D11_STENCIL_OP StencilFailOp; + D3D11_STENCIL_OP StencilDepthFailOp; + D3D11_STENCIL_OP StencilPassOp; + D3D11_COMPARISON_FUNC StencilFunc; +} D3D11_DEPTH_STENCILOP_DESC; + +typedef struct D3D11_DEPTH_STENCIL_DESC +{ + BOOL DepthEnable; + D3D11_DEPTH_WRITE_MASK DepthWriteMask; + D3D11_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D11_DEPTH_STENCILOP_DESC FrontFace; + D3D11_DEPTH_STENCILOP_DESC BackFace; +} D3D11_DEPTH_STENCIL_DESC; + +cpp_quote("#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )") +cpp_quote("struct CD3D11_DEPTH_STENCIL_DESC : public D3D11_DEPTH_STENCIL_DESC {") +cpp_quote(" CD3D11_DEPTH_STENCIL_DESC() {}") +cpp_quote(" explicit CD3D11_DEPTH_STENCIL_DESC(const D3D11_DEPTH_STENCIL_DESC &other) : D3D11_DEPTH_STENCIL_DESC(other) {}") +cpp_quote(" explicit CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT) {") +cpp_quote(" const D3D11_DEPTH_STENCILOP_DESC default_op =") +cpp_quote(" {D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_COMPARISON_ALWAYS};") +cpp_quote(" DepthEnable = TRUE;") +cpp_quote(" DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;") +cpp_quote(" DepthFunc = D3D11_COMPARISON_LESS;") +cpp_quote(" StencilEnable = FALSE;") +cpp_quote(" StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;") +cpp_quote(" StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;") +cpp_quote(" FrontFace = default_op;") +cpp_quote(" BackFace = default_op;") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_DEPTH_STENCIL_DESC(") +cpp_quote(" BOOL depth_enable,") +cpp_quote(" D3D11_DEPTH_WRITE_MASK depth_write_mask,") +cpp_quote(" D3D11_COMPARISON_FUNC depth_func,") +cpp_quote(" BOOL stencil_enable,") +cpp_quote(" UINT8 stencil_read_mask,") +cpp_quote(" UINT8 stencil_write_mask,") +cpp_quote(" D3D11_STENCIL_OP front_stencil_fail_op,") +cpp_quote(" D3D11_STENCIL_OP front_stencil_depth_fail_op,") +cpp_quote(" D3D11_STENCIL_OP front_stencil_pass_op,") +cpp_quote(" D3D11_COMPARISON_FUNC front_stencil_func,") +cpp_quote(" D3D11_STENCIL_OP back_stencil_fail_op,") +cpp_quote(" D3D11_STENCIL_OP back_stencil_depth_fail_op,") +cpp_quote(" D3D11_STENCIL_OP back_stencil_pass_op,") +cpp_quote(" D3D11_COMPARISON_FUNC back_stencil_func) {") +cpp_quote(" DepthEnable = depth_enable;") +cpp_quote(" DepthWriteMask = depth_write_mask;") +cpp_quote(" DepthFunc = depth_func;") +cpp_quote(" StencilEnable = stencil_enable;") +cpp_quote(" StencilReadMask = stencil_read_mask;") +cpp_quote(" StencilWriteMask = stencil_write_mask;") +cpp_quote(" FrontFace.StencilFailOp = front_stencil_fail_op;") +cpp_quote(" FrontFace.StencilDepthFailOp = front_stencil_depth_fail_op;") +cpp_quote(" FrontFace.StencilPassOp = front_stencil_pass_op;") +cpp_quote(" FrontFace.StencilFunc = front_stencil_func;") +cpp_quote(" BackFace.StencilFailOp = back_stencil_fail_op;") +cpp_quote(" BackFace.StencilDepthFailOp = back_stencil_depth_fail_op;") +cpp_quote(" BackFace.StencilPassOp = back_stencil_pass_op;") +cpp_quote(" BackFace.StencilFunc = back_stencil_func;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_DEPTH_STENCIL_DESC() {}") +cpp_quote(" operator const D3D11_DEPTH_STENCIL_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_RENDER_TARGET_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_RTV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_RTV Buffer; + D3D11_TEX1D_RTV Texture1D; + D3D11_TEX1D_ARRAY_RTV Texture1DArray; + D3D11_TEX2D_RTV Texture2D; + D3D11_TEX2D_ARRAY_RTV Texture2DArray; + D3D11_TEX2DMS_RTV Texture2DMS; + D3D11_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D11_TEX3D_RTV Texture3D; + }; +} D3D11_RENDER_TARGET_VIEW_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_RENDER_TARGET_VIEW_DESC : public D3D11_RENDER_TARGET_VIEW_DESC {") +cpp_quote(" CD3D11_RENDER_TARGET_VIEW_DESC() {}") +cpp_quote(" explicit CD3D11_RENDER_TARGET_VIEW_DESC(D3D11_RTV_DIMENSION dim, DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN,") +cpp_quote(" UINT mip_slice = 0, UINT first_slice = 0, UINT array_size = -1) {") +cpp_quote(" Format = format;") +cpp_quote(" ViewDimension = dim;") +cpp_quote(" switch(dim) {") +cpp_quote(" case D3D11_RTV_DIMENSION_BUFFER:") +cpp_quote(" Buffer.FirstElement = mip_slice;") +cpp_quote(" Buffer.NumElements = first_slice;") +cpp_quote(" break;") +cpp_quote(" case D3D11_RTV_DIMENSION_TEXTURE1D:") +cpp_quote(" Texture1D.MipSlice = mip_slice;") +cpp_quote(" break;") +cpp_quote(" case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:") +cpp_quote(" Texture1DArray.MipSlice = mip_slice;") +cpp_quote(" Texture1DArray.FirstArraySlice = first_slice;") +cpp_quote(" Texture1DArray.ArraySize = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_RTV_DIMENSION_TEXTURE2D:") +cpp_quote(" Texture2D.MipSlice = mip_slice;") +cpp_quote(" break;") +cpp_quote(" case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:") +cpp_quote(" Texture2DArray.MipSlice = mip_slice;") +cpp_quote(" Texture2DArray.FirstArraySlice = first_slice;") +cpp_quote(" Texture2DArray.ArraySize = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:") +cpp_quote(" Texture2DMSArray.FirstArraySlice = first_slice;") +cpp_quote(" Texture2DMSArray.ArraySize = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_RTV_DIMENSION_TEXTURE3D:") +cpp_quote(" Texture3D.MipSlice = mip_slice;") +cpp_quote(" Texture3D.FirstWSlice = first_slice;") +cpp_quote(" Texture3D.WSize = array_size;") +cpp_quote(" break;") +cpp_quote(" default:") +cpp_quote(" break;") +cpp_quote(" }") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_RENDER_TARGET_VIEW_DESC(ID3D11Buffer*, DXGI_FORMAT format, UINT first_elem,") +cpp_quote(" UINT elem_cnt) {") +cpp_quote(" Format = format;") +cpp_quote(" ViewDimension = D3D11_RTV_DIMENSION_BUFFER;") +cpp_quote(" Buffer.FirstElement = first_elem;") +cpp_quote(" Buffer.NumElements = elem_cnt;") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_RENDER_TARGET_VIEW_DESC(ID3D11Texture1D *texture, D3D11_RTV_DIMENSION dim,") +cpp_quote(" DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN, UINT mip_slice = 0, UINT first_slice = 0,") +cpp_quote(" UINT array_size = -1);") /* FIXME: implement */ +cpp_quote(" explicit CD3D11_RENDER_TARGET_VIEW_DESC(ID3D11Texture2D *texture, D3D11_RTV_DIMENSION dim,") +cpp_quote(" DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN, UINT mip_slice = 0, UINT first_slice = 0,") +cpp_quote(" UINT array_size = -1);") /* FIXME: implement */ +cpp_quote(" explicit CD3D11_RENDER_TARGET_VIEW_DESC(ID3D11Texture3D *texture, DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN,") +cpp_quote(" UINT mip_slice = 0, UINT first_w_slice = 0, UINT w_slice = -1 );") /* FIXME: implement */ +cpp_quote(" ~CD3D11_RENDER_TARGET_VIEW_DESC() {}") +cpp_quote(" explicit CD3D11_RENDER_TARGET_VIEW_DESC(const D3D11_RENDER_TARGET_VIEW_DESC &other)") +cpp_quote(" : D3D11_RENDER_TARGET_VIEW_DESC(other) {}") +cpp_quote(" operator const D3D11_RENDER_TARGET_VIEW_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + + +typedef struct D3D11_SAMPLER_DESC +{ + D3D11_FILTER Filter; + D3D11_TEXTURE_ADDRESS_MODE AddressU; + D3D11_TEXTURE_ADDRESS_MODE AddressV; + D3D11_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D11_COMPARISON_FUNC ComparisonFunc; + FLOAT BorderColor[4]; + FLOAT MinLOD; + FLOAT MaxLOD; +} D3D11_SAMPLER_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_SAMPLER_DESC : public D3D11_SAMPLER_DESC {") +cpp_quote(" CD3D11_SAMPLER_DESC() {}") +cpp_quote(" explicit CD3D11_SAMPLER_DESC(const D3D11_SAMPLER_DESC &o) : D3D11_SAMPLER_DESC(o) {}") +cpp_quote(" explicit CD3D11_SAMPLER_DESC(CD3D11_DEFAULT) {" ) +cpp_quote(" Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;") +cpp_quote(" AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;") +cpp_quote(" AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;") +cpp_quote(" AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;") +cpp_quote(" MipLODBias = 0;") +cpp_quote(" MaxAnisotropy = 1;") +cpp_quote(" ComparisonFunc = D3D11_COMPARISON_NEVER;") +cpp_quote(" BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 1.0f;") +cpp_quote(" MinLOD = -3.402823466e+38f;") +cpp_quote(" MaxLOD = 3.402823466e+38f;") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_SAMPLER_DESC(D3D11_FILTER filter, D3D11_TEXTURE_ADDRESS_MODE addressU,") +cpp_quote(" D3D11_TEXTURE_ADDRESS_MODE addressV, D3D11_TEXTURE_ADDRESS_MODE addressW,") +cpp_quote(" FLOAT mipLODBias, UINT maxAnisotropy, D3D11_COMPARISON_FUNC comparisonFunc,") +cpp_quote(" const FLOAT *borderColor, FLOAT minLOD, FLOAT maxLOD) {" ) +cpp_quote(" Filter = filter;") +cpp_quote(" AddressU = addressU;") +cpp_quote(" AddressV = addressV;") +cpp_quote(" AddressW = addressW;") +cpp_quote(" MipLODBias = mipLODBias;") +cpp_quote(" MaxAnisotropy = maxAnisotropy;") +cpp_quote(" ComparisonFunc = comparisonFunc;") +cpp_quote(" if(borderColor) {") +cpp_quote(" BorderColor[0] = borderColor[0];") +cpp_quote(" BorderColor[1] = borderColor[1];") +cpp_quote(" BorderColor[2] = borderColor[2];") +cpp_quote(" BorderColor[3] = borderColor[3];") +cpp_quote(" }else {") +cpp_quote(" BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 1.0f;") +cpp_quote(" }") +cpp_quote(" MinLOD = minLOD;") +cpp_quote(" MaxLOD = maxLOD;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_SAMPLER_DESC() {}") +cpp_quote(" operator const D3D11_SAMPLER_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_SHADER_RESOURCE_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_SRV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_SRV Buffer; + D3D11_TEX1D_SRV Texture1D; + D3D11_TEX1D_ARRAY_SRV Texture1DArray; + D3D11_TEX2D_SRV Texture2D; + D3D11_TEX2D_ARRAY_SRV Texture2DArray; + D3D11_TEX2DMS_SRV Texture2DMS; + D3D11_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D11_TEX3D_SRV Texture3D; + D3D11_TEXCUBE_SRV TextureCube; + D3D11_TEXCUBE_ARRAY_SRV TextureCubeArray; + D3D11_BUFFEREX_SRV BufferEx; + }; +} D3D11_SHADER_RESOURCE_VIEW_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined( __cplusplus )") +cpp_quote("struct CD3D11_SHADER_RESOURCE_VIEW_DESC : public D3D11_SHADER_RESOURCE_VIEW_DESC {") +cpp_quote(" CD3D11_SHADER_RESOURCE_VIEW_DESC() {}") +cpp_quote(" explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(D3D11_SRV_DIMENSION dim,") +cpp_quote(" DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN, UINT most_detailed_mip = 0,") +cpp_quote(" UINT mip_levels = -1, UINT first_slice = 0, UINT array_size = -1, UINT flags = 0) {") +cpp_quote(" Format = format;") +cpp_quote(" ViewDimension = dim;") +cpp_quote(" switch(ViewDimension) {") +cpp_quote(" case D3D11_SRV_DIMENSION_BUFFER:") +cpp_quote(" Buffer.FirstElement = most_detailed_mip;") +cpp_quote(" Buffer.NumElements = mip_levels;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURE1D:") +cpp_quote(" Texture1D.MostDetailedMip = most_detailed_mip;") +cpp_quote(" Texture1D.MipLevels = mip_levels;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:") +cpp_quote(" Texture1DArray.MostDetailedMip = most_detailed_mip;") +cpp_quote(" Texture1DArray.MipLevels = mip_levels;") +cpp_quote(" Texture1DArray.FirstArraySlice = first_slice;") +cpp_quote(" Texture1DArray.ArraySize = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURE2D:") +cpp_quote(" Texture2D.MostDetailedMip = most_detailed_mip;") +cpp_quote(" Texture2D.MipLevels = mip_levels;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:") +cpp_quote(" Texture2DArray.MostDetailedMip = most_detailed_mip;") +cpp_quote(" Texture2DArray.MipLevels = mip_levels;") +cpp_quote(" Texture2DArray.FirstArraySlice = first_slice;") +cpp_quote(" Texture2DArray.ArraySize = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:") +cpp_quote(" Texture2DMSArray.FirstArraySlice = first_slice;") +cpp_quote(" Texture2DMSArray.ArraySize = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURE3D:") +cpp_quote(" Texture3D.MostDetailedMip = most_detailed_mip;") +cpp_quote(" Texture3D.MipLevels = mip_levels;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURECUBE:") +cpp_quote(" TextureCube.MostDetailedMip = most_detailed_mip;") +cpp_quote(" TextureCube.MipLevels = mip_levels;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:") +cpp_quote(" TextureCubeArray.MostDetailedMip = most_detailed_mip;") +cpp_quote(" TextureCubeArray.MipLevels = mip_levels;") +cpp_quote(" TextureCubeArray.First2DArrayFace = first_slice;") +cpp_quote(" TextureCubeArray.NumCubes = array_size;") +cpp_quote(" break;") +cpp_quote(" case D3D11_SRV_DIMENSION_BUFFEREX:") +cpp_quote(" BufferEx.FirstElement = most_detailed_mip;") +cpp_quote(" BufferEx.NumElements = mip_levels;") +cpp_quote(" BufferEx.Flags = flags;") +cpp_quote(" break;") +cpp_quote(" default:") +cpp_quote(" break;") +cpp_quote(" }") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(ID3D11Buffer*, DXGI_FORMAT format, UINT first_elem,") +cpp_quote(" UINT elem_cnt, UINT flags = 0);") /* FIXME: implement */ +cpp_quote(" explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(ID3D11Texture1D *texture, D3D11_SRV_DIMENSION dim,") +cpp_quote(" DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN, UINT most_detailed_mip = 0, UINT mip_levels = -1,") +cpp_quote(" UINT first_slice = 0, UINT array_size = -1 );") /* FIXME: implement */ +cpp_quote(" explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(ID3D11Texture2D *texture, D3D11_SRV_DIMENSION dim,") +cpp_quote(" DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN, UINT most_detailed_mip = 0, UINT mip_levels = -1,") +cpp_quote(" UINT first_slice = 0, UINT array_size = -1 );") /* FIXME: implement */ +cpp_quote(" explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(ID3D11Texture3D *texture, DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN,") +cpp_quote(" UINT most_detailed_mip = 0, UINT mip_levels = -1 );") +cpp_quote(" ~CD3D11_SHADER_RESOURCE_VIEW_DESC() {}") +cpp_quote(" explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(const D3D11_SHADER_RESOURCE_VIEW_DESC &other)") +cpp_quote(" : D3D11_SHADER_RESOURCE_VIEW_DESC(other) {}") +cpp_quote(" operator const D3D11_SHADER_RESOURCE_VIEW_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_TEXTURE1D_DESC +{ + UINT Width; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D11_TEXTURE1D_DESC; + +typedef struct D3D11_TEXTURE2D_DESC +{ + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D11_TEXTURE2D_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_TEXTURE2D_DESC : public D3D11_TEXTURE2D_DESC {") +cpp_quote(" CD3D11_TEXTURE2D_DESC() {}") +cpp_quote(" explicit CD3D11_TEXTURE2D_DESC(const D3D11_TEXTURE2D_DESC &o) : D3D11_TEXTURE2D_DESC(o) {}") +cpp_quote(" explicit CD3D11_TEXTURE2D_DESC(DXGI_FORMAT format, UINT width, UINT height, UINT arraySize = 1,") +cpp_quote(" UINT mipLevels = 0, UINT bindFlags = D3D11_BIND_SHADER_RESOURCE,") +cpp_quote(" D3D11_USAGE usage = D3D11_USAGE_DEFAULT, UINT cpuaccessFlags = 0, UINT sampleCount = 1," ) +cpp_quote(" UINT sampleQuality = 0, UINT miscFlags = 0) {") +cpp_quote(" Width = width;") +cpp_quote(" Height = height;") +cpp_quote(" MipLevels = mipLevels;") +cpp_quote(" ArraySize = arraySize;") +cpp_quote(" Format = format;") +cpp_quote(" SampleDesc.Count = sampleCount;") +cpp_quote(" SampleDesc.Quality = sampleQuality;") +cpp_quote(" Usage = usage;") +cpp_quote(" BindFlags = bindFlags;") +cpp_quote(" CPUAccessFlags = cpuaccessFlags;") +cpp_quote(" MiscFlags = miscFlags;") +cpp_quote(" }" ) +cpp_quote(" ~CD3D11_TEXTURE2D_DESC() {}") +cpp_quote(" operator const D3D11_TEXTURE2D_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_TEXTURE3D_DESC +{ + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + DXGI_FORMAT Format; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D11_TEXTURE3D_DESC; + +/* + * + * D3D11 video decoder profiles + * + */ + +/* MPEG1 & MPEG2 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_MOCOMP, 0xe6a9f44b,0x61b0,0x4563,0x9e,0xa4,0x63,0xd2,0xa3,0xc6,0xfe,0x66);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_IDCT, 0xbf22ad00,0x03ea,0x4690,0x80,0x77,0x47,0x33,0x46,0x20,0x9b,0x7e);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_VLD, 0xee27417f,0x5e28,0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG1_VLD, 0x6f3ec719,0x3735,0x42cc,0x80,0x63,0x65,0xcc,0x3c,0xb3,0x66,0x16);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2and1_VLD, 0x86695f12,0x340e,0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60);") + +/* H264 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT, 0x1b81be64,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_MOCOMP_FGT, 0x1b81be65,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_IDCT_NOFGT, 0x1b81be66,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_IDCT_FGT, 0x1b81be67,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_NOFGT, 0x1b81be68,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_FGT, 0x1b81be69,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT, 0xd5f04ff9,0x3418,0x45d8,0x95,0x61,0x32,0xa7,0x6a,0xae,0x2d,0xdd);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT, 0xd79be8da,0x0cf1,0x4c81,0xb8,0x2a,0x69,0xa4,0xe2,0x36,0xf4,0x3d);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT, 0xf9aaccbb,0xc2b6,0x4cfc,0x87,0x79,0x57,0x07,0xb1,0x76,0x05,0x52);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT, 0x705b9d82,0x76cf,0x49d6,0xb7,0xe6,0xac,0x88,0x72,0xdb,0x01,0x3c);") + +/* WMV8 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV8_POSTPROC, 0x1b81be80,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV8_MOCOMP, 0x1b81be81,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") + +/* WMV9 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_POSTPROC, 0x1b81be90,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_MOCOMP, 0x1b81be91,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_IDCT, 0x1b81be94,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") + +/* VC1 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_POSTPROC, 0x1b81beA0,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_MOCOMP, 0x1b81beA1,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_IDCT, 0x1b81beA2,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_VLD, 0x1b81beA3,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_D2010, 0x1b81beA4,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);") + +/* MPEG4 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE, 0xefd64d74,0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC, 0xed418a9f,0x010d,0x4eda,0x9a,0xe3,0x9a,0x65,0x35,0x8d,0x8d,0x2e);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC, 0xab998b5b,0x4258,0x44a9,0x9f,0xeb,0x94,0xe5,0x97,0xa6,0xba,0xae);") + +/* HVEC */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_HEVC_VLD_MAIN, 0x5b11d51b,0x2f4c,0x4452,0xbc,0xc3,0x09,0xf2,0xa1,0x16,0x0c,0xc0);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10, 0x107af0e0,0xef1a,0x4d19,0xab,0xa8,0x67,0xa1,0x63,0x07,0x3d,0x13);") + +/* VP9 */ +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VP9_VLD_PROFILE0, 0x463707f8,0xa1d0,0x4585,0x87,0x6d,0x83,0xaa,0x6d,0x60,0xb8,0x9e);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VP9_VLD_10BIT_PROFILE2, 0xa4c749ef,0x6ecf,0x48aa,0x84,0x48,0x50,0xa7,0xa1,0x16,0x5f,0xf7);") +cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VP8_VLD, 0x90b899ea,0x3a62,0x4705,0x88,0xb3,0x8d,0xf0,0x4b,0x27,0x44,0xe7);") + +typedef struct D3D11_VIDEO_DECODER_DESC +{ + GUID Guid; + UINT SampleWidth; + UINT SampleHeight; + DXGI_FORMAT OutputFormat; +} D3D11_VIDEO_DECODER_DESC; + +typedef struct D3D11_VIDEO_DECODER_CONFIG +{ + GUID guidConfigBitstreamEncryption; + GUID guidConfigMBcontrolEncryption; + GUID guidConfigResidDiffEncryption; + UINT ConfigBitstreamRaw; + UINT ConfigMBcontrolRasterOrder; + UINT ConfigResidDiffHost; + UINT ConfigSpatialResid8; + UINT ConfigResid8Subtraction; + UINT ConfigSpatialHost8or9Clipping; + UINT ConfigSpatialResidInterleaved; + UINT ConfigIntraResidUnsigned; + UINT ConfigResidDiffAccelerator; + UINT ConfigHostInverseScan; + UINT ConfigSpecificIDCT; + UINT Config4GroupedCoefs; + USHORT ConfigMinRenderTargetBuffCount; + USHORT ConfigDecoderSpecific; +} D3D11_VIDEO_DECODER_CONFIG; + +typedef enum D3D11_VIDEO_FRAME_FORMAT +{ + D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE = 0, + D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST = 1, + D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST = 2 +} D3D11_VIDEO_FRAME_FORMAT; + +typedef enum D3D11_VIDEO_USAGE +{ + D3D11_VIDEO_USAGE_PLAYBACK_NORMAL = 0, + D3D11_VIDEO_USAGE_OPTIMAL_SPEED = 1, + D3D11_VIDEO_USAGE_OPTIMAL_QUALITY = 2 +} D3D11_VIDEO_USAGE; + +typedef struct D3D11_VIDEO_PROCESSOR_CONTENT_DESC +{ + D3D11_VIDEO_FRAME_FORMAT InputFrameFormat; + DXGI_RATIONAL InputFrameRate; + UINT InputWidth; + UINT InputHeight; + DXGI_RATIONAL OutputFrameRate; + UINT OutputWidth; + UINT OutputHeight; + D3D11_VIDEO_USAGE Usage; +} D3D11_VIDEO_PROCESSOR_CONTENT_DESC; + +typedef struct D3D11_VIDEO_PROCESSOR_CAPS +{ + UINT DeviceCaps; + UINT FeatureCaps; + UINT FilterCaps; + UINT InputFormatCaps; + UINT AutoStreamCaps; + UINT StereoCaps; + UINT RateConversionCapsCount; + UINT MaxInputStreams; + UINT MaxStreamStates; +} D3D11_VIDEO_PROCESSOR_CAPS; + +typedef struct D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS +{ + UINT PastFrames; + UINT FutureFrames; + UINT ProcessorCaps; + UINT ITelecineCaps; + UINT CustomRateCount; +} D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS; + +typedef struct D3D11_VIDEO_PROCESSOR_CUSTOM_RATE +{ + DXGI_RATIONAL CustomRate; + UINT OutputFrames; + BOOL InputInterlaced; + UINT InputFramesOrFields; +} D3D11_VIDEO_PROCESSOR_CUSTOM_RATE; + +typedef enum D3D11_VIDEO_PROCESSOR_FILTER +{ + D3D11_VIDEO_PROCESSOR_FILTER_BRIGHTNESS = 0, + D3D11_VIDEO_PROCESSOR_FILTER_CONTRAST = 1, + D3D11_VIDEO_PROCESSOR_FILTER_HUE = 2, + D3D11_VIDEO_PROCESSOR_FILTER_SATURATION = 3, + D3D11_VIDEO_PROCESSOR_FILTER_NOISE_REDUCTION = 4, + D3D11_VIDEO_PROCESSOR_FILTER_EDGE_ENHANCEMENT = 5, + D3D11_VIDEO_PROCESSOR_FILTER_ANAMORPHIC_SCALING = 6, + D3D11_VIDEO_PROCESSOR_FILTER_STEREO_ADJUSTMENT = 7 +} D3D11_VIDEO_PROCESSOR_FILTER; + +typedef struct D3D11_VIDEO_PROCESSOR_FILTER_RANGE +{ + int Minimum; + int Maximum; + int Default; + float Multiplier; +} D3D11_VIDEO_PROCESSOR_FILTER_RANGE; + +typedef enum D3D11_AUTHENTICATED_CHANNEL_TYPE +{ + D3D11_AUTHENTICATED_CHANNEL_D3D11 = 1, + D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE = 2, + D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE = 3 +} D3D11_AUTHENTICATED_CHANNEL_TYPE; + +typedef enum D3D11_VDOV_DIMENSION +{ + D3D11_VDOV_DIMENSION_UNKNOWN = 0, + D3D11_VDOV_DIMENSION_TEXTURE2D = 1 +} D3D11_VDOV_DIMENSION; + +typedef struct D3D11_TEX2D_VDOV +{ + UINT ArraySlice; +} D3D11_TEX2D_VDOV; + +typedef struct D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC +{ + GUID DecodeProfile; + D3D11_VDOV_DIMENSION ViewDimension; + union { + D3D11_TEX2D_VDOV Texture2D; + }; +} D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC; + +typedef enum D3D11_VPIV_DIMENSION +{ + D3D11_VPIV_DIMENSION_UNKNOWN = 0, + D3D11_VPIV_DIMENSION_TEXTURE2D = 1 +} D3D11_VPIV_DIMENSION; + +typedef struct D3D11_TEX2D_VPIV +{ + UINT MipSlice; + UINT ArraySlice; +} D3D11_TEX2D_VPIV; + +typedef struct D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC +{ + UINT FourCC; + D3D11_VPIV_DIMENSION ViewDimension; + union { + D3D11_TEX2D_VPIV Texture2D; + }; +} D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC; + +typedef enum D3D11_VPOV_DIMENSION +{ + D3D11_VPOV_DIMENSION_UNKNOWN = 0, + D3D11_VPOV_DIMENSION_TEXTURE2D = 1, + D3D11_VPOV_DIMENSION_TEXTURE2DARRAY = 2 +} D3D11_VPOV_DIMENSION; + +typedef struct D3D11_TEX2D_VPOV +{ + UINT MipSlice; +} D3D11_TEX2D_VPOV; + +typedef struct D3D11_TEX2D_ARRAY_VPOV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_VPOV; + +typedef struct D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC +{ + D3D11_VPOV_DIMENSION ViewDimension; + union { + D3D11_TEX2D_VPOV Texture2D; + D3D11_TEX2D_ARRAY_VPOV Texture2DArray; + }; +} D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC; + +typedef struct D3D11_VIDEO_CONTENT_PROTECTION_CAPS +{ + UINT Caps; + UINT KeyExchangeTypeCount; + UINT BlockAlignmentSize; + ULONGLONG ProtectedMemorySize; +} D3D11_VIDEO_CONTENT_PROTECTION_CAPS; + +typedef struct D3D11_ENCRYPTED_BLOCK_INFO +{ + UINT NumEncryptedBytesAtBeginning; + UINT NumBytesInSkipPattern; + UINT NumBytesInEncryptPattern; +} D3D11_ENCRYPTED_BLOCK_INFO; + +typedef struct D3D11_VIDEO_DECODER_BUFFER_DESC +{ + D3D11_VIDEO_DECODER_BUFFER_TYPE BufferType; + UINT BufferIndex; + UINT DataOffset; + UINT DataSize; + UINT FirstMBaddress; + UINT NumMBsInBuffer; + UINT Width; + UINT Height; + UINT Stride; + UINT ReservedBits; + void *pIV; + UINT IVSize; + BOOL PartialEncryption; + D3D11_ENCRYPTED_BLOCK_INFO EncryptedBlockInfo; +} D3D11_VIDEO_DECODER_BUFFER_DESC; + +typedef struct D3D11_VIDEO_DECODER_EXTENSION +{ + UINT Function; + void *pPrivateInputData; + UINT PrivateInputDataSize; + void *pPrivateOutputData; + UINT PrivateOutputDataSize; + UINT ResourceCount; + ID3D11Resource **ppResourceList; +} D3D11_VIDEO_DECODER_EXTENSION; + +typedef struct D3D11_VIDEO_COLOR_YCbCrA +{ + float Y; + float Cb; + float Cr; + float A; +} D3D11_VIDEO_COLOR_YCbCrA; + +typedef struct D3D11_VIDEO_COLOR_RGBA +{ + float R; + float G; + float B; + float A; +} D3D11_VIDEO_COLOR_RGBA; + +typedef struct D3D11_VIDEO_COLOR +{ + union + { + D3D11_VIDEO_COLOR_YCbCrA YCbCr; + D3D11_VIDEO_COLOR_RGBA RGBA; + }; +} D3D11_VIDEO_COLOR; + +typedef struct D3D11_VIDEO_PROCESSOR_COLOR_SPACE +{ + UINT Usage : 1; + UINT RGB_Range : 1; + UINT YCbCr_Matrix : 1; + UINT YCbCr_xvYCC : 1; + UINT Nominal_Range : 2; + UINT Reserved : 26; +} D3D11_VIDEO_PROCESSOR_COLOR_SPACE; + +typedef struct D3D11_VIDEO_PROCESSOR_STREAM +{ + BOOL Enable; + UINT OutputIndex; + UINT InputFrameOrField; + UINT PastFrames; + UINT FutureFrames; + ID3D11VideoProcessorInputView **ppPastSurfaces; + ID3D11VideoProcessorInputView *pInputSurface; + ID3D11VideoProcessorInputView **ppFutureSurfaces; + ID3D11VideoProcessorInputView **ppPastSurfacesRight; + ID3D11VideoProcessorInputView *pInputSurfaceRight; + ID3D11VideoProcessorInputView **ppFutureSurfacesRight; +} D3D11_VIDEO_PROCESSOR_STREAM; + +typedef struct D3D11_OMAC +{ + BYTE Omac[D3D11_OMAC_SIZE]; +} D3D11_OMAC; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_OUTPUT +{ + D3D11_OMAC omac; + GUID ConfigureType; + HANDLE hChannel; + UINT SequenceNumber; + HRESULT ReturnCode; +} D3D11_AUTHENTICATED_CONFIGURE_OUTPUT; + +typedef struct D3D11_QUERY_DATA_TIMESTAMP_DISJOINT +{ + UINT64 Frequency; + BOOL Disjoint; +} D3D11_QUERY_DATA_TIMESTAMP_DISJOINT; + +typedef struct D3D11_QUERY_DATA_PIPELINE_STATISTICS +{ + UINT64 IAVertices; + UINT64 IAPrimitives; + UINT64 VSInvocations; + UINT64 GSInvocations; + UINT64 GSPrimitives; + UINT64 CInvocations; + UINT64 CPrimitives; + UINT64 PSInvocations; + UINT64 HSInvocations; + UINT64 DSInvocations; + UINT64 CSInvocations; +} D3D11_QUERY_DATA_PIPELINE_STATISTICS; + +typedef struct D3D11_DRAW_INSTANCED_INDIRECT_ARGS +{ + UINT VertexCountPerInstance; + UINT InstanceCount; + UINT StartVertexLocation; + UINT StartInstanceLocation; +} D3D11_DRAW_INSTANCED_INDIRECT_ARGS; + +typedef struct D3D11_DRAW_INDEXED_INSTANCED_INDIRECT_ARGS +{ + UINT IndexCountPerInstance; + UINT InstanceCount; + UINT StartIndexLocation; + INT BaseVertexLocation; + UINT StartInstanceLocation; +} D3D11_DRAW_INDEXED_INSTANCED_INDIRECT_ARGS; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_INPUT +{ + D3D11_OMAC omac; + GUID ConfigureType; + HANDLE hChannel; + UINT SequenceNumber; +} D3D11_AUTHENTICATED_CONFIGURE_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_INPUT +{ + GUID QueryType; + HANDLE hChannel; + UINT SequenceNumber; +} D3D11_AUTHENTICATED_QUERY_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT +{ + D3D11_OMAC omac; + GUID QueryType; + HANDLE hChannel; + UINT SequenceNumber; + HRESULT ReturnCode; +} D3D11_AUTHENTICATED_QUERY_OUTPUT; + +typedef union D3D11_AUTHENTICATED_PROTECTION_FLAGS +{ + struct + { + UINT ProtectionEnabled : 1; + UINT OverlayOrFullscreenRequired : 1; + UINT Reserved : 30; + } Flags; + UINT Value; +} D3D11_AUTHENTICATED_PROTECTION_FLAGS; + +typedef struct D3D11_AUTHENTICATED_QUERY_PROTECTION_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + D3D11_AUTHENTICATED_PROTECTION_FLAGS ProtectionFlags; +} D3D11_AUTHENTICATED_QUERY_PROTECTION_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType; +} D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + HANDLE DeviceHandle; +} D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT +{ + D3D11_AUTHENTICATED_QUERY_INPUT Input; + HANDLE DecoderHandle; +} D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + HANDLE DecoderHandle; + HANDLE CryptoSessionHandle; + HANDLE DeviceHandle; +} D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + UINT RestrictedSharedResourceProcessCount; +} D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT +{ + D3D11_AUTHENTICATED_QUERY_INPUT Input; + UINT ProcessIndex; +} D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + UINT ProcessIndex; + D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE ProcessIdentifier; + HANDLE ProcessHandle; +} D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + UINT UnrestrictedProtectedSharedResourceCount; +} D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT +{ + D3D11_AUTHENTICATED_QUERY_INPUT Input; + HANDLE DeviceHandle; + HANDLE CryptoSessionHandle; +} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + HANDLE DeviceHandle; + HANDLE CryptoSessionHandle; + UINT OutputIDCount; +} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_INPUT +{ + D3D11_AUTHENTICATED_QUERY_INPUT Input; + HANDLE DeviceHandle; + HANDLE CryptoSessionHandle; + UINT OutputIDIndex; +} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + HANDLE DeviceHandle; + HANDLE CryptoSessionHandle; + UINT OutputIDIndex; + UINT64 OutputID; +} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_ACESSIBILITY_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + D3D11_BUS_TYPE BusType; + BOOL AccessibleInContiguousBlocks; + BOOL AccessibleInNonContiguousBlocks; +} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + UINT EncryptionGuidCount; +} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT +{ + D3D11_AUTHENTICATED_QUERY_INPUT Input; + UINT EncryptionGuidIndex; +} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + UINT EncryptionGuidIndex; + GUID EncryptionGuid; +} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT +{ + D3D11_AUTHENTICATED_QUERY_OUTPUT Output; + GUID EncryptionGuid; +} D3D11_AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT +{ + D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters; + UINT StartSequenceQuery; + UINT StartSequenceConfigure; +} D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_PROTECTION_INPUT +{ + D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters; + D3D11_AUTHENTICATED_PROTECTION_FLAGS Protections; +} D3D11_AUTHENTICATED_CONFIGURE_PROTECTION_INPUT; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT +{ + D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters; + HANDLE DecoderHandle; + HANDLE CryptoSessionHandle; + HANDLE DeviceHandle; +} D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT +{ + D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters; + D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE ProcessType; + HANDLE ProcessHandle; + BOOL AllowAccess; +} D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT; + +typedef struct D3D11_AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT +{ + D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters; + GUID EncryptionGuid; +} D3D11_AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT; + +[ + object, + local, + uuid(1841e5c8-16b0-489b-bcc8-44cfb0d5deae) +] +interface ID3D11DeviceChild : IUnknown +{ + void GetDevice( + [out] ID3D11Device **ppDevice); + HRESULT GetPrivateData( + [in] REFGUID guid, + [in, out] UINT *pDataSize, + [out] void *pData); + HRESULT SetPrivateData( + [in] REFGUID guid, + [in] UINT DataSize, + [in] const void *pData); + HRESULT SetPrivateDataInterface( + [in] REFGUID guid, + [in] const IUnknown *pData); +} + +[ + object, + local, + uuid(4b35d0cd-1e15-4258-9c98-1b1333f6dd3b) +] +interface ID3D11Asynchronous : ID3D11DeviceChild +{ + UINT GetDataSize(); +} + +[ + object, + local, + uuid(d6c00747-87b7-425e-b84d-44d108560afd) +] +interface ID3D11Query : ID3D11Asynchronous +{ + void GetDesc( + [out] D3D11_QUERY_DESC *pDesc); +} + +[ + object, + local, + uuid(dc8e63f3-d12b-4952-b47b-5e45026a862d) +] +interface ID3D11Resource : ID3D11DeviceChild +{ + void GetType( + [out] D3D11_RESOURCE_DIMENSION *pResourceDimension); + void SetEvictionPriority( + [in] UINT EvictionPriority); + UINT GetEvictionPriority(); +} + +[ + object, + local, + uuid(839d1216-bb2e-412b-b7f4-a9dbebe08ed1) +] +interface ID3D11View : ID3D11DeviceChild +{ + void GetResource( + [out] ID3D11Resource **ppResource); +} + +[ + object, + local, + uuid(75b68faa-347d-4159-8f45-a0640f01cd9a) +] +interface ID3D11BlendState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_BLEND_DESC *pDesc); +} + +[ + object, + local, + uuid(48570b85-d1ee-4fcd-a250-eb350722b037) +] +interface ID3D11Buffer : ID3D11Resource +{ + void GetDesc( + [out] D3D11_BUFFER_DESC *pDesc); +} + +[ + object, + local, + uuid(a6cd7faa-b0b7-4a2f-9436-8662a65797cb) +] +interface ID3D11ClassInstance : ID3D11DeviceChild +{ + void GetClassLinkage( + [out] ID3D11ClassLinkage **ppLinkage); + void GetDesc( + [out] D3D11_CLASS_INSTANCE_DESC *pDesc); + void GetInstanceName( + [out] LPSTR pInstanceName, + [in, out] SIZE_T *pBufferLength); + void GetTypeName( + [out] LPSTR pTypeName, + [in, out] SIZE_T *pBufferLength); +} + +[ + object, + local, + uuid(ddf57cba-9543-46e4-a12b-f207a0fe7fed) +] +interface ID3D11ClassLinkage : ID3D11DeviceChild +{ + HRESULT GetClassInstance( + [in] LPCSTR pClassInstanceName, + [in] UINT InstanceIndex, + [out] ID3D11ClassInstance **ppInstance); + HRESULT CreateClassInstance( + [in] LPCSTR pClassTypeName, + [in] UINT ConstantBufferOffset, + [in] UINT ConstantVectorOffset, + [in] UINT TextureOffset, + [in] UINT SamplerOffset, + [out] ID3D11ClassInstance **ppInstance); +} + +[ + object, + local, + uuid(a24bc4d1-769e-43f7-8013-98ff566c18e2) +] +interface ID3D11CommandList : ID3D11DeviceChild +{ + UINT GetContextFlags(); +} + +[ + object, + local, + uuid(4f5b196e-c2bd-495e-bd01-1fded38e4969) +] +interface ID3D11ComputeShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(6e8c49fb-a371-4770-b440-29086022b741) +] +interface ID3D11Counter : ID3D11Asynchronous +{ + void GetDesc( + [out] D3D11_COUNTER_DESC *pDesc); +} + +[ + object, + local, + uuid(03823efb-8d8f-4e1c-9aa2-f64bb2cbfdf1) +] +interface ID3D11DepthStencilState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_DEPTH_STENCIL_DESC *pDesc); +} + +[ + object, + local, + uuid(9fdac92a-1876-48c3-afad-25b94f84a9b6) +] +interface ID3D11DepthStencilView : ID3D11View +{ + void GetDesc( + [out] D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(f582c508-0f36-490c-9977-31eece268cfa) +] +interface ID3D11DomainShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(38325b96-effb-4022-ba02-2e795b70275c) +] +interface ID3D11GeometryShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(8e5c6061-628a-4c8e-8264-bbe45cb3d5dd) +] +interface ID3D11HullShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(e4819ddc-4cf0-4025-bd26-5de82a3e07b7) +] +interface ID3D11InputLayout : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(ea82e40d-51dc-4f33-93d4-db7c9125ae8c) +] +interface ID3D11PixelShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(9eb576dd-9f77-4d86-81aa-8bab5fe490e2) +] +interface ID3D11Predicate : ID3D11Query +{ +} + +[ + object, + local, + uuid(9bb4ab81-ab1a-4d8f-b506-fc04200b6ee7) +] +interface ID3D11RasterizerState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_RASTERIZER_DESC *pDesc); +} + +[ + object, + local, + uuid(dfdba067-0b8d-4865-875b-d7b4516cc164) +] +interface ID3D11RenderTargetView : ID3D11View +{ + void GetDesc( + [out] D3D11_RENDER_TARGET_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(da6fea51-564c-4487-9810-f0d0f9b4e3a5) +] +interface ID3D11SamplerState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_SAMPLER_DESC *pDesc); +} + +[ + object, + local, + uuid(b0e06fe0-8192-4e1a-b1ca-36d7414710b2) +] +interface ID3D11ShaderResourceView : ID3D11View +{ + void GetDesc( + [out] D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(f8fb5c27-c6b3-4f75-a4c8-439af2ef564c), +] +interface ID3D11Texture1D : ID3D11Resource +{ + void GetDesc( + [out] D3D11_TEXTURE1D_DESC *pDesc); +} + +[ + object, + local, + uuid(6f15aaf2-d208-4e89-9ab4-489535d34f9c) +] +interface ID3D11Texture2D : ID3D11Resource +{ + void GetDesc( + [out] D3D11_TEXTURE2D_DESC *pDesc); +} + +[ + object, + local, + uuid(037e866e-f56d-4357-a8af-9dabbe6e250e) +] +interface ID3D11Texture3D : ID3D11Resource +{ + void GetDesc( + [out] D3D11_TEXTURE3D_DESC *pDesc); +} + +[ + object, + local, + uuid(28acf509-7f5c-48f6-8611-f316010a6380) +] +interface ID3D11UnorderedAccessView : ID3D11View +{ + void GetDesc( + [out] D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(3b301d64-d678-4289-8897-22f8928b72f3) +] +interface ID3D11VertexShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(c0bfa96c-e089-44fb-8eaf-26f8796190da) +] +interface ID3D11DeviceContext : ID3D11DeviceChild +{ + void VSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void PSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void PSSetShader( + [in] ID3D11PixelShader *pPixelShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void PSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void VSSetShader( + [in] ID3D11VertexShader *pVertexShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void DrawIndexed( + [in] UINT IndexCount, + [in] UINT StartIndexLocation, + [in] INT BaseVertexLocation); + void Draw( + [in] UINT VertexCount, + [in] UINT StartVertexLocation); + HRESULT Map( + [in] ID3D11Resource *pResource, + [in] UINT Subresource, + [in] D3D11_MAP MapType, + [in] UINT MapFlags, + [out] D3D11_MAPPED_SUBRESOURCE *pMappedResource); + void Unmap( + [in] ID3D11Resource *pResource, + [in] UINT Subresource); + void PSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void IASetInputLayout( + [in] ID3D11InputLayout *pInputLayout); + void IASetVertexBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppVertexBuffers, + [in] const UINT *pStrides, + [in] const UINT *pOffsets); + void IASetIndexBuffer( + [in] ID3D11Buffer *pIndexBuffer, + [in] DXGI_FORMAT Format, + [in] UINT Offset); + void DrawIndexedInstanced( + [in] UINT IndexCountPerInstance, + [in] UINT InstanceCount, + [in] UINT StartIndexLocation, + [in] INT BaseVertexLocation, + [in] UINT StartInstanceLocation); + void DrawInstanced( + [in] UINT VertexCountPerInstance, + [in] UINT InstanceCount, + [in] UINT StartVertexLocation, + [in] UINT StartInstanceLocation); + void GSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void GSSetShader( + [in] ID3D11GeometryShader *pShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void IASetPrimitiveTopology( + [in] D3D11_PRIMITIVE_TOPOLOGY Topology); + void VSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void VSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void Begin( + [in] ID3D11Asynchronous *pAsync); + void End( + [in] ID3D11Asynchronous *pAsync); + HRESULT GetData( + [in] ID3D11Asynchronous *pAsync, + [in] void *pData, + [in] UINT DataSize, + [in] UINT GetDataFlags); + void SetPredication( + [in] ID3D11Predicate *pPredicate, + [in] BOOL PredicateValue); + void GSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void GSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void OMSetRenderTargets( + [in] UINT NumViews, + [in] ID3D11RenderTargetView *const *ppRenderTargetViews, + [in] ID3D11DepthStencilView *pDepthStencilView); + void OMSetRenderTargetsAndUnorderedAccessViews( + [in] UINT NumRTVs, + [in] ID3D11RenderTargetView *const *ppRenderTargetViews, + [in] ID3D11DepthStencilView *pDepthStencilView, + [in] UINT UAVStartSlot, + [in] UINT NumUAVs, + [in] ID3D11UnorderedAccessView *const *ppUnorderedAccessViews, + [in] const UINT *pUAVInitialCounts); + void OMSetBlendState( + [in] ID3D11BlendState *pBlendState, + [in] const FLOAT BlendFactor[4], + [in] UINT SampleMask); + void OMSetDepthStencilState( + [in] ID3D11DepthStencilState *pDepthStencilState, + [in] UINT StencilRef); + void SOSetTargets( + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppSOTargets, + [in] const UINT *pOffsets); + void DrawAuto(); + void DrawIndexedInstancedIndirect( + [in] ID3D11Buffer *pBufferForArgs, + [in] UINT AlignedByteOffsetForArgs); + void DrawInstancedIndirect( + [in] ID3D11Buffer *pBufferForArgs, + [in] UINT AlignedByteOffsetForArgs); + void Dispatch( + [in] UINT ThreadGroupCountX, + [in] UINT ThreadGroupCountY, + [in] UINT ThreadGroupCountZ); + void DispatchIndirect( + [in] ID3D11Buffer *pBufferForArgs, + [in] UINT AlignedByteOffsetForArgs); + void RSSetState( + [in] ID3D11RasterizerState *pRasterizerState); + void RSSetViewports( + [in] UINT NumViewports, + [in] const D3D11_VIEWPORT *pViewports); + void RSSetScissorRects( + [in] UINT NumRects, + [in] const D3D11_RECT *pRects); + void CopySubresourceRegion( + [in] ID3D11Resource *pDstResource, + [in] UINT DstSubresource, + [in] UINT DstX, + [in] UINT DstY, + [in] UINT DstZ, + [in] ID3D11Resource *pSrcResource, + [in] UINT SrcSubresource, + [in] const D3D11_BOX *pSrcBox); + void CopyResource( + [in] ID3D11Resource *pDstResource, + [in] ID3D11Resource *pSrcResource); + void UpdateSubresource( + [in] ID3D11Resource *pDstResource, + [in] UINT DstSubresource, + [in] const D3D11_BOX *pDstBox, + [in] const void *pSrcData, + [in] UINT SrcRowPitch, + [in] UINT SrcDepthPitch); + void CopyStructureCount( + [in] ID3D11Buffer *pDstBuffer, + [in] UINT DstAlignedByteOffset, + [in] ID3D11UnorderedAccessView *pSrcView); + void ClearRenderTargetView( + [in] ID3D11RenderTargetView *pRenderTargetView, + [in] const FLOAT ColorRGBA[4]); + void ClearUnorderedAccessViewUint( + [in] ID3D11UnorderedAccessView *pUnorderedAccessView, + [in] const UINT Values[4]); + void ClearUnorderedAccessViewFloat( + [in] ID3D11UnorderedAccessView *pUnorderedAccessView, + [in] const FLOAT Values[4]); + void ClearDepthStencilView( + [in] ID3D11DepthStencilView *pDepthStencilView, + [in] UINT ClearFlags, + [in] FLOAT Depth, + [in] UINT8 Stencil); + void GenerateMips( + [in] ID3D11ShaderResourceView *pShaderResourceView); + void SetResourceMinLOD( + [in] ID3D11Resource *pResource, FLOAT MinLOD); + FLOAT GetResourceMinLOD( + [in] ID3D11Resource *pResource); + void ResolveSubresource( + [in] ID3D11Resource *pDstResource, + [in] UINT DstSubresource, + [in] ID3D11Resource *pSrcResource, + [in] UINT SrcSubresource, + [in] DXGI_FORMAT Format); + void ExecuteCommandList( + [in] ID3D11CommandList *pCommandList, + BOOL RestoreContextState); + void HSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void HSSetShader( + [in] ID3D11HullShader *pHullShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void HSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void HSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void DSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void DSSetShader( + [in] ID3D11DomainShader *pDomainShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void DSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void DSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void CSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void CSSetUnorderedAccessViews( + [in] UINT StartSlot, + [in] UINT NumUAVs, + [in] ID3D11UnorderedAccessView *const *ppUnorderedAccessViews, + [in] const UINT *pUAVInitialCounts); + void CSSetShader( + [in] ID3D11ComputeShader *pComputeShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void CSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void CSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void VSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void PSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void PSGetShader( + [out] ID3D11PixelShader **ppPixelShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void PSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void VSGetShader( + [out] ID3D11VertexShader **ppVertexShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void PSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void IAGetInputLayout( + [out] ID3D11InputLayout **ppInputLayout); + void IAGetVertexBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppVertexBuffers, + [out] UINT *pStrides, + [out] UINT *pOffsets); + void IAGetIndexBuffer( + [out] ID3D11Buffer **pIndexBuffer, + [out] DXGI_FORMAT* Format, + [out] UINT* Offset); + void GSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void GSGetShader( + [out] ID3D11GeometryShader **ppGeometryShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void IAGetPrimitiveTopology( + [out] D3D11_PRIMITIVE_TOPOLOGY *pTopology); + void VSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void VSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void GetPredication( + [out] ID3D11Predicate **ppPredicate, + [out] BOOL *pPredicateValue); + void GSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void GSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void OMGetRenderTargets( + [in] UINT NumViews, + [out] ID3D11RenderTargetView **ppRenderTargetViews, + [out] ID3D11DepthStencilView **ppDepthStencilView); + void OMGetRenderTargetsAndUnorderedAccessViews( + [in] UINT NumRTVs, + [out] ID3D11RenderTargetView **ppRenderTargetViews, + [out] ID3D11DepthStencilView **ppDepthStencilView, + [in] UINT UAVStartSlot, + [in] UINT NumUAVs, + [out] ID3D11UnorderedAccessView **ppUnorderedAccessViews); + void OMGetBlendState( + [out] ID3D11BlendState **ppBlendState, + [out] FLOAT BlendFactor[4], + [out] UINT *pSampleMask); + void OMGetDepthStencilState( + [out] ID3D11DepthStencilState **ppDepthStencilState, + [out] UINT *pStencilRef); + void SOGetTargets( + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppSOTargets); + void RSGetState( + [out] ID3D11RasterizerState **ppRasterizerState); + void RSGetViewports( + [in, out] UINT *pNumViewports, + [out] D3D11_VIEWPORT *pViewports); + void RSGetScissorRects( + [in, out] UINT *pNumRects, + [out] D3D11_RECT *pRects); + void HSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void HSGetShader( + [out] ID3D11HullShader **ppHullShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void HSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void HSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void DSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void DSGetShader( + [out] ID3D11DomainShader **ppDomainShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void DSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void DSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void CSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void CSGetUnorderedAccessViews( + [in] UINT StartSlot, + [in] UINT NumUAVs, + [out] ID3D11UnorderedAccessView **ppUnorderedAccessViews); + void CSGetShader( + [out] ID3D11ComputeShader **ppComputeShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void CSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void CSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void ClearState(); + void Flush(); + D3D11_DEVICE_CONTEXT_TYPE GetType(); + UINT GetContextFlags(); + HRESULT FinishCommandList( + BOOL RestoreDeferredContextState, + [out] ID3D11CommandList **ppCommandList); +} + +[ + object, + uuid(3015a308-dcbd-47aa-a747-192486d14d4a), + local, + pointer_default(unique) +] +interface ID3D11AuthenticatedChannel : ID3D11DeviceChild +{ + HRESULT GetCertificateSize( + UINT *pCertificateSize); + HRESULT GetCertificate( + UINT CertificateSize, + BYTE *pCertificate); + void GetChannelHandle( + HANDLE *pChannelHandle); +} + +[ + object, + uuid(9b32f9ad-bdcc-40a6-a39d-d5c865845720), + local, + pointer_default(unique) +] +interface ID3D11CryptoSession : ID3D11DeviceChild +{ + void GetCryptoType( + GUID *pCryptoType); + void GetDecoderProfile( + GUID *pDecoderProfile); + HRESULT GetCertificateSize( + UINT *pCertificateSize); + HRESULT GetCertificate( + UINT CertificateSize, + BYTE *pCertificate); + void GetCryptoSessionHandle( + HANDLE *pCryptoSessionHandle); +} + +[ + object, + uuid(3c9c5b51-995d-48d1-9b8d-fa5caeded65c), + local, + pointer_default(unique) +] +interface ID3D11VideoDecoder : ID3D11DeviceChild +{ + HRESULT GetCreationParameters( + D3D11_VIDEO_DECODER_DESC *pVideoDesc, + D3D11_VIDEO_DECODER_CONFIG *pConfig); + HRESULT GetDriverHandle( + HANDLE *pDriverHandle); +} + +[ + object, + uuid(31627037-53ab-4200-9061-05faa9ab45f9), + local, + pointer_default(unique) +] +interface ID3D11VideoProcessorEnumerator : ID3D11DeviceChild +{ + HRESULT GetVideoProcessorContentDesc( + D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc); + HRESULT CheckVideoProcessorFormat( + DXGI_FORMAT Format, + UINT *pFlags); + HRESULT GetVideoProcessorCaps( + D3D11_VIDEO_PROCESSOR_CAPS *pCaps); + HRESULT GetVideoProcessorRateConversionCaps( + UINT TypeIndex, + D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps); + HRESULT GetVideoProcessorCustomRate( + UINT TypeIndex, + UINT CustomRateIndex, + D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate); + HRESULT GetVideoProcessorFilterRange( + D3D11_VIDEO_PROCESSOR_FILTER Filter, + D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange); +} + +[ + object, + uuid(1d7b0652-185f-41c6-85ce-0c5be3d4ae6c), + local, + pointer_default(unique) +] +interface ID3D11VideoProcessor : ID3D11DeviceChild +{ + void GetContentDesc( + D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc); + void GetRateConversionCaps( + D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps); +} + +[ + object, + uuid(c2931aea-2a85-4f20-860f-fba1fd256e18), + local, + pointer_default(unique) +] +interface ID3D11VideoDecoderOutputView : ID3D11View +{ + void GetDesc( + D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc); +} + +[ + object, + uuid(11ec5a5f-51dc-4945-ab34-6e8c21300ea5), + local, + pointer_default(unique) +] +interface ID3D11VideoProcessorInputView : ID3D11View +{ + void GetDesc( + D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc); +} + +[ + object, + uuid(a048285e-25a9-4527-bd93-d68b68c44254), + local, + pointer_default(unique) +] +interface ID3D11VideoProcessorOutputView : ID3D11View +{ + void GetDesc( + D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc); +} + +[ + object, + uuid(10ec4d5b-975a-4689-b9e4-d0aac30fe333), + local, + pointer_default(unique) +] +interface ID3D11VideoDevice : IUnknown +{ + HRESULT CreateVideoDecoder( + const D3D11_VIDEO_DECODER_DESC *pVideoDesc, + const D3D11_VIDEO_DECODER_CONFIG *pConfig, + ID3D11VideoDecoder **ppDecoder); + HRESULT CreateVideoProcessor( + ID3D11VideoProcessorEnumerator *pEnum, + UINT RateConversionIndex, + ID3D11VideoProcessor **ppVideoProcessor); + HRESULT CreateAuthenticatedChannel( + D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType, + ID3D11AuthenticatedChannel **ppAuthenticatedChannel); + HRESULT CreateCryptoSession( + const GUID *pCryptoType, + const GUID *pDecoderProfile, + const GUID *pKeyExchangeType, + ID3D11CryptoSession **ppCryptoSession); + HRESULT CreateVideoDecoderOutputView( + ID3D11Resource *pResource, + const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc, + ID3D11VideoDecoderOutputView **ppVDOVView); + HRESULT CreateVideoProcessorInputView( + ID3D11Resource *pResource, + ID3D11VideoProcessorEnumerator *pEnum, + const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc, + ID3D11VideoProcessorInputView **ppVPIView); + HRESULT CreateVideoProcessorOutputView( + ID3D11Resource *pResource, + ID3D11VideoProcessorEnumerator *pEnum, + const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc, + ID3D11VideoProcessorOutputView **ppVPOView); + HRESULT CreateVideoProcessorEnumerator( + const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc, + ID3D11VideoProcessorEnumerator **ppEnum); + UINT GetVideoDecoderProfileCount(); + HRESULT GetVideoDecoderProfile( + UINT Index, + GUID *pDecoderProfile); + HRESULT CheckVideoDecoderFormat( + const GUID *pDecoderProfile, + DXGI_FORMAT Format, + BOOL *pSupported); + HRESULT GetVideoDecoderConfigCount( + const D3D11_VIDEO_DECODER_DESC *pDesc, + UINT *pCount); + HRESULT GetVideoDecoderConfig( + const D3D11_VIDEO_DECODER_DESC *pDesc, + UINT Index, + D3D11_VIDEO_DECODER_CONFIG *pConfig); + HRESULT GetContentProtectionCaps( + const GUID *pCryptoType, + const GUID *pDecoderProfile, + D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps); + HRESULT CheckCryptoKeyExchange( + const GUID *pCryptoType, + const GUID *pDecoderProfile, + UINT Index, + GUID *pKeyExchangeType); + HRESULT SetPrivateData( + REFGUID guid, + UINT DataSize, + const void *pData); + HRESULT SetPrivateDataInterface( + REFGUID guid, + const IUnknown *pData); +} + +[ + object, + uuid(61f21c45-3c0e-4a74-9cea-67100d9ad5e4), + local, + pointer_default(unique) +] +interface ID3D11VideoContext : ID3D11DeviceChild +{ + HRESULT GetDecoderBuffer( + [in] ID3D11VideoDecoder *decoder, + [in] D3D11_VIDEO_DECODER_BUFFER_TYPE type, + [out] UINT *buffer_size, + [out] void **buffer + ); + HRESULT ReleaseDecoderBuffer( + [in] ID3D11VideoDecoder *decoder, + [in] D3D11_VIDEO_DECODER_BUFFER_TYPE type + ); + HRESULT DecoderBeginFrame( + [in] ID3D11VideoDecoder *decoder, + [in] ID3D11VideoDecoderOutputView *view, + [in] UINT key_size, + [in] const void *key + ); + HRESULT DecoderEndFrame( + [in] ID3D11VideoDecoder *decoder + ); + HRESULT SubmitDecoderBuffers( + [in] ID3D11VideoDecoder *decoder, + [in] UINT buffers_count, + [in] const D3D11_VIDEO_DECODER_BUFFER_DESC *buffer_desc + ); + HRESULT DecoderExtension( + [in] ID3D11VideoDecoder *decoder, + [in] const D3D11_VIDEO_DECODER_EXTENSION *extension + ); + void VideoProcessorSetOutputTargetRect( + [in] ID3D11VideoProcessor *processor, + [in] BOOL enable, + [in] const RECT *rect + ); + void VideoProcessorSetOutputBackgroundColor( + [in] ID3D11VideoProcessor *processor, + [in] BOOL y_cb_cr, + [in] const D3D11_VIDEO_COLOR *color + ); + void VideoProcessorSetOutputColorSpace( + [in] ID3D11VideoProcessor *processor, + [in] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *color_space + ); + void VideoProcessorSetOutputAlphaFillMode( + [in] ID3D11VideoProcessor *processor, + [in] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE alpha_fill_mode, + [in] UINT stream_idx + ); + void VideoProcessorSetOutputConstriction( + [in] ID3D11VideoProcessor *processor, + [in] BOOL enable, + [in] SIZE size + ); + void VideoProcessorSetOutputStereoMode( + [in] ID3D11VideoProcessor *processor, + [in] BOOL enable + ); + HRESULT VideoProcessorSetOutputExtension( + [in] ID3D11VideoProcessor *processor, + [in] const GUID *guid, + [in] UINT data_size, + [in] void *data + ); + void VideoProcessorGetOutputTargetRect( + [in] ID3D11VideoProcessor *processor, + [out] BOOL *enabled, + [out] RECT *rect + ); + void VideoProcessorGetOutputBackgroundColor( + [in] ID3D11VideoProcessor *processor, + [out] BOOL *y_cb_cr, + [out] D3D11_VIDEO_COLOR *color + ); + void VideoProcessorGetOutputColorSpace( + [in] ID3D11VideoProcessor *processor, + [out] D3D11_VIDEO_PROCESSOR_COLOR_SPACE *color_space + ); + void VideoProcessorGetOutputAlphaFillMode( + [in] ID3D11VideoProcessor *processor, + [out] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE *alpha_fill_mode, + [out] UINT *stream_idx + ); + void VideoProcessorGetOutputConstriction( + [in] ID3D11VideoProcessor *processor, + [out] BOOL *enabled, + [out] SIZE *size + ); + void VideoProcessorGetOutputStereoMode( + [in] ID3D11VideoProcessor *processor, + [out] BOOL *enabled + ); + HRESULT VideoProcessorGetOutputExtension( + [in] ID3D11VideoProcessor *processor, + [in] const GUID *guid, + [in] UINT data_size, + [out] void *data + ); + void VideoProcessorSetStreamFrameFormat( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] D3D11_VIDEO_FRAME_FORMAT format + ); + void VideoProcessorSetStreamColorSpace( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *color_space + ); + void VideoProcessorSetStreamOutputRate( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE rate, + [in] BOOL repeat, + [in] const DXGI_RATIONAL *custom_rate + ); + void VideoProcessorSetStreamSourceRect( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] const RECT *rect + ); + void VideoProcessorSetStreamDestRect( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] const RECT *rect + ); + void VideoProcessorSetStreamAlpha( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] float alpha + ); + void VideoProcessorSetStreamPalette( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] UINT entry_count, + [in] const UINT *entries + ); + void VideoProcessorSetStreamPixelAspectRatio( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] const DXGI_RATIONAL *src_aspect_ratio, + [in] const DXGI_RATIONAL *dst_aspect_ratio + ); + void VideoProcessorSetStreamLumaKey( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] float lower, + [in] float upper + ); + void VideoProcessorSetStreamStereoFormat( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT format, + [in] BOOL left_view_frame0, + [in] BOOL base_view_frame0, + [in] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE flip_mode, + [in] int mono_offset + ); + void VideoProcessorSetStreamAutoProcessingMode( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable + ); + void VideoProcessorSetStreamFilter( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] D3D11_VIDEO_PROCESSOR_FILTER filter, + [in] BOOL enable, + [in] int level + ); + HRESULT VideoProcessorSetStreamExtension( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] const GUID *guid, + [in] UINT data_size, + [in] void *data + ); + void VideoProcessorGetStreamFrameFormat( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] D3D11_VIDEO_FRAME_FORMAT *format + ); + void VideoProcessorGetStreamColorSpace( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] D3D11_VIDEO_PROCESSOR_COLOR_SPACE *color_space + ); + void VideoProcessorGetStreamOutputRate( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE *rate, + [out] BOOL *repeat, + [out] DXGI_RATIONAL *custom_rate + ); + void VideoProcessorGetStreamSourceRect( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled, + [out] RECT *rect + ); + void VideoProcessorGetStreamDestRect( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled, + [out] RECT *rect + ); + void VideoProcessorGetStreamAlpha( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled, + [out] float *alpha + ); + void VideoProcessorGetStreamPalette( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] UINT entry_count, + [out] UINT *entries + ); + void VideoProcessorGetStreamPixelAspectRatio( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled, + [out] DXGI_RATIONAL *src_aspect_ratio, + [out] DXGI_RATIONAL *dst_aspect_ratio + ); + void VideoProcessorGetStreamLumaKey( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled, + [out] float *lower, + [out] float *upper + ); + void VideoProcessorGetStreamStereoFormat( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled, + [out] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT *format, + [out] BOOL *left_view_frame0, + [out] BOOL *base_view_frame0, + [out] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE *flip_mode, + [out] int *mono_offset + ); + void VideoProcessorGetStreamAutoProcessingMode( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enabled + ); + void VideoProcessorGetStreamFilter( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] D3D11_VIDEO_PROCESSOR_FILTER filter, + [out] BOOL *enabled, + [out] int *level + ); + HRESULT VideoProcessorGetStreamExtension( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] const GUID *guid, + [in] UINT data_size, + [out] void *data + ); + HRESULT VideoProcessorBlt( + [in] ID3D11VideoProcessor *processor, + [in] ID3D11VideoProcessorOutputView *view, + [in] UINT frame_idx, + [in] UINT stream_count, + [in] const D3D11_VIDEO_PROCESSOR_STREAM *streams + ); + HRESULT NegotiateCryptoSessionKeyExchange( + [in] ID3D11CryptoSession *session, + [in] UINT data_size, + [in, out] void *data + ); + void EncryptionBlt( + [in] ID3D11CryptoSession *session, + [in] ID3D11Texture2D *src_surface, + [in] ID3D11Texture2D *dst_surface, + [in] UINT iv_size, + [in, out] void *iv + ); + void DecryptionBlt( + [in] ID3D11CryptoSession *session, + [in] ID3D11Texture2D *src_surface, + [in] ID3D11Texture2D *dst_surface, + [in] D3D11_ENCRYPTED_BLOCK_INFO *block_info, + [in] UINT key_size, + [in] const void *key, + [in] UINT iv_size, + [in, out] void *iv + ); + void StartSessionKeyRefresh( + [in] ID3D11CryptoSession *session, + [in] UINT random_number_size, + [out] void *random_number + ); + void FinishSessionKeyRefresh( + [in] ID3D11CryptoSession *session + ); + HRESULT GetEncryptionBltKey( + [in] ID3D11CryptoSession *session, + [in] UINT key_size, + [out] void *key + ); + HRESULT NegotiateAuthenticatedChannelKeyExchange( + [in] ID3D11AuthenticatedChannel *channel, + [in] UINT data_size, + [in, out] void *data + ); + HRESULT QueryAuthenticatedChannel( + [in] ID3D11AuthenticatedChannel *channel, + [in] UINT input_size, + [in] const void *input, + [in] UINT output_size, + [out] void *output + ); + HRESULT ConfigureAuthenticatedChannel( + [in] ID3D11AuthenticatedChannel *channel, + [in] UINT input_size, + [in] const void *input, + [out] D3D11_AUTHENTICATED_CONFIGURE_OUTPUT *output + ); + void VideoProcessorSetStreamRotation( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [in] BOOL enable, + [in] D3D11_VIDEO_PROCESSOR_ROTATION rotation + ); + void VideoProcessorGetStreamRotation( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_idx, + [out] BOOL *enable, + [out] D3D11_VIDEO_PROCESSOR_ROTATION *rotation + ); +} + +[ + object, + local, + uuid(db6f6ddb-ac77-4e88-8253-819df9bbf140) +] +interface ID3D11Device : IUnknown +{ + HRESULT CreateBuffer( + [in] const D3D11_BUFFER_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Buffer **ppBuffer); + HRESULT CreateTexture1D( + [in] const D3D11_TEXTURE1D_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Texture1D **ppTexture1D); + HRESULT CreateTexture2D( + [in] const D3D11_TEXTURE2D_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Texture2D **ppTexture2D); + HRESULT CreateTexture3D( + [in] const D3D11_TEXTURE3D_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Texture3D **ppTexture3D); + HRESULT CreateShaderResourceView( + [in] ID3D11Resource *pResource, + [in] const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc, + [out] ID3D11ShaderResourceView **ppSRView); + HRESULT CreateUnorderedAccessView( + [in] ID3D11Resource *pResource, + [in] const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc, + [out] ID3D11UnorderedAccessView **ppUAView); + HRESULT CreateRenderTargetView( + [in] ID3D11Resource *pResource, + [in] const D3D11_RENDER_TARGET_VIEW_DESC *pDesc, + [out] ID3D11RenderTargetView **ppRTView); + HRESULT CreateDepthStencilView( + [in] ID3D11Resource *pResource, + [in] const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc, + [out] ID3D11DepthStencilView **ppDepthStencilView); + HRESULT CreateInputLayout( + [in] const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs, + [in] UINT NumElements, + [in] const void *pShaderBytecodeWithInputSignature, + [in] SIZE_T BytecodeLength, + [out] ID3D11InputLayout **ppInputLayout); + HRESULT CreateVertexShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11VertexShader **ppVertexShader); + HRESULT CreateGeometryShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11GeometryShader **ppGeometryShader); + HRESULT CreateGeometryShaderWithStreamOutput( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] const D3D11_SO_DECLARATION_ENTRY *pSODeclaration, + [in] UINT NumEntries, + [in] const UINT *pBufferStrides, + [in] UINT NumStrides, + [in] UINT RasterizedStream, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11GeometryShader **ppGeometryShader); + HRESULT CreatePixelShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11PixelShader **ppPixelShader); + HRESULT CreateHullShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11HullShader **ppHullShader); + HRESULT CreateDomainShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11DomainShader **ppDomainShader); + HRESULT CreateComputeShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11ComputeShader **ppComputeShader); + HRESULT CreateClassLinkage( + [out] ID3D11ClassLinkage **ppLinkage); + HRESULT CreateBlendState( + [in] const D3D11_BLEND_DESC *pBlendStateDesc, + [out] ID3D11BlendState **ppBlendState); + HRESULT CreateDepthStencilState( + [in] const D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc, + [out] ID3D11DepthStencilState **ppDepthStencilState); + HRESULT CreateRasterizerState( + [in] const D3D11_RASTERIZER_DESC *pRasterizerDesc, + [out] ID3D11RasterizerState **ppRasterizerState); + HRESULT CreateSamplerState( + [in] const D3D11_SAMPLER_DESC *pSamplerDesc, + [out] ID3D11SamplerState **ppSamplerState); + HRESULT CreateQuery( + [in] const D3D11_QUERY_DESC *pQueryDesc, + [out] ID3D11Query **ppQuery); + HRESULT CreatePredicate( + [in] const D3D11_QUERY_DESC *pPredicateDesc, + [out] ID3D11Predicate **ppPredicate); + HRESULT CreateCounter( + [in] const D3D11_COUNTER_DESC *pCounterDesc, + [out] ID3D11Counter **ppCounter); + HRESULT CreateDeferredContext( + UINT ContextFlags, + [out] ID3D11DeviceContext **ppDeferredContext); + HRESULT OpenSharedResource( + [in] HANDLE hResource, + [in] REFIID ReturnedInterface, + [out] void **ppResource); + HRESULT CheckFormatSupport( + [in] DXGI_FORMAT Format, + [out] UINT *pFormatSupport); + HRESULT CheckMultisampleQualityLevels( + [in] DXGI_FORMAT Format, + [in] UINT SampleCount, + [out] UINT *pNumQualityLevels); + void CheckCounterInfo( + [out] D3D11_COUNTER_INFO *pCounterInfo); + HRESULT CheckCounter( + [in] const D3D11_COUNTER_DESC *pDesc, + [out] D3D11_COUNTER_TYPE *pType, + [out] UINT *pActiveCounters, + [out] LPSTR szName, + [in, out] UINT *pNameLength, + [out] LPSTR szUnits, + [in, out] UINT *pUnitsLength, + [out] LPSTR szDescription, + [in, out] UINT *pDescriptionLength); + HRESULT CheckFeatureSupport( + D3D11_FEATURE Feature, + [out] void *pFeatureSupportData, + UINT FeatureSupportDataSize); + HRESULT GetPrivateData( + [in] REFGUID guid, + [in, out] UINT *pDataSize, + [out] void *pData); + HRESULT SetPrivateData( + [in] REFGUID guid, + [in] UINT DataSize, + [in] const void *pData); + HRESULT SetPrivateDataInterface( + [in] REFGUID guid, + [in] const IUnknown *pData); + D3D_FEATURE_LEVEL GetFeatureLevel(); + UINT GetCreationFlags(); + HRESULT GetDeviceRemovedReason(); + void GetImmediateContext( + [out] ID3D11DeviceContext **ppImmediateContext); + HRESULT SetExceptionMode(UINT RaiseFlags); + UINT GetExceptionMode(); +} + +typedef enum D3D11_CREATE_DEVICE_FLAG { + D3D11_CREATE_DEVICE_SINGLETHREADED = 0x0001, + D3D11_CREATE_DEVICE_DEBUG = 0x0002, + D3D11_CREATE_DEVICE_SWITCH_TO_REF = 0x0004, + D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x0008, + D3D11_CREATE_DEVICE_BGRA_SUPPORT = 0x0020, + D3D11_CREATE_DEVICE_DEBUGGABLE = 0x0040, + D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x0080, + D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT = 0x0100, + D3D11_CREATE_DEVICE_VIDEO_SUPPORT = 0x0800 +} D3D11_CREATE_DEVICE_FLAG; + +typedef enum D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT +{ + D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT = 0x0001, + D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT = 0x0002, +} D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT; + +const UINT D3D11_SDK_VERSION = 7; + +cpp_quote("#include ") +cpp_quote("#ifndef D3D11_IGNORE_SDK_LAYERS") +cpp_quote("# include ") +cpp_quote("#endif") +cpp_quote("#include ") +cpp_quote("#include ") +cpp_quote("#include ") +cpp_quote("#include ") + +const UINT _FACD3D11 = 0x87c; +cpp_quote("#define MAKE_D3D11_HRESULT(code) MAKE_HRESULT(SEVERITY_ERROR, _FACD3D11, code)") + +cpp_quote("typedef HRESULT (WINAPI* PFN_D3D11_CREATE_DEVICE)(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,") +cpp_quote(" const D3D_FEATURE_LEVEL*,UINT,UINT,ID3D11Device**,D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);") + +cpp_quote("HRESULT WINAPI D3D11CreateDevice(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,const D3D_FEATURE_LEVEL*," ) +cpp_quote(" UINT,UINT,ID3D11Device**,D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);") + +cpp_quote("typedef HRESULT (WINAPI *PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,") +cpp_quote(" const D3D_FEATURE_LEVEL*,UINT,UINT,const DXGI_SWAP_CHAIN_DESC*,IDXGISwapChain**,ID3D11Device**,") +cpp_quote(" D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);") + +[local] HRESULT __stdcall D3D11CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D_DRIVER_TYPE driver_type, + HMODULE swrast, UINT flags, const D3D_FEATURE_LEVEL *feature_levels, UINT levels, UINT sdk_version, + const DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, ID3D11Device **device, + D3D_FEATURE_LEVEL *obtained_feature_level, ID3D11DeviceContext **immediate_context); diff --git a/WineFix/lib/d2d1/include/windows/d3d11_1.idl b/WineFix/lib/d2d1/include/windows/d3d11_1.idl new file mode 100644 index 0000000..4fd82f0 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11_1.idl @@ -0,0 +1,547 @@ +/* + * Copyright 2014 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi1_2.idl"; +import "d3dcommon.idl"; +import "d3d11.idl"; + +typedef enum D3D11_LOGIC_OP +{ + D3D11_LOGIC_OP_CLEAR = 0, + D3D11_LOGIC_OP_SET, + D3D11_LOGIC_OP_COPY, + D3D11_LOGIC_OP_COPY_INVERTED, + D3D11_LOGIC_OP_NOOP, + D3D11_LOGIC_OP_INVERT, + D3D11_LOGIC_OP_AND, + D3D11_LOGIC_OP_NAND, + D3D11_LOGIC_OP_OR, + D3D11_LOGIC_OP_NOR, + D3D11_LOGIC_OP_XOR, + D3D11_LOGIC_OP_EQUIV, + D3D11_LOGIC_OP_AND_REVERSE, + D3D11_LOGIC_OP_AND_INVERTED, + D3D11_LOGIC_OP_OR_REVERSE, + D3D11_LOGIC_OP_OR_INVERTED +} D3D11_LOGIC_OP; + +typedef enum D3D11_COPY_FLAGS +{ + D3D11_COPY_NO_OVERWRITE = 0x00000001, + D3D11_COPY_DISCARD = 0x00000002, +} D3D11_COPY_FLAGS; + +typedef enum D3D11_1_CREATE_DEVICE_CONTEXT_STATE_FLAG +{ + D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED = 0x1, +} D3D11_1_CREATE_DEVICE_CONTEXT_STATE_FLAG; + +typedef enum D3D11_VIDEO_DECODER_CAPS +{ + D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE = 0x01, + D3D11_VIDEO_DECODER_CAPS_NON_REAL_TIME = 0x02, + D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_DYNAMIC = 0x04, + D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_REQUIRED = 0x08, + D3D11_VIDEO_DECODER_CAPS_UNSUPPORTED = 0x10, +} D3D11_VIDEO_DECODER_CAPS; + +typedef enum D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINTS +{ + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_ROTATION = 0x01, + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_RESIZE = 0x02, + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_COLOR_SPACE_CONVERSION = 0x04, + D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_TRIPLE_BUFFER_OUTPUT = 0x08, +} D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINTS; + +typedef enum D3D11_CRYPTO_SESSION_STATUS +{ + D3D11_CRYPTO_SESSION_STATUS_OK = 0x0, + D3D11_CRYPTO_SESSION_STATUS_KEY_LOST = 0x1, + D3D11_CRYPTO_SESSION_STATUS_KEY_AND_CONTENT_LOST = 0x2, +} D3D11_CRYPTO_SESSION_STATUS; + +typedef struct D3D11_RENDER_TARGET_BLEND_DESC1 +{ + BOOL BlendEnable; + BOOL LogicOpEnable; + D3D11_BLEND SrcBlend; + D3D11_BLEND DestBlend; + D3D11_BLEND_OP BlendOp; + D3D11_BLEND SrcBlendAlpha; + D3D11_BLEND DestBlendAlpha; + D3D11_BLEND_OP BlendOpAlpha; + D3D11_LOGIC_OP LogicOp; + UINT8 RenderTargetWriteMask; +} D3D11_RENDER_TARGET_BLEND_DESC1; + +typedef struct D3D11_BLEND_DESC1 +{ + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + D3D11_RENDER_TARGET_BLEND_DESC1 RenderTarget[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT]; +} D3D11_BLEND_DESC1; + +typedef struct D3D11_RASTERIZER_DESC1 +{ + D3D11_FILL_MODE FillMode; + D3D11_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; + UINT ForcedSampleCount; +} D3D11_RASTERIZER_DESC1; + +typedef struct D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK +{ + UINT ClearSize; + UINT EncryptedSize; +} D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK; + +typedef struct D3D11_VIDEO_DECODER_BUFFER_DESC1 +{ + D3D11_VIDEO_DECODER_BUFFER_TYPE BufferType; + UINT DataOffset; + UINT DataSize; + void *pIV; + UINT IVSize; + D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK *pSubSampleMappingBlock; + UINT SubSampleMappingCount; +} D3D11_VIDEO_DECODER_BUFFER_DESC1; + +typedef struct D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION +{ + ID3D11CryptoSession *pCryptoSession; + UINT BlobSize; + void *pBlob; + GUID *pKeyInfoId; + UINT PrivateDataSize; + void *pPrivateData; +} D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION; + +typedef struct D3D11_VIDEO_PROCESSOR_STREAM_BEHAVIOR_HINT +{ + BOOL Enable; + UINT Width; + UINT Height; + DXGI_FORMAT Format; +} D3D11_VIDEO_PROCESSOR_STREAM_BEHAVIOR_HINT; + +typedef struct D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA +{ + UINT PrivateDataSize; + UINT HWProtectionDataSize; + BYTE pbInput[4]; +} D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA; + +typedef struct D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA +{ + UINT PrivateDataSize; + UINT MaxHWProtectionDataSize; + UINT HWProtectionDataSize; + UINT64 TransportTime; + UINT64 ExecutionTime; + BYTE pbOutput[4]; +} D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA; + +typedef struct D3D11_KEY_EXCHANGE_HW_PROTECTION_DATA +{ + UINT HWProtectionFunctionID; + D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA *pInputData; + D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA *pOutputData; + HRESULT Status; +} D3D11_KEY_EXCHANGE_HW_PROTECTION_DATA; + +typedef struct D3D11_VIDEO_SAMPLE_DESC +{ + UINT Width; + UINT Height; + DXGI_FORMAT Format; + DXGI_COLOR_SPACE_TYPE ColorSpace; +} D3D11_VIDEO_SAMPLE_DESC; + +[ + uuid(cc86fabe-da55-401d-85e7-e3c9de2877e9), + object, + local, + pointer_default(unique) +] +interface ID3D11BlendState1 : ID3D11BlendState +{ + void GetDesc1(D3D11_BLEND_DESC1 *pDesc); +} + +[ + uuid(5c1e0d8a-7c23-48f9-8c59-a92958ceff11), + object, + local, + pointer_default(unique) +] +interface ID3DDeviceContextState : ID3D11DeviceChild +{ +} + +[ + uuid(bb2c6faa-b5fb-4082-8e6b-388b8cfa90e1), + object, + local, + pointer_default(unique) +] +interface ID3D11DeviceContext1 : ID3D11DeviceContext +{ + void CopySubresourceRegion1( + ID3D11Resource *pDstResource, + UINT DstSubresource, + UINT DstX, + UINT DstY, + UINT DstZ, + ID3D11Resource *pSrcResource, + UINT SrcSubresource, + const D3D11_BOX *pSrcBox, + UINT CopyFlags); + + void UpdateSubresource1( + ID3D11Resource *pDstResource, + UINT DstSubresource, + const D3D11_BOX *pDstBox, + const void *pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch, + UINT CopyFlags); + + void DiscardResource(ID3D11Resource *pResource); + + void DiscardView(ID3D11View *pResourceView); + + void VSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer *const *ppConstantBuffers, + const UINT *pFirstConstant, + const UINT *pNumConstants); + + void HSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer *const *ppConstantBuffers, + const UINT *pFirstConstant, + const UINT *pNumConstants); + + void DSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer *const *ppConstantBuffers, + const UINT *pFirstConstant, + const UINT *pNumConstants); + + void GSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer *const *ppConstantBuffers, + const UINT *pFirstConstant, + const UINT *pNumConstants); + + void PSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer *const *ppConstantBuffers, + const UINT *pFirstConstant, + const UINT *pNumConstants); + + void CSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer *const *ppConstantBuffers, + const UINT *pFirstConstant, + const UINT *pNumConstants); + + void VSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer **ppConstantBuffers, + UINT *pFirstConstant, + UINT *pNumConstants); + + void HSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer **ppConstantBuffers, + UINT *pFirstConstant, + UINT *pNumConstants); + + void DSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer **ppConstantBuffers, + UINT *pFirstConstant, + UINT *pNumConstants); + + void GSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer **ppConstantBuffers, + UINT *pFirstConstant, + UINT *pNumConstants); + + void PSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer **ppConstantBuffers, + UINT *pFirstConstant, + UINT *pNumConstants); + + void CSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer **ppConstantBuffers, + UINT *pFirstConstant, + UINT *pNumConstants); + + void SwapDeviceContextState( + ID3DDeviceContextState *pState, + ID3DDeviceContextState **ppPreviousState); + + void ClearView( + ID3D11View *pView, + const FLOAT Color[4], + const D3D11_RECT *pRect, + UINT NumRects); + + void DiscardView1( + ID3D11View *pResourceView, + const D3D11_RECT *pRects, + UINT NumRects); +} + +[ + uuid(a7f026da-a5f8-4487-a564-15e34357651e), + object, + local, + pointer_default(unique) +] +interface ID3D11VideoContext1 : ID3D11VideoContext +{ + HRESULT SubmitDecoderBuffers1( + ID3D11VideoDecoder *decoder, + UINT buffer_count, + const D3D11_VIDEO_DECODER_BUFFER_DESC1 *buffer_desc + ); + HRESULT GetDataForNewHardwareKey( + ID3D11CryptoSession *session, + UINT input_size, + const void *input_data, + UINT64 *output_data + ); + HRESULT CheckCryptoSessionStatus( + ID3D11CryptoSession *session, + D3D11_CRYPTO_SESSION_STATUS *status + ); + HRESULT DecoderEnableDownsampling( + ID3D11VideoDecoder *decoder, + DXGI_COLOR_SPACE_TYPE colour_space, + const D3D11_VIDEO_SAMPLE_DESC *output_desc, + UINT reference_frame_count + ); + HRESULT DecoderUpdateDownsampling( + ID3D11VideoDecoder *decoder, + const D3D11_VIDEO_SAMPLE_DESC *output_desc + ); + void VideoProcessorSetOutputColorSpace1( + ID3D11VideoProcessor *processor, + DXGI_COLOR_SPACE_TYPE colour_space + ); + void VideoProcessorSetOutputShaderUsage( + ID3D11VideoProcessor *processor, + BOOL shader_usage + ); + void VideoProcessorGetOutputColorSpace1( + ID3D11VideoProcessor *processor, + DXGI_COLOR_SPACE_TYPE *colour_space + ); + void VideoProcessorGetOutputShaderUsage( + ID3D11VideoProcessor *processor, + BOOL *shader_usage + ); + void VideoProcessorSetStreamColorSpace1( + ID3D11VideoProcessor *processor, + UINT stream_index, + DXGI_COLOR_SPACE_TYPE colour_space + ); + void VideoProcessorSetStreamMirror( + ID3D11VideoProcessor *processor, + UINT stream_index, + BOOL enable, + BOOL flip_horizontal, + BOOL flip_vertical + ); + void VideoProcessorGetStreamColorSpace1( + ID3D11VideoProcessor *processor, + UINT stream_index, + DXGI_COLOR_SPACE_TYPE *colour_space + ); + void VideoProcessorGetStreamMirror( + ID3D11VideoProcessor *processor, + UINT stream_index, + BOOL *enable, + BOOL *flip_horizontal, + BOOL *flip_vertical + ); + HRESULT VideoProcessorGetBehaviorHints( + ID3D11VideoProcessor *processor, + UINT output_width, + UINT output_height, + DXGI_FORMAT output_format, + UINT stream_count, + const D3D11_VIDEO_PROCESSOR_STREAM_BEHAVIOR_HINT *streams, + UINT *behaviour_hints + ); +} + +[ + uuid(29da1d51-1321-4454-804b-f5fc9f861f0f), + object, + local, + pointer_default(unique) +] +interface ID3D11VideoDevice1 : ID3D11VideoDevice +{ + HRESULT GetCryptoSessionPrivateDataSize( + const GUID *crypto_type, + const GUID *decoder_profile, + const GUID *key_exchange_type, + UINT *input_size, + UINT *output_size + ); + HRESULT GetVideoDecoderCaps( + const GUID *decoder_profile, + UINT sample_width, + UINT sample_height, + const DXGI_RATIONAL *framerate, + UINT bitrate, + const GUID *crypto_type, + UINT *decoder_caps + ); + HRESULT CheckVideoDecoderDownsampling( + const D3D11_VIDEO_DECODER_DESC *input_desc, + DXGI_COLOR_SPACE_TYPE input_colour_space, + const D3D11_VIDEO_DECODER_CONFIG *input_config, + const DXGI_RATIONAL *framerate, + const D3D11_VIDEO_SAMPLE_DESC *output_desc, + BOOL *supported, + BOOL *real_time_hint + ); + HRESULT RecommendVideoDecoderDownsampleParameters( + const D3D11_VIDEO_DECODER_DESC *input_desc, + DXGI_COLOR_SPACE_TYPE input_colour_space, + const D3D11_VIDEO_DECODER_CONFIG *input_config, + const DXGI_RATIONAL *framerate, + D3D11_VIDEO_SAMPLE_DESC *recommended_output_desc + ); +} + +[ + uuid(465217f2-5568-43cf-b5b9-f61d54531ca1), + object, + local, + pointer_default(unique) +] +interface ID3D11VideoProcessorEnumerator1 : ID3D11VideoProcessorEnumerator +{ + HRESULT CheckVideoProcessorFormatConversion( + DXGI_FORMAT input_format, + DXGI_COLOR_SPACE_TYPE input_colour_space, + DXGI_FORMAT output_format, + DXGI_COLOR_SPACE_TYPE output_colour_space, + BOOL *supported + ); +} + +[ + uuid(b2daad8b-03d4-4dbf-95eb-32ab4b63d0ab), + object, + local, + pointer_default(unique) +] +interface ID3DUserDefinedAnnotation : IUnknown +{ + INT BeginEvent(LPCWSTR Name); + INT EndEvent(); + void SetMarker(LPCWSTR Name); + BOOL GetStatus(); +} + +[ + uuid(1217d7a6-5039-418c-b042-9cbe256afd6e), + object, + local, + pointer_default(unique) +] +interface ID3D11RasterizerState1 : ID3D11RasterizerState +{ + void GetDesc1(D3D11_RASTERIZER_DESC1 *pDesc); +} + +[ + uuid(a04bfb29-08ef-43d6-a49c-a9bdbdcbe686), + object, + local, + pointer_default(unique) +] +interface ID3D11Device1 : ID3D11Device +{ + void GetImmediateContext1( + ID3D11DeviceContext1 **ppImmediateContext); + + HRESULT CreateDeferredContext1( + UINT ContextFlags, + ID3D11DeviceContext1 **ppDeferredContext); + + HRESULT CreateBlendState1( + const D3D11_BLEND_DESC1 *pBlendStateDesc, + ID3D11BlendState1 **ppBlendState); + + HRESULT CreateRasterizerState1( + const D3D11_RASTERIZER_DESC1 *pRasterizerDesc, + ID3D11RasterizerState1 **ppRasterizerState); + + HRESULT CreateDeviceContextState( + UINT Flags, + const D3D_FEATURE_LEVEL *pFeatureLevels, + UINT FeatureLevels, + UINT SDKVersion, + REFIID EmulatedInterface, + D3D_FEATURE_LEVEL *pChosenFeatureLevel, + ID3DDeviceContextState **ppContextState); + + HRESULT OpenSharedResource1( + HANDLE hResource, + REFIID returnedInterface, + void **ppResource); + + HRESULT OpenSharedResourceByName( + LPCWSTR lpName, + DWORD dwDesiredAccess, + REFIID returnedInterface, + void **ppResource); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d11_2.idl b/WineFix/lib/d2d1/include/windows/d3d11_2.idl new file mode 100644 index 0000000..bb4db02 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11_2.idl @@ -0,0 +1,173 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi1_3.idl"; +import "d3dcommon.idl"; +import "d3d11_1.idl"; + +const UINT D3D11_PACKED_TILE = 0xffffffff; + +typedef enum D3D11_TILE_MAPPING_FLAG +{ + D3D11_TILE_MAPPING_NO_OVERWRITE = 0x1, +} D3D11_TILE_MAPPING_FLAG; + +typedef enum D3D11_TILE_RANGE_FLAG +{ + D3D11_TILE_RANGE_NULL = 0x1, + D3D11_TILE_RANGE_SKIP = 0x2, + D3D11_TILE_RANGE_REUSE_SINGLE_TILE = 0x4, +} D3D11_TILE_RANGE_FLAG; + +typedef enum D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_FLAG +{ + D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_TILED_RESOURCE = 0x1, +} D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_FLAG; + +typedef enum D3D11_TILE_COPY_FLAG +{ + D3D11_TILE_COPY_NO_OVERWRITE = 0x1, + D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2, + D3D11_TILE_COPY_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4, +} D3D11_TILE_COPY_FLAG; + +typedef struct D3D11_TILED_RESOURCE_COORDINATE +{ + UINT X; + UINT Y; + UINT Z; + UINT Subresource; +} D3D11_TILED_RESOURCE_COORDINATE; + +typedef struct D3D11_TILE_REGION_SIZE +{ + UINT NumTiles; + BOOL bUseBox; + UINT Width; + UINT16 Height; + UINT16 Depth; +} D3D11_TILE_REGION_SIZE; + +typedef struct D3D11_SUBRESOURCE_TILING +{ + UINT WidthInTiles; + UINT16 HeightInTiles; + UINT16 DepthInTiles; + UINT StartTileIndexInOverallResource; +} D3D11_SUBRESOURCE_TILING; + +typedef struct D3D11_TILE_SHAPE +{ + UINT WidthInTexels; + UINT HeightInTexels; + UINT DepthInTexels; +} D3D11_TILE_SHAPE; + +typedef struct D3D11_PACKED_MIP_DESC +{ + UINT8 NumStandardMips; + UINT8 NumPackedMips; + UINT NumTilesForPackedMips; + UINT StartTileIndexInOverallResource; +} D3D11_PACKED_MIP_DESC; + +[ + uuid(420d5b32-b90c-4da4-bef0-359f6a24a83a), + object, + local, + pointer_default(unique) +] +interface ID3D11DeviceContext2 : ID3D11DeviceContext1 +{ + HRESULT UpdateTileMappings( + ID3D11Resource *resource, + UINT region_count, + const D3D11_TILED_RESOURCE_COORDINATE *region_start_coordinates, + const D3D11_TILE_REGION_SIZE *region_sizes, + ID3D11Buffer *pool, + UINT range_count, + const UINT *range_flags, + const UINT *pool_start_offsets, + const UINT *range_tile_counts, + UINT flags + ); + HRESULT CopyTileMappings( + ID3D11Resource *dst_resource, + const D3D11_TILED_RESOURCE_COORDINATE *dst_start_coordinate, + ID3D11Resource *src_resource, + const D3D11_TILED_RESOURCE_COORDINATE *src_start_coordinate, + const D3D11_TILE_REGION_SIZE *region_size, + UINT flags + ); + void CopyTiles( + ID3D11Resource *resource, + const D3D11_TILED_RESOURCE_COORDINATE *start_coordinate, + const D3D11_TILE_REGION_SIZE *size, + ID3D11Buffer *buffer, + UINT64 start_offset, + UINT flags + ); + void UpdateTiles( + ID3D11Resource *dst_resource, + const D3D11_TILED_RESOURCE_COORDINATE *dst_start_coordinate, + const D3D11_TILE_REGION_SIZE *dst_region_size, + const void *src_data, + UINT flags + ); + HRESULT ResizeTilePool( + ID3D11Buffer *pool, + UINT64 size + ); + void TiledResourceBarrier( + ID3D11DeviceChild *before_barrier, + ID3D11DeviceChild *after_barrier + ); + BOOL IsAnnotationEnabled(); + void SetMarkerInt(const WCHAR *label, int data); + void BeginEventInt(const WCHAR *label, int data); + void EndEvent(); +} + +[ + uuid(9d06dffa-d1e5-4d07-83a8-1bb123f2f841), + object, + local, + pointer_default(unique) +] +interface ID3D11Device2 : ID3D11Device1 +{ + void GetImmediateContext2(ID3D11DeviceContext2 **context); + HRESULT CreateDeferredContext2(UINT flags, ID3D11DeviceContext2 **context); + void GetResourceTiling( + ID3D11Resource *resource, + UINT *tile_count, + D3D11_PACKED_MIP_DESC *mip_desc, + D3D11_TILE_SHAPE *tile_shape, + UINT *subresource_tiling_count, + UINT first_subresource_tiling, + D3D11_SUBRESOURCE_TILING *subresource_tiling + ); + HRESULT CheckMultisampleQualityLevels1( + DXGI_FORMAT format, + UINT sample_count, + UINT flags, + UINT *quality_level_count + ); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d11_3.idl b/WineFix/lib/d2d1/include/windows/d3d11_3.idl new file mode 100644 index 0000000..f188a37 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11_3.idl @@ -0,0 +1,385 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi1_3.idl"; +import "d3dcommon.idl"; +import "d3d11_2.idl"; + +typedef enum D3D11_CONTEXT_TYPE +{ + D3D11_CONTEXT_TYPE_ALL = 0x0, + D3D11_CONTEXT_TYPE_3D = 0x1, + D3D11_CONTEXT_TYPE_COMPUTE = 0x2, + D3D11_CONTEXT_TYPE_COPY = 0x3, + D3D11_CONTEXT_TYPE_VIDEO = 0x4, +} D3D11_CONTEXT_TYPE; + +typedef enum D3D11_TEXTURE_LAYOUT +{ + D3D11_TEXTURE_LAYOUT_UNDEFINED = 0x0, + D3D11_TEXTURE_LAYOUT_ROW_MAJOR = 0x1, + D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE = 0x2, +} D3D11_TEXTURE_LAYOUT; + +typedef enum D3D11_CONSERVATIVE_RASTERIZATION_MODE +{ + D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF = 0x0, + D3D11_CONSERVATIVE_RASTERIZATION_MODE_ON = 0x1, +} D3D11_CONSERVATIVE_RASTERIZATION_MODE; + +typedef enum D3D11_FENCE_FLAG +{ + D3D11_FENCE_FLAG_NONE = 0x1, + D3D11_FENCE_FLAG_SHARED = 0x2, + D3D11_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x4, + D3D11_FENCE_FLAG_NON_MONITORED = 0x8, +} D3D11_FENCE_FLAG; + +typedef struct D3D11_TEXTURE2D_DESC1 +{ + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + D3D11_TEXTURE_LAYOUT TextureLayout; +} D3D11_TEXTURE2D_DESC1; + +typedef struct D3D11_TEXTURE3D_DESC1 +{ + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + DXGI_FORMAT Format; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + D3D11_TEXTURE_LAYOUT TextureLayout; +} D3D11_TEXTURE3D_DESC1; + +typedef struct D3D11_RASTERIZER_DESC2 +{ + D3D11_FILL_MODE FillMode; + D3D11_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + int DepthBias; + float DepthBiasClamp; + float SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; + UINT ForcedSampleCount; + D3D11_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; +} D3D11_RASTERIZER_DESC2; + +typedef struct D3D11_TEX2D_SRV1 +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT PlaneSlice; +} D3D11_TEX2D_SRV1; + +typedef struct D3D11_TEX2D_ARRAY_SRV1 +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; +} D3D11_TEX2D_ARRAY_SRV1; + +typedef struct D3D11_SHADER_RESOURCE_VIEW_DESC1 +{ + DXGI_FORMAT Format; + D3D11_SRV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_SRV Buffer; + D3D11_TEX1D_SRV Texture1D; + D3D11_TEX1D_ARRAY_SRV Texture1DArray; + D3D11_TEX2D_SRV1 Texture2D; + D3D11_TEX2D_ARRAY_SRV1 Texture2DArray; + D3D11_TEX2DMS_SRV Texture2DMS; + D3D11_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D11_TEX3D_SRV Texture3D; + D3D11_TEXCUBE_SRV TextureCube; + D3D11_TEXCUBE_ARRAY_SRV TextureCubeArray; + D3D11_BUFFEREX_SRV BufferEx; + }; +} D3D11_SHADER_RESOURCE_VIEW_DESC1; + +typedef struct D3D11_TEX2D_RTV1 +{ + UINT MipSlice; + UINT PlaneSlice; +} D3D11_TEX2D_RTV1; + +typedef struct D3D11_TEX2D_ARRAY_RTV1 +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; +} D3D11_TEX2D_ARRAY_RTV1; + +typedef struct D3D11_RENDER_TARGET_VIEW_DESC1 +{ + DXGI_FORMAT Format; + D3D11_RTV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_RTV Buffer; + D3D11_TEX1D_RTV Texture1D; + D3D11_TEX1D_ARRAY_RTV Texture1DArray; + D3D11_TEX2D_RTV1 Texture2D; + D3D11_TEX2D_ARRAY_RTV1 Texture2DArray; + D3D11_TEX2DMS_RTV Texture2DMS; + D3D11_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D11_TEX3D_RTV Texture3D; + }; +} D3D11_RENDER_TARGET_VIEW_DESC1; + +typedef struct D3D11_TEX2D_UAV1 +{ + UINT MipSlice; + UINT PlaneSlice; +} D3D11_TEX2D_UAV1; + +typedef struct D3D11_TEX2D_ARRAY_UAV1 +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; +} D3D11_TEX2D_ARRAY_UAV1; + +typedef struct D3D11_UNORDERED_ACCESS_VIEW_DESC1 +{ + DXGI_FORMAT Format; + D3D11_UAV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_UAV Buffer; + D3D11_TEX1D_UAV Texture1D; + D3D11_TEX1D_ARRAY_UAV Texture1DArray; + D3D11_TEX2D_UAV1 Texture2D; + D3D11_TEX2D_ARRAY_UAV1 Texture2DArray; + D3D11_TEX3D_UAV Texture3D; + }; +} D3D11_UNORDERED_ACCESS_VIEW_DESC1; + +typedef struct D3D11_QUERY_DESC1 +{ + D3D11_QUERY Query; + UINT MiscFlags; + D3D11_CONTEXT_TYPE ContextType; +} D3D11_QUERY_DESC1; + +[ + uuid(51218251-1e33-4617-9ccb-4d3a4367e7bb), + object, + local, + pointer_default(unique) +] +interface ID3D11Texture2D1 : ID3D11Texture2D +{ + void GetDesc1(D3D11_TEXTURE2D_DESC1 *desc); +} + +[ + uuid(0c711683-2853-4846-9bb0-f3e60639e46a), + object, + local, + pointer_default(unique) +] +interface ID3D11Texture3D1 : ID3D11Texture3D +{ + void GetDesc1(D3D11_TEXTURE3D_DESC1 *desc); +} + +[ + uuid(6fbd02fb-209f-46c4-b059-2ed15586a6ac), + object, + local, + pointer_default(unique) +] +interface ID3D11RasterizerState2 : ID3D11RasterizerState1 +{ + void GetDesc2(D3D11_RASTERIZER_DESC2 *desc); +} + +[ + uuid(91308b87-9040-411d-8c67-c39253ce3802), + object, + local, + pointer_default(unique) +] +interface ID3D11ShaderResourceView1 : ID3D11ShaderResourceView +{ + void GetDesc1(D3D11_SHADER_RESOURCE_VIEW_DESC1 *desc); +} + +[ + uuid(ffbe2e23-f011-418a-ac56-5ceed7c5b94b), + object, + local, + pointer_default(unique) +] +interface ID3D11RenderTargetView1 : ID3D11RenderTargetView +{ + void GetDesc1(D3D11_RENDER_TARGET_VIEW_DESC1 *desc); +} + +[ + uuid(7b3b6153-a886-4544-ab37-6537c8500403), + object, + local, + pointer_default(unique) +] +interface ID3D11UnorderedAccessView1 : ID3D11UnorderedAccessView +{ + void GetDesc1(D3D11_UNORDERED_ACCESS_VIEW_DESC1 *desc); +} + +[ + uuid(631b4766-36dc-461d-8db6-c47e13e60916), + object, + local, + pointer_default(unique) +] +interface ID3D11Query1 : ID3D11Query +{ + void GetDesc1(D3D11_QUERY_DESC1 *desc); +} + +[ + uuid(b4e3c01d-e79e-4637-91b2-510e9f4c9b8f), + object, + local, + pointer_default(unique) +] +interface ID3D11DeviceContext3 : ID3D11DeviceContext2 +{ + void Flush1(D3D11_CONTEXT_TYPE type, HANDLE event); + void SetHardwareProtectionState(BOOL enable); + void GetHardwareProtectionState(BOOL *enable); +} + +[ + uuid(affde9d1-1df7-4bb7-8a34-0f46251dab80), + object, + local, + pointer_default(unique) +] +interface ID3D11Fence : ID3D11DeviceChild +{ + HRESULT CreateSharedHandle( + const SECURITY_ATTRIBUTES *attributes, + DWORD access, + const WCHAR *name, + HANDLE *handle + ); + UINT64 GetCompletedValue(); + HRESULT SetEventOnCompletion( + UINT64 value, + HANDLE event + ); +} + +[ + uuid(917600da-f58c-4c33-98d8-3e15b390fa24), + object, + local, + pointer_default(unique) +] +interface ID3D11DeviceContext4 : ID3D11DeviceContext3 +{ + HRESULT Signal(ID3D11Fence *fence, UINT64 value); + HRESULT Wait(ID3D11Fence *fence, UINT64 value); +} + +[ + uuid(a05c8c37-d2c6-4732-b3a0-9ce0b0dc9ae6), + object, + local, + pointer_default(unique) +] +interface ID3D11Device3 : ID3D11Device2 +{ + HRESULT CreateTexture2D1( + const D3D11_TEXTURE2D_DESC1 *desc, + const D3D11_SUBRESOURCE_DATA *initial_data, + ID3D11Texture2D1 **texture + ); + HRESULT CreateTexture3D1( + const D3D11_TEXTURE3D_DESC1 *desc, + const D3D11_SUBRESOURCE_DATA *initial_data, + ID3D11Texture3D1 **texture + ); + HRESULT CreateRasterizerState2( + const D3D11_RASTERIZER_DESC2 *desc, + ID3D11RasterizerState2 **state + ); + HRESULT CreateShaderResourceView1( + ID3D11Resource *resource, + const D3D11_SHADER_RESOURCE_VIEW_DESC1 *desc, + ID3D11ShaderResourceView1 **view + ); + HRESULT CreateUnorderedAccessView1( + ID3D11Resource *resource, + const D3D11_UNORDERED_ACCESS_VIEW_DESC1 *desc, + ID3D11UnorderedAccessView1 **view + ); + HRESULT CreateRenderTargetView1( + ID3D11Resource *resource, + const D3D11_RENDER_TARGET_VIEW_DESC1 *desc, + ID3D11RenderTargetView1 **view + ); + HRESULT CreateQuery1(const D3D11_QUERY_DESC1 *desc, ID3D11Query1 **query); + void GetImmediateContext3(ID3D11DeviceContext3 **context); + HRESULT CreateDeferredContext3(UINT flags, ID3D11DeviceContext3 **context); + void WriteToSubresource( + ID3D11Resource *dst_resource, + UINT dst_subresource, + const D3D11_BOX *dst_box, + const void *src_data, + UINT src_row_pitch, + UINT src_depth_pitch + ); + void ReadFromSubresource( + void *dst_data, + UINT dst_row_pitch, + UINT dst_depth_pitch, + ID3D11Resource *src_resource, + UINT src_subresource, + const D3D11_BOX *src_box + ); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d11_4.idl b/WineFix/lib/d2d1/include/windows/d3d11_4.idl new file mode 100644 index 0000000..f98a7b8 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11_4.idl @@ -0,0 +1,120 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA +*/ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi1_5.idl"; +import "d3dcommon.idl"; +import "d3d11_3.idl"; + +typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS4 +{ + BOOL ExtendedNV12SharedTextureSupported; +} D3D11_FEATURE_DATA_D3D11_OPTIONS4; + +[ + uuid(8992ab71-02e6-4b8d-ba48-b056dcda42c4), + object, + local, + pointer_default(unique) +] +interface ID3D11Device4 : ID3D11Device3 +{ + HRESULT RegisterDeviceRemovedEvent( + [in] HANDLE event, + [out] DWORD *cookie + ); + void UnregisterDeviceRemoved( + [in] DWORD cookie + ); +} + +[ + uuid(8ffde202-a0e7-45df-9e01-e837801b5ea0), + object, + local, + pointer_default(unique) +] +interface ID3D11Device5 : ID3D11Device4 +{ + HRESULT OpenSharedFence( + [in] HANDLE handle, + [in] REFIID iid, + [out] void **fence + ); + HRESULT CreateFence( + [in] UINT64 initial_value, + [in] D3D11_FENCE_FLAG flags, + [in] REFIID iid, + [out] void **fence + ); +} + +[ + uuid(9b7e4e00-342c-4106-a19f-4f2704f689f0), + object, + local, + pointer_default(unique) +] +interface ID3D11Multithread : IUnknown +{ + void Enter(); + void Leave(); + BOOL SetMultithreadProtected( + [in] BOOL enable + ); + BOOL GetMultithreadProtected(); +} + +[ + uuid(c4e7374c-6243-4d1b-ae87-52b4f740e261), + object, + local, + pointer_default(unique) +] +interface ID3D11VideoContext2 : ID3D11VideoContext1 +{ + void VideoProcessorSetOutputHDRMetaData( + [in] ID3D11VideoProcessor *processor, + [in] DXGI_HDR_METADATA_TYPE type, + [in] UINT size, + [in] const void *meta_data + ); + void VideoProcessorGetOutputHDRMetaData( + [in] ID3D11VideoProcessor *processor, + [out] DXGI_HDR_METADATA_TYPE *type, + [in] UINT size, + [out] void *meta_data + ); + + void VideoProcessorSetStreamHDRMetaData( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_index, + [in] DXGI_HDR_METADATA_TYPE type, + [in] UINT size, + [in] const void *meta_data + ); + + void VideoProcessorGetStreamHDRMetaData( + [in] ID3D11VideoProcessor *processor, + [in] UINT stream_index, + [out] DXGI_HDR_METADATA_TYPE *type, + [in] UINT size, + [out] void *meta_data + ); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d11on12.idl b/WineFix/lib/d2d1/include/windows/d3d11on12.idl new file mode 100644 index 0000000..fb9037c --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11on12.idl @@ -0,0 +1,90 @@ +/* + * Copyright 2018 Józef Kucia + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "d3d11.idl"; +import "d3d12.idl"; + +typedef struct D3D11_RESOURCE_FLAGS +{ + UINT BindFlags; + UINT MiscFlags; + UINT CPUAccessFlags; + UINT StructureByteStride; +} D3D11_RESOURCE_FLAGS; + +[ + uuid(85611e73-70a9-490e-9614-a9e302777904), + object, + local, + pointer_default(unique) +] +interface ID3D11On12Device : IUnknown +{ + HRESULT CreateWrappedResource(IUnknown *d3d12_resource, + const D3D11_RESOURCE_FLAGS *flags, + D3D12_RESOURCE_STATES input_state, + D3D12_RESOURCE_STATES output_state, + REFIID iid, void **d3d11_resource); + + void ReleaseWrappedResources(ID3D11Resource * const *resources, UINT count); + + void AcquireWrappedResources(ID3D11Resource * const *resources, UINT count); +} + +[local] HRESULT __stdcall D3D11On12CreateDevice(IUnknown *device, UINT flags, + const D3D_FEATURE_LEVEL *feature_levels, UINT feature_level_count, + IUnknown * const *queues, UINT queue_count, UINT node_mask, + ID3D11Device **d3d11_device, ID3D11DeviceContext **d3d11_immediate_context, + D3D_FEATURE_LEVEL *obtained_feature_level); + +typedef HRESULT (__stdcall *PFN_D3D11ON12_CREATE_DEVICE)(IUnknown *device, UINT flags, + const D3D_FEATURE_LEVEL *feature_levels, UINT feature_level_count, + IUnknown * const *queues, UINT queue_count, UINT node_mask, + ID3D11Device **d3d11_device, ID3D11DeviceContext **d3d11_immediate_context, + D3D_FEATURE_LEVEL *obtained_feature_level); + +[ + uuid(bdb64df4-ea2f-4c70-b861-aaab1258bb5d), + object, + local, + pointer_default(unique) +] +interface ID3D11On12Device1 : ID3D11On12Device +{ + HRESULT GetD3D12Device(REFIID iid, ID3D12Device **d3d12_device); +} + +[ + uuid(dc90f331-4740-43fa-866e-67f12cb58223), + object, + local, + pointer_default(unique) +] +interface ID3D11On12Device2 : ID3D11On12Device1 +{ + HRESULT UnwrapUnderlyingResource(ID3D11Resource *d3d11_resource, + ID3D12CommandQueue *d3d12_command_queue, + REFIID iid, void **d3d12_resource); + + HRESULT ReturnUnderlyingResource(ID3D11Resource *d3d11_resource, + UINT num_sync, + UINT64 *signal_values, + ID3D12Fence **fences); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d11sdklayers.idl b/WineFix/lib/d2d1/include/windows/d3d11sdklayers.idl new file mode 100644 index 0000000..843e978 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11sdklayers.idl @@ -0,0 +1,1305 @@ +/* + * Copyright 2013 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "d3d11.idl"; + +const UINT D3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OP = 0x1; +const UINT D3D11_DEBUG_FEATURE_FINISH_PER_RENDER_OP = 0x2; +const UINT D3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OP = 0x4; +const UINT D3D11_DEBUG_FEATURE_ALWAYS_DISCARD_OFFERED_RESOURCE = 0x8; +const UINT D3D11_DEBUG_FEATURE_NEVER_DISCARD_OFFERED_RESOURCE = 0x10; +const UINT D3D11_DEBUG_FEATURE_AVOID_BEHAVIOR_CHANGING_DEBUG_AIDS = 0x40; +const UINT D3D11_DEBUG_FEATURE_DISABLE_TILED_RESOURCE_MAPPING_TRACKING_AND_VALIDATION = 0x80; + +cpp_quote("DEFINE_GUID(DXGI_DEBUG_D3D11, 0x4b99317b, 0xac39, 0x4aa6, 0xbb, 0xb, 0xba, 0xa0, 0x47, 0x84, 0x79, 0x8f);") + +typedef enum D3D11_MESSAGE_CATEGORY { + D3D11_MESSAGE_CATEGORY_APPLICATION_DEFINED, + D3D11_MESSAGE_CATEGORY_MISCELLANEOUS, + D3D11_MESSAGE_CATEGORY_INITIALIZATION, + D3D11_MESSAGE_CATEGORY_CLEANUP, + D3D11_MESSAGE_CATEGORY_COMPILATION, + D3D11_MESSAGE_CATEGORY_STATE_CREATION, + D3D11_MESSAGE_CATEGORY_STATE_SETTING, + D3D11_MESSAGE_CATEGORY_STATE_GETTING, + D3D11_MESSAGE_CATEGORY_RESOURCE_MANIPULATION, + D3D11_MESSAGE_CATEGORY_EXECUTION, + D3D11_MESSAGE_CATEGORY_SHADER +} D3D11_MESSAGE_CATEGORY; + +typedef enum D3D11_MESSAGE_SEVERITY { + D3D11_MESSAGE_SEVERITY_CORRUPTION, + D3D11_MESSAGE_SEVERITY_ERROR, + D3D11_MESSAGE_SEVERITY_WARNING, + D3D11_MESSAGE_SEVERITY_INFO, + D3D11_MESSAGE_SEVERITY_MESSAGE +} D3D11_MESSAGE_SEVERITY; + +typedef enum D3D11_MESSAGE_ID { + D3D11_MESSAGE_ID_UNKNOWN = 0, + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_HAZARD, + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_HAZARD, + D3D11_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_HAZARD, + D3D11_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_HAZARD, + D3D11_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_HAZARD, + D3D11_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_HAZARD, + D3D11_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_HAZARD, + D3D11_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_HAZARD, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETS_HAZARD, + D3D11_MESSAGE_ID_DEVICE_SOSETTARGETS_HAZARD, + D3D11_MESSAGE_ID_STRING_FROM_APPLICATION, + D3D11_MESSAGE_ID_CORRUPTED_THIS, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER1, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER2, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER3, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER4, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER5, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER6, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER7, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER8, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER9, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER10, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER11, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER12, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER13, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER14, + D3D11_MESSAGE_ID_CORRUPTED_PARAMETER15, + D3D11_MESSAGE_ID_CORRUPTED_MULTITHREADING, + D3D11_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY, + D3D11_MESSAGE_ID_IASETINPUTLAYOUT_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_IASETINDEXBUFFER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_VSSETSHADER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_VSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_VSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_GSSETSHADER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_GSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_GSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_SOSETTARGETS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_PSSETSHADER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_PSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_PSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_RSSETSTATE_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_OMSETBLENDSTATE_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_OMSETDEPTHSTENCILSTATE_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_SETPREDICATION_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_GETPRIVATEDATA_MOREDATA, + D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA, + D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN, + D3D11_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS, + D3D11_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS, + D3D11_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDSAMPLES, + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDUSAGE, + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDBINDFLAGS, + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDMISCFLAGS, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDBINDFLAGS, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDINITIALDATA, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDMIPLEVELS, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDMISCFLAGS, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATEBUFFER_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEBUFFER_NULLDESC, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDCONSTANTBUFFERBINDINGS, + D3D11_MESSAGE_ID_CREATEBUFFER_LARGEALLOCATION, + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNSUPPORTEDFORMAT, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDSAMPLES, + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDUSAGE, + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDBINDFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDMISCFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDBINDFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDINITIALDATA, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDMIPLEVELS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDMISCFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE1D_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATETEXTURE1D_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATETEXTURE1D_NULLDESC, + D3D11_MESSAGE_ID_CREATETEXTURE1D_LARGEALLOCATION, + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNSUPPORTEDFORMAT, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDSAMPLES, + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDUSAGE, + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDBINDFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDMISCFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDBINDFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDINITIALDATA, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDMIPLEVELS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDMISCFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE2D_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATETEXTURE2D_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATETEXTURE2D_NULLDESC, + D3D11_MESSAGE_ID_CREATETEXTURE2D_LARGEALLOCATION, + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNSUPPORTEDFORMAT, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDSAMPLES, + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDUSAGE, + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDBINDFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDMISCFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDCPUACCESSFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDBINDFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDINITIALDATA, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDMIPLEVELS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDMISCFLAGS, + D3D11_MESSAGE_ID_CREATETEXTURE3D_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATETEXTURE3D_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATETEXTURE3D_NULLDESC, + D3D11_MESSAGE_ID_CREATETEXTURE3D_LARGEALLOCATION, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_NULLDESC, + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE, + D3D11_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC, + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDQUERY, + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDMISCFLAGS, + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_UNEXPECTEDMISCFLAG, + D3D11_MESSAGE_ID_CREATEQUERYORPREDICATE_NULLDESC, + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED, + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED, + D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_OFFSET_TOO_LARGE, + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_IASETINDEXBUFFER_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_FORMAT_INVALID, + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_TOO_LARGE, + D3D11_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_VSSETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_GSSETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_SOSETTARGETS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_SOSETTARGETS_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_PSSETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT, + D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR, + D3D11_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH, + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH, + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID, + D3D11_MESSAGE_ID_DEVICE_IAGETVERTEXBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_VSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_VSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_VSGETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_GSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_GSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_GSGETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_SOGETTARGETS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_PSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_PSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_PSGETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_RSGETVIEWPORTS_VIEWPORTS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_RSGETSCISSORRECTS_RECTS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_GENERATEMIPS_RESOURCE_INVALID, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSUBRESOURCE, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESUBRESOURCE, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCEBOX, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCE, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSTATE, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESTATE, + D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE, + D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE, + D3D11_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE, + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE, + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX, + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE, + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID, + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID, + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID, + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID, + D3D11_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID, + D3D11_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE, + D3D11_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS, + D3D11_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED, + D3D11_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN, + D3D11_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED, + D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE, + D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS, + D3D11_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED, + D3D11_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN, + D3D11_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED, + D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE, + D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS, + D3D11_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED, + D3D11_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN, + D3D11_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED, + D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE, + D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS, + D3D11_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED, + D3D11_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN, + D3D11_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED, + D3D11_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED, + D3D11_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED, + D3D11_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS, + D3D11_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN, + D3D11_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE, + D3D11_MESSAGE_ID_REF_THREADING_MODE, + D3D11_MESSAGE_ID_REF_UMDRIVER_EXCEPTION, + D3D11_MESSAGE_ID_REF_KMDRIVER_EXCEPTION, + D3D11_MESSAGE_ID_REF_HARDWARE_EXCEPTION, + D3D11_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE, + D3D11_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER, + D3D11_MESSAGE_ID_REF_OUT_OF_MEMORY, + D3D11_MESSAGE_ID_REF_INFO, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_INPUTLAYOUT_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_TOO_SMALL, + D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_SHADERRESOURCEVIEW_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_VIEW_DIMENSION_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL, + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_FORMAT_INVALID, + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_TOO_SMALL, + D3D11_MESSAGE_ID_DEVICE_DRAW_GS_INPUT_PRIMITIVE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_RETURN_TYPE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_POSITION_NOT_PRESENT, + D3D11_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_BOUND_RESOURCE_MAPPED, + D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_PRIMITIVETOPOLOGY, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_STRIDE_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_DRAW_INDEX_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE, + D3D11_MESSAGE_ID_DEVICE_DRAW_SO_STRIDE_LARGER_THAN_BUFFER, + D3D11_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING, + D3D11_MESSAGE_ID_DEVICE_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0, + D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT, + D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT, + D3D11_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT, + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN, + D3D11_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC, + D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH, + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW, + D3D11_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH, + D3D11_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY, + D3D11_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY, + D3D11_MESSAGE_ID_CREATEQUERY_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEPREDICATE_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATECOUNTER_OUTOFRANGE_COUNTER, + D3D11_MESSAGE_ID_CREATECOUNTER_SIMULTANEOUS_ACTIVE_COUNTERS_EXHAUSTED, + D3D11_MESSAGE_ID_CREATECOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER, + D3D11_MESSAGE_ID_CREATECOUNTER_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATECOUNTER_NONEXCLUSIVE_RETURN, + D3D11_MESSAGE_ID_CREATECOUNTER_NULLDESC, + D3D11_MESSAGE_ID_CHECKCOUNTER_OUTOFRANGE_COUNTER, + D3D11_MESSAGE_ID_CHECKCOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER, + D3D11_MESSAGE_ID_SETPREDICATION_INVALID_PREDICATE_STATE, + D3D11_MESSAGE_ID_QUERY_BEGIN_UNSUPPORTED, + D3D11_MESSAGE_ID_PREDICATE_BEGIN_DURING_PREDICATION, + D3D11_MESSAGE_ID_QUERY_BEGIN_DUPLICATE, + D3D11_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS, + D3D11_MESSAGE_ID_PREDICATE_END_DURING_PREDICATION, + D3D11_MESSAGE_ID_QUERY_END_ABANDONING_PREVIOUS_RESULTS, + D3D11_MESSAGE_ID_QUERY_END_WITHOUT_BEGIN, + D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_DATASIZE, + D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_FLAGS, + D3D11_MESSAGE_ID_QUERY_GETDATA_INVALID_CALL, + D3D11_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN, + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE, + D3D11_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT, + D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH, + D3D11_MESSAGE_ID_LIVE_OBJECT_SUMMARY, + D3D11_MESSAGE_ID_LIVE_BUFFER, + D3D11_MESSAGE_ID_LIVE_TEXTURE1D, + D3D11_MESSAGE_ID_LIVE_TEXTURE2D, + D3D11_MESSAGE_ID_LIVE_TEXTURE3D, + D3D11_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW, + D3D11_MESSAGE_ID_LIVE_RENDERTARGETVIEW, + D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW, + D3D11_MESSAGE_ID_LIVE_VERTEXSHADER, + D3D11_MESSAGE_ID_LIVE_GEOMETRYSHADER, + D3D11_MESSAGE_ID_LIVE_PIXELSHADER, + D3D11_MESSAGE_ID_LIVE_INPUTLAYOUT, + D3D11_MESSAGE_ID_LIVE_SAMPLER, + D3D11_MESSAGE_ID_LIVE_BLENDSTATE, + D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE, + D3D11_MESSAGE_ID_LIVE_RASTERIZERSTATE, + D3D11_MESSAGE_ID_LIVE_QUERY, + D3D11_MESSAGE_ID_LIVE_PREDICATE, + D3D11_MESSAGE_ID_LIVE_COUNTER, + D3D11_MESSAGE_ID_LIVE_DEVICE, + D3D11_MESSAGE_ID_LIVE_SWAPCHAIN, + D3D11_MESSAGE_ID_D3D10_MESSAGES_END, + + D3D11_MESSAGE_ID_D3D10L9_MESSAGES_START = 0x00100000, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_STENCIL_NO_TWO_SIDED, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_DepthBiasClamp_NOT_SUPPORTED, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NO_COMPARISON_SUPPORT, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_EXCESSIVE_ANISOTROPY, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_OUT_OF_RANGE, + D3D11_MESSAGE_ID_VSSETSAMPLERS_NOT_SUPPORTED, + D3D11_MESSAGE_ID_VSSETSAMPLERS_TOO_MANY_SAMPLERS, + D3D11_MESSAGE_ID_PSSETSAMPLERS_TOO_MANY_SAMPLERS, + D3D11_MESSAGE_ID_CREATERESOURCE_NO_ARRAYS, + D3D11_MESSAGE_ID_CREATERESOURCE_NO_VB_AND_IB_BIND, + D3D11_MESSAGE_ID_CREATERESOURCE_NO_TEXTURE_1D, + D3D11_MESSAGE_ID_CREATERESOURCE_DIMENSION_OUT_OF_RANGE, + D3D11_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_SHADER_RESOURCE, + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_TOO_MANY_RENDER_TARGETS, + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_NO_DIFFERING_BIT_DEPTHS, + D3D11_MESSAGE_ID_IASETVERTEXBUFFERS_BAD_BUFFER_INDEX, + D3D11_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_TOO_MANY_VIEWPORTS, + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_ADJACENCY_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_TOO_MANY_SCISSORS, + D3D11_MESSAGE_ID_COPYRESOURCE_ONLY_TEXTURE_2D_WITHIN_GPU_MEMORY, + D3D11_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_3D_READBACK, + D3D11_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_ONLY_READBACK, + D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_UNSUPPORTED_FORMAT, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_ALPHA_TO_COVERAGE, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_DepthClipEnable_MUST_BE_TRUE, + D3D11_MESSAGE_ID_DRAWINDEXED_STARTINDEXLOCATION_MUST_BE_POSITIVE, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_MUST_USE_LOWEST_LOD, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_MINLOD_MUST_NOT_BE_FRACTIONAL, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_MAXLOD_MUST_BE_FLT_MAX, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_FIRSTARRAYSLICE_MUST_BE_ZERO, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_CUBES_MUST_HAVE_6_SIDES, + D3D11_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_RENDER_TARGET, + D3D11_MESSAGE_ID_CREATERESOURCE_NO_DWORD_INDEX_BUFFER, + D3D11_MESSAGE_ID_CREATERESOURCE_MSAA_PRECLUDES_SHADER_RESOURCE, + D3D11_MESSAGE_ID_CREATERESOURCE_PRESENTATION_PRECLUDES_SHADER_RESOURCE, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_BLEND_ENABLE, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_WRITE_MASKS, + D3D11_MESSAGE_ID_CREATERESOURCE_NO_STREAM_OUT, + D3D11_MESSAGE_ID_CREATERESOURCE_ONLY_VB_IB_FOR_BUFFERS, + D3D11_MESSAGE_ID_CREATERESOURCE_NO_AUTOGEN_FOR_VOLUMES, + D3D11_MESSAGE_ID_CREATERESOURCE_DXGI_FORMAT_R8G8B8A8_CANNOT_BE_SHARED, + D3D11_MESSAGE_ID_VSSHADERRESOURCES_NOT_SUPPORTED, + D3D11_MESSAGE_ID_GEOMETRY_SHADER_NOT_SUPPORTED, + D3D11_MESSAGE_ID_STREAM_OUT_NOT_SUPPORTED, + D3D11_MESSAGE_ID_TEXT_FILTER_NOT_SUPPORTED, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_SEPARATE_ALPHA_BLEND, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_NO_MRT_BLEND, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_OPERATION_NOT_SUPPORTED, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_NO_MIRRORONCE, + D3D11_MESSAGE_ID_DRAWINSTANCED_NOT_SUPPORTED, + D3D11_MESSAGE_ID_DRAWINDEXEDINSTANCED_NOT_SUPPORTED_BELOW_9_3, + D3D11_MESSAGE_ID_DRAWINDEXED_POINTLIST_UNSUPPORTED, + D3D11_MESSAGE_ID_SETBLENDSTATE_SAMPLE_MASK_CANNOT_BE_ZERO, + D3D11_MESSAGE_ID_CREATERESOURCE_DIMENSION_EXCEEDS_FEATURE_LEVEL_DEFINITION, + D3D11_MESSAGE_ID_CREATERESOURCE_ONLY_SINGLE_MIP_LEVEL_DEPTH_STENCIL_SUPPORTED, + D3D11_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_NEGATIVESCISSOR, + D3D11_MESSAGE_ID_SLOT_ZERO_MUST_BE_D3D10_INPUT_PER_VERTEX_DATA, + D3D11_MESSAGE_ID_CREATERESOURCE_NON_POW_2_MIPMAP, + D3D11_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_NOT_SUPPORTED, + D3D11_MESSAGE_ID_OMSETRENDERTARGETS_NO_SRGB_MRT, + D3D11_MESSAGE_ID_COPYRESOURCE_NO_3D_MISMATCHED_UPDATES, + D3D11_MESSAGE_ID_D3D10L9_MESSAGES_END, + + D3D11_MESSAGE_ID_D3D11_MESSAGES_START = 0x00200000, + D3D11_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS, + D3D11_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALID_COMMANDLISTFLAGS, + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_SINGLETHREADED, + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_INVALID_CALL_RETURN, + D3D11_MESSAGE_ID_CREATEDEFERREDCONTEXT_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_FINISHDISPLAYLIST_ONIMMEDIATECONTEXT, + D3D11_MESSAGE_ID_FINISHDISPLAYLIST_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_FINISHDISPLAYLIST_INVALID_CALL_RETURN, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES, + D3D11_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES, + D3D11_MESSAGE_ID_DEVICE_HSSETSHADERRESOURCES_HAZARD, + D3D11_MESSAGE_ID_DEVICE_HSSETCONSTANTBUFFERS_HAZARD, + D3D11_MESSAGE_ID_HSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL, + D3D11_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_DEVICE_HSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_HSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_HSSETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_HSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_HSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_HSGETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_DSSETSHADERRESOURCES_HAZARD, + D3D11_MESSAGE_ID_DEVICE_DSSETCONSTANTBUFFERS_HAZARD, + D3D11_MESSAGE_ID_DSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL, + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_DEVICE_DSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_DSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_DSSETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_DSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_DSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_DSGETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH, + D3D11_MESSAGE_ID_DEFERRED_CONTEXT_REMOVAL_PROCESS_AT_FAULT, + D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER, + D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW, + D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE, + D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS, + D3D11_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED, + D3D11_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN, + D3D11_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD, + D3D11_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE, + D3D11_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED, + D3D11_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS, + D3D11_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH, + D3D11_MESSAGE_ID_CREATE_CONTEXT, + D3D11_MESSAGE_ID_LIVE_CONTEXT, + D3D11_MESSAGE_ID_DESTROY_CONTEXT, + D3D11_MESSAGE_ID_CREATE_BUFFER, + D3D11_MESSAGE_ID_LIVE_BUFFER_WIN7, + D3D11_MESSAGE_ID_DESTROY_BUFFER, + D3D11_MESSAGE_ID_CREATE_TEXTURE1D, + D3D11_MESSAGE_ID_LIVE_TEXTURE1D_WIN7, + D3D11_MESSAGE_ID_DESTROY_TEXTURE1D, + D3D11_MESSAGE_ID_CREATE_TEXTURE2D, + D3D11_MESSAGE_ID_LIVE_TEXTURE2D_WIN7, + D3D11_MESSAGE_ID_DESTROY_TEXTURE2D, + D3D11_MESSAGE_ID_CREATE_TEXTURE3D, + D3D11_MESSAGE_ID_LIVE_TEXTURE3D_WIN7, + D3D11_MESSAGE_ID_DESTROY_TEXTURE3D, + D3D11_MESSAGE_ID_CREATE_SHADERRESOURCEVIEW, + D3D11_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW_WIN7, + D3D11_MESSAGE_ID_DESTROY_SHADERRESOURCEVIEW, + D3D11_MESSAGE_ID_CREATE_RENDERTARGETVIEW, + D3D11_MESSAGE_ID_LIVE_RENDERTARGETVIEW_WIN7, + D3D11_MESSAGE_ID_DESTROY_RENDERTARGETVIEW, + D3D11_MESSAGE_ID_CREATE_DEPTHSTENCILVIEW, + D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW_WIN7, + D3D11_MESSAGE_ID_DESTROY_DEPTHSTENCILVIEW, + D3D11_MESSAGE_ID_CREATE_VERTEXSHADER, + D3D11_MESSAGE_ID_LIVE_VERTEXSHADER_WIN7, + D3D11_MESSAGE_ID_DESTROY_VERTEXSHADER, + D3D11_MESSAGE_ID_CREATE_HULLSHADER, + D3D11_MESSAGE_ID_LIVE_HULLSHADER, + D3D11_MESSAGE_ID_DESTROY_HULLSHADER, + D3D11_MESSAGE_ID_CREATE_DOMAINSHADER, + D3D11_MESSAGE_ID_LIVE_DOMAINSHADER, + D3D11_MESSAGE_ID_DESTROY_DOMAINSHADER, + D3D11_MESSAGE_ID_CREATE_GEOMETRYSHADER, + D3D11_MESSAGE_ID_LIVE_GEOMETRYSHADER_WIN7, + D3D11_MESSAGE_ID_DESTROY_GEOMETRYSHADER, + D3D11_MESSAGE_ID_CREATE_PIXELSHADER, + D3D11_MESSAGE_ID_LIVE_PIXELSHADER_WIN7, + D3D11_MESSAGE_ID_DESTROY_PIXELSHADER, + D3D11_MESSAGE_ID_CREATE_INPUTLAYOUT, + D3D11_MESSAGE_ID_LIVE_INPUTLAYOUT_WIN7, + D3D11_MESSAGE_ID_DESTROY_INPUTLAYOUT, + D3D11_MESSAGE_ID_CREATE_SAMPLER, + D3D11_MESSAGE_ID_LIVE_SAMPLER_WIN7, + D3D11_MESSAGE_ID_DESTROY_SAMPLER, + D3D11_MESSAGE_ID_CREATE_BLENDSTATE, + D3D11_MESSAGE_ID_LIVE_BLENDSTATE_WIN7, + D3D11_MESSAGE_ID_DESTROY_BLENDSTATE, + D3D11_MESSAGE_ID_CREATE_DEPTHSTENCILSTATE, + D3D11_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE_WIN7, + D3D11_MESSAGE_ID_DESTROY_DEPTHSTENCILSTATE, + D3D11_MESSAGE_ID_CREATE_RASTERIZERSTATE, + D3D11_MESSAGE_ID_LIVE_RASTERIZERSTATE_WIN7, + D3D11_MESSAGE_ID_DESTROY_RASTERIZERSTATE, + D3D11_MESSAGE_ID_CREATE_QUERY, + D3D11_MESSAGE_ID_LIVE_QUERY_WIN7, + D3D11_MESSAGE_ID_DESTROY_QUERY, + D3D11_MESSAGE_ID_CREATE_PREDICATE, + D3D11_MESSAGE_ID_LIVE_PREDICATE_WIN7, + D3D11_MESSAGE_ID_DESTROY_PREDICATE, + D3D11_MESSAGE_ID_CREATE_COUNTER, + D3D11_MESSAGE_ID_DESTROY_COUNTER, + D3D11_MESSAGE_ID_CREATE_COMMANDLIST, + D3D11_MESSAGE_ID_LIVE_COMMANDLIST, + D3D11_MESSAGE_ID_DESTROY_COMMANDLIST, + D3D11_MESSAGE_ID_CREATE_CLASSINSTANCE, + D3D11_MESSAGE_ID_LIVE_CLASSINSTANCE, + D3D11_MESSAGE_ID_DESTROY_CLASSINSTANCE, + D3D11_MESSAGE_ID_CREATE_CLASSLINKAGE, + D3D11_MESSAGE_ID_LIVE_CLASSLINKAGE, + D3D11_MESSAGE_ID_DESTROY_CLASSLINKAGE, + D3D11_MESSAGE_ID_LIVE_DEVICE_WIN7, + D3D11_MESSAGE_ID_LIVE_OBJECT_SUMMARY_WIN7, + D3D11_MESSAGE_ID_CREATE_COMPUTESHADER, + D3D11_MESSAGE_ID_LIVE_COMPUTESHADER, + D3D11_MESSAGE_ID_DESTROY_COMPUTESHADER, + D3D11_MESSAGE_ID_CREATE_UNORDEREDACCESSVIEW, + D3D11_MESSAGE_ID_LIVE_UNORDEREDACCESSVIEW, + D3D11_MESSAGE_ID_DESTROY_UNORDEREDACCESSVIEW, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INTERFACES_FEATURELEVEL, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INTERFACE_COUNT_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_INDEX, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_TYPE, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INVALID_INSTANCE_DATA, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_UNBOUND_INSTANCE_DATA, + D3D11_MESSAGE_ID_DEVICE_SETSHADER_INSTANCE_DATA_BINDINGS, + D3D11_MESSAGE_ID_DEVICE_CREATESHADER_CLASSLINKAGE_FULL, + D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE, + D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE, + D3D11_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_HAZARD, + D3D11_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_HAZARD, + D3D11_MESSAGE_ID_CSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL, + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY, + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE, + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERTYPE, + D3D11_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE, + D3D11_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D11_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED, + D3D11_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_HAZARD, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP, + D3D11_MESSAGE_ID_CSSETUNORDEREDACCESSVIEWS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_PSSETUNORDEREDACCESSVIEWS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_HAZARD, + D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH, + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY, + D3D11_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS, + D3D11_MESSAGE_ID_CREATESHADERRESESOURCEVIEW_TOOMANYOBJECTS, + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER, + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED, + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDCONTEXT, + D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDRESOURCE, + D3D11_MESSAGE_ID_DEVICE_SETRESOURCEMINLOD_INVALIDMINLOD, + D3D11_MESSAGE_ID_DEVICE_GETRESOURCEMINLOD_INVALIDCONTEXT, + D3D11_MESSAGE_ID_DEVICE_GETRESOURCEMINLOD_INVALIDRESOURCE, + D3D11_MESSAGE_ID_OMSETDEPTHSTENCIL_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY, + D3D11_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY, + D3D11_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED, + D3D11_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW, + D3D11_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO, + D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH, + D3D11_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED, + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET, + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET, + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE, + D3D11_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE, + D3D11_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_INVALIDVIEW, + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_INVALIDOFFSET, + D3D11_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSVIEWS_TOOMANYVIEWS, + D3D11_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED, + D3D11_MESSAGE_ID_REF_WARNING, + D3D11_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV, + D3D11_MESSAGE_ID_SHADER_ABORT, + D3D11_MESSAGE_ID_SHADER_MESSAGE, + D3D11_MESSAGE_ID_SHADER_ERROR, + D3D11_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE, + D3D11_MESSAGE_ID_HSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_DSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_HSSETSHADER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_DSSETSHADER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_CSSETSHADER_UNBINDDELETINGOBJECT, + D3D11_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN, + D3D11_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NUMUAVS_INVALIDRANGE, + D3D11_MESSAGE_ID_D3D11_MESSAGES_END, + + D3D11_MESSAGE_ID_D3D11_1_MESSAGES_START = 0x00300000, + D3D11_MESSAGE_ID_CREATE_VIDEODECODER, + D3D11_MESSAGE_ID_CREATE_VIDEOPROCESSORENUM, + D3D11_MESSAGE_ID_CREATE_VIDEOPROCESSOR, + D3D11_MESSAGE_ID_CREATE_DECODEROUTPUTVIEW, + D3D11_MESSAGE_ID_CREATE_PROCESSORINPUTVIEW, + D3D11_MESSAGE_ID_CREATE_PROCESSOROUTPUTVIEW, + D3D11_MESSAGE_ID_CREATE_DEVICECONTEXTSTATE, + D3D11_MESSAGE_ID_LIVE_VIDEODECODER, + D3D11_MESSAGE_ID_LIVE_VIDEOPROCESSORENUM, + D3D11_MESSAGE_ID_LIVE_VIDEOPROCESSOR, + D3D11_MESSAGE_ID_LIVE_DECODEROUTPUTVIEW, + D3D11_MESSAGE_ID_LIVE_PROCESSORINPUTVIEW, + D3D11_MESSAGE_ID_LIVE_PROCESSOROUTPUTVIEW, + D3D11_MESSAGE_ID_LIVE_DEVICECONTEXTSTATE, + D3D11_MESSAGE_ID_DESTROY_VIDEODECODER, + D3D11_MESSAGE_ID_DESTROY_VIDEOPROCESSORENUM, + D3D11_MESSAGE_ID_DESTROY_VIDEOPROCESSOR, + D3D11_MESSAGE_ID_DESTROY_DECODEROUTPUTVIEW, + D3D11_MESSAGE_ID_DESTROY_PROCESSORINPUTVIEW, + D3D11_MESSAGE_ID_DESTROY_PROCESSOROUTPUTVIEW, + D3D11_MESSAGE_ID_DESTROY_DEVICECONTEXTSTATE, + D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_INVALIDFLAGS, + D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_INVALIDFEATURELEVEL, + D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_FEATURELEVELS_NOT_SUPPORTED, + D3D11_MESSAGE_ID_CREATEDEVICECONTEXTSTATE_INVALIDREFIID, + D3D11_MESSAGE_ID_DEVICE_DISCARDVIEW_INVALIDVIEW, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION1_INVALIDCOPYFLAGS, + D3D11_MESSAGE_ID_UPDATESUBRESOURCE1_INVALIDCOPYFLAGS, + D3D11_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT, + D3D11_MESSAGE_ID_CREATEVIDEODECODER_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEVIDEODECODER_NULLPARAM, + D3D11_MESSAGE_ID_CREATEVIDEODECODER_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATEVIDEODECODER_ZEROWIDTHHEIGHT, + D3D11_MESSAGE_ID_CREATEVIDEODECODER_DRIVER_INVALIDBUFFERSIZE, + D3D11_MESSAGE_ID_CREATEVIDEODECODER_DRIVER_INVALIDBUFFERUSAGE, + D3D11_MESSAGE_ID_GETVIDEODECODERPROFILECOUNT_OUTOFMEMORY, + D3D11_MESSAGE_ID_GETVIDEODECODERPROFILE_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEODECODERPROFILE_INVALIDINDEX, + D3D11_MESSAGE_ID_GETVIDEODECODERPROFILE_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CHECKVIDEODECODERFORMAT_NULLPARAM, + D3D11_MESSAGE_ID_CHECKVIDEODECODERFORMAT_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_GETVIDEODECODERCONFIGCOUNT_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEODECODERCONFIGCOUNT_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_GETVIDEODECODERCONFIG_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEODECODERCONFIG_INVALIDINDEX, + D3D11_MESSAGE_ID_GETVIDEODECODERCONFIG_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_GETDECODERCREATIONPARAMS_NULLPARAM, + D3D11_MESSAGE_ID_GETDECODERDRIVERHANDLE_NULLPARAM, + D3D11_MESSAGE_ID_GETDECODERBUFFER_NULLPARAM, + D3D11_MESSAGE_ID_GETDECODERBUFFER_INVALIDBUFFER, + D3D11_MESSAGE_ID_GETDECODERBUFFER_INVALIDTYPE, + D3D11_MESSAGE_ID_GETDECODERBUFFER_LOCKED, + D3D11_MESSAGE_ID_RELEASEDECODERBUFFER_NULLPARAM, + D3D11_MESSAGE_ID_RELEASEDECODERBUFFER_INVALIDTYPE, + D3D11_MESSAGE_ID_RELEASEDECODERBUFFER_NOTLOCKED, + D3D11_MESSAGE_ID_DECODERBEGINFRAME_NULLPARAM, + D3D11_MESSAGE_ID_DECODERBEGINFRAME_HAZARD, + D3D11_MESSAGE_ID_DECODERENDFRAME_NULLPARAM, + D3D11_MESSAGE_ID_SUBMITDECODERBUFFERS_NULLPARAM, + D3D11_MESSAGE_ID_SUBMITDECODERBUFFERS_INVALIDTYPE, + D3D11_MESSAGE_ID_DECODEREXTENSION_NULLPARAM, + D3D11_MESSAGE_ID_DECODEREXTENSION_INVALIDRESOURCE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_NULLPARAM, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDFRAMEFORMAT, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDUSAGE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDINPUTFRAMERATE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDOUTPUTFRAMERATE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORENUMERATOR_INVALIDWIDTHHEIGHT, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORCONTENTDESC_NULLPARAM, + D3D11_MESSAGE_ID_CHECKVIDEOPROCESSORFORMAT_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORCAPS_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORRATECONVERSIONCAPS_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORRATECONVERSIONCAPS_INVALIDINDEX, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORCUSTOMRATE_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORCUSTOMRATE_INVALIDINDEX, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORFILTERRANGE_NULLPARAM, + D3D11_MESSAGE_ID_GETVIDEOPROCESSORFILTERRANGE_UNSUPPORTED, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOR_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOR_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTTARGETRECT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTBACKGROUNDCOLOR_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTBACKGROUNDCOLOR_INVALIDALPHA, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTALPHAFILLMODE_INVALIDFILLMODE, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCONSTRICTION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSTEREOMODE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSTEREOMODE_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTEXTENSION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTTARGETRECT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTBACKGROUNDCOLOR_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTALPHAFILLMODE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCONSTRICTION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCONSTRICTION_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCONSTRICTION_INVALIDSIZE, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSTEREOMODE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTEXTENSION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFRAMEFORMAT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFRAMEFORMAT_INVALIDFORMAT, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFRAMEFORMAT_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_INVALIDRATE, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_INVALIDFLAG, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMOUTPUTRATE_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSOURCERECT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSOURCERECT_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSOURCERECT_INVALIDRECT, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMDESTRECT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMDESTRECT_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMDESTRECT_INVALIDRECT, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_INVALIDALPHA, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_INVALIDCOUNT, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPALETTE_INVALIDALPHA, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_INVALIDRATIO, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_INVALIDRANGE, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMLUMAKEY_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_FLIPUNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_MONOOFFSETUNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_FORMATUNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMSTEREOFORMAT_INVALIDFORMAT, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMAUTOPROCESSINGMODE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMAUTOPROCESSINGMODE_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_INVALIDFILTER, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMFILTER_INVALIDLEVEL, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMEXTENSION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMEXTENSION_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMFRAMEFORMAT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMOUTPUTRATE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMSOURCERECT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMDESTRECT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMALPHA_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMPALETTE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMPIXELASPECTRATIO_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMLUMAKEY_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMSTEREOFORMAT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMAUTOPROCESSINGMODE_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMFILTER_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMEXTENSION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMEXTENSION_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDSTREAMCOUNT, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_TARGETRECT, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDOUTPUT, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDPASTFRAMES, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDFUTUREFRAMES, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDSOURCERECT, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDDESTRECT, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDINPUTRESOURCE, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDARRAYSIZE, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDARRAY, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_RIGHTEXPECTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_RIGHTNOTEXPECTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_STEREONOTENABLED, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INVALIDRIGHTRESOURCE, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_NOSTEREOSTREAMS, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_INPUTHAZARD, + D3D11_MESSAGE_ID_VIDEOPROCESSORBLT_OUTPUTHAZARD, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_NULLPARAM, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDTYPE, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDBIND, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_UNSUPPORTEDFORMAT, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDMIP, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_UNSUPPORTEMIP, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDARRAYSIZE, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDARRAY, + D3D11_MESSAGE_ID_CREATEVIDEODECODEROUTPUTVIEW_INVALIDDIMENSION, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_NULLPARAM, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDTYPE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDBIND, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMISC, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDUSAGE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDFOURCC, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMIP, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_UNSUPPORTEDMIP, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDARRAYSIZE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDARRAY, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDDIMENSION, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_NULLPARAM, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDTYPE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDBIND, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDFORMAT, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMIP, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_UNSUPPORTEDMIP, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_UNSUPPORTEDARRAY, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDARRAY, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDDIMENSION, + D3D11_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT, + D3D11_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS, + D3D11_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDARRAYWITHDECODER, + D3D11_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDARRAYWITHDECODER, + D3D11_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDARRAYWITHDECODER, + D3D11_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE, + D3D11_MESSAGE_ID_REF_WARNING_ATOMIC_INCONSISTENT, + D3D11_MESSAGE_ID_REF_WARNING_READING_UNINITIALIZED_RESOURCE, + D3D11_MESSAGE_ID_REF_WARNING_RAW_HAZARD, + D3D11_MESSAGE_ID_REF_WARNING_WAR_HAZARD, + D3D11_MESSAGE_ID_REF_WARNING_WAW_HAZARD, + D3D11_MESSAGE_ID_CREATECRYPTOSESSION_NULLPARAM, + D3D11_MESSAGE_ID_CREATECRYPTOSESSION_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_GETCRYPTOTYPE_NULLPARAM, + D3D11_MESSAGE_ID_GETDECODERPROFILE_NULLPARAM, + D3D11_MESSAGE_ID_GETCRYPTOSESSIONCERTIFICATESIZE_NULLPARAM, + D3D11_MESSAGE_ID_GETCRYPTOSESSIONCERTIFICATE_NULLPARAM, + D3D11_MESSAGE_ID_GETCRYPTOSESSIONCERTIFICATE_WRONGSIZE, + D3D11_MESSAGE_ID_GETCRYPTOSESSIONHANDLE_WRONGSIZE, + D3D11_MESSAGE_ID_NEGOTIATECRPYTOSESSIONKEYEXCHANGE_NULLPARAM, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_UNSUPPORTED, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_NULLPARAM, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_WRONGDEVICE, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_WRONGDEVICE, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_FORMAT_MISMATCH, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_SIZE_MISMATCH, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_MULTISAMPLED, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_NOT_STAGING, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_MAPPED, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_MAPPED, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_OFFERED, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_DST_OFFERED, + D3D11_MESSAGE_ID_ENCRYPTIONBLT_SRC_CONTENT_UNDEFINED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_UNSUPPORTED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_NULLPARAM, + D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_WRONGDEVICE, + D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_WRONGDEVICE, + D3D11_MESSAGE_ID_DECRYPTIONBLT_FORMAT_MISMATCH, + D3D11_MESSAGE_ID_DECRYPTIONBLT_SIZE_MISMATCH, + D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_MULTISAMPLED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_NOT_STAGING, + D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_NOT_RENDER_TARGET, + D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_MAPPED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_MAPPED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_OFFERED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_DST_OFFERED, + D3D11_MESSAGE_ID_DECRYPTIONBLT_SRC_CONTENT_UNDEFINED, + D3D11_MESSAGE_ID_STARTSESSIONKEYREFRESH_NULLPARAM, + D3D11_MESSAGE_ID_STARTSESSIONKEYREFRESH_INVALIDSIZE, + D3D11_MESSAGE_ID_FINISHSESSIONKEYREFRESH_NULLPARAM, + D3D11_MESSAGE_ID_GETENCRYPTIONBLTKEY_NULLPARAM, + D3D11_MESSAGE_ID_GETENCRYPTIONBLTKEY_INVALIDSIZE, + D3D11_MESSAGE_ID_GETCONTENTPROTECTIONCAPS_NULLPARAM, + D3D11_MESSAGE_ID_CHECKCRYPTOKEYEXCHANGE_NULLPARAM, + D3D11_MESSAGE_ID_CHECKCRYPTOKEYEXCHANGE_INVALIDINDEX, + D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_NULLPARAM, + D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_UNSUPPORTED, + D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_INVALIDTYPE, + D3D11_MESSAGE_ID_CREATEAUTHENTICATEDCHANNEL_OUTOFMEMORY_RETURN, + D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATESIZE_INVALIDCHANNEL, + D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATESIZE_NULLPARAM, + D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATE_INVALIDCHANNEL, + D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATE_NULLPARAM, + D3D11_MESSAGE_ID_GETAUTHENTICATEDCHANNELCERTIFICATE_WRONGSIZE, + D3D11_MESSAGE_ID_NEGOTIATEAUTHENTICATEDCHANNELKEYEXCHANGE_INVALIDCHANNEL, + D3D11_MESSAGE_ID_NEGOTIATEAUTHENTICATEDCHANNELKEYEXCHANGE_NULLPARAM, + D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_NULLPARAM, + D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_WRONGCHANNEL, + D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_UNSUPPORTEDQUERY, + D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_WRONGSIZE, + D3D11_MESSAGE_ID_QUERYAUTHENTICATEDCHANNEL_INVALIDPROCESSINDEX, + D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_NULLPARAM, + D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_WRONGCHANNEL, + D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_UNSUPPORTEDCONFIGURE, + D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_WRONGSIZE, + D3D11_MESSAGE_ID_CONFIGUREAUTHENTICATEDCHANNEL_INVALIDPROCESSIDTYPE, + D3D11_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT, + D3D11_MESSAGE_ID_DSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT, + D3D11_MESSAGE_ID_HSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT, + D3D11_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT, + D3D11_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT, + D3D11_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFEROFFSETORCOUNT, + D3D11_MESSAGE_ID_NEGOTIATECRPYTOSESSIONKEYEXCHANGE_INVALIDSIZE, + D3D11_MESSAGE_ID_NEGOTIATEAUTHENTICATEDCHANNELKEYEXCHANGE_INVALIDSIZE, + D3D11_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY, + D3D11_MESSAGE_ID_GETCRYPTOSESSIONHANDLE_OUTOFMEMORY, + D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_NULLPARAM, + D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_INVALIDTYPE, + D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_INVALIDBIND, + D3D11_MESSAGE_ID_ACQUIREHANDLEFORCAPTURE_INVALIDARRAY, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_NULLPARAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_INVALIDSTREAM, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_INVALID, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMROTATION_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORGETSTREAMROTATION_NULLPARAM, + D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW, + D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMALPHA_UNSUPPORTED, + D3D11_MESSAGE_ID_VIDEOPROCESSORSETSTREAMPIXELASPECTRATIO_UNSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET, + D3D11_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS, + D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED, + D3D11_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED, + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1, + D3D11_MESSAGE_ID_GETDC_INACCESSIBLE, + D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT, + D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9, + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED, + D3D11_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED, + D3D11_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED, + D3D11_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED, + D3D11_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA, + D3D11_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA, + D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT, + D3D11_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT, + D3D11_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX, + D3D11_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX, + D3D11_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS, + D3D11_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET, + D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT, + D3D11_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT, + D3D11_MESSAGE_ID_D3D11_1_MESSAGES_END +} D3D11_MESSAGE_ID; + +typedef enum D3D11_RLDO_FLAGS { + D3D11_RLDO_SUMMARY = 1, + D3D11_RLDO_DETAIL = 2 +} D3D11_RLDO_FLAGS; + +typedef struct D3D11_MESSAGE { + D3D11_MESSAGE_CATEGORY Category; + D3D11_MESSAGE_SEVERITY Severity; + D3D11_MESSAGE_ID ID; + const char *pDescription; + SIZE_T DescriptionByteLength; +} D3D11_MESSAGE; + +typedef struct D3D11_INFO_QUEUE_FILTER_DESC { + UINT NumCategories; + D3D11_MESSAGE_CATEGORY *pCategoryList; + UINT NumSeverities; + D3D11_MESSAGE_SEVERITY *pSeverityList; + UINT NumIDs; + D3D11_MESSAGE_ID *pIDList; +} D3D11_INFO_QUEUE_FILTER_DESC; + +typedef struct D3D11_INFO_QUEUE_FILTER { + D3D11_INFO_QUEUE_FILTER_DESC AllowList; + D3D11_INFO_QUEUE_FILTER_DESC DenyList; +} D3D11_INFO_QUEUE_FILTER; + +cpp_quote("#define D3D11_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024") + +[ + object, + uuid(79cf2233-7536-4948-9d36-1e4692dc5760), + local, + pointer_default(unique) +] +interface ID3D11Debug : IUnknown { + HRESULT SetFeatureMask(UINT Mask); + UINT GetFeatureMask(); + HRESULT SetPresentPerRenderOpDelay(UINT Milliseconds); + UINT GetPresentPerRenderOpDelay(); + HRESULT SetSwapChain(IDXGISwapChain *pSwapChain); + HRESULT GetSwapChain(IDXGISwapChain **ppSwapChain); + HRESULT ValidateContext(ID3D11DeviceContext *pContext); + HRESULT ReportLiveDeviceObjects(D3D11_RLDO_FLAGS Flags); + HRESULT ValidateContextForDispatch(ID3D11DeviceContext *pContext); +} + +[ + object, + uuid(1ef337e3-58e7-4f83-a692-db221f5ed47e), + local, + pointer_default(unique) +] +interface ID3D11SwitchToRef : IUnknown { + BOOL SetUseRef( + [in] BOOL useref + ); + BOOL GetUseRef(); +} + +[ + object, + uuid(6543dbb6-1b48-42f5-ab82-e97ec74326f6), + local, + pointer_default(unique) +] +interface ID3D11InfoQueue : IUnknown { + HRESULT SetMessageCountLimit(UINT64 MessageCountLimit); + void ClearStoredMessages(); + +cpp_quote("#ifdef WINE_NO_UNICODE_MACROS") +cpp_quote("#undef GetMessage") +cpp_quote("#endif") + HRESULT GetMessage(UINT64 MessageIndex, D3D11_MESSAGE* pMessage, SIZE_T *pMessageByteLength); + + UINT64 GetNumMessagesAllowedByStorageFilter(); + UINT64 GetNumMessagesDeniedByStorageFilter(); + UINT64 GetNumStoredMessages(); + UINT64 GetNumStoredMessagesAllowedByRetrievalFilter(); + UINT64 GetNumMessagesDiscardedByMessageCountLimit(); + UINT64 GetMessageCountLimit(); + HRESULT AddStorageFilterEntries(D3D11_INFO_QUEUE_FILTER *pFilter); + HRESULT GetStorageFilter(D3D11_INFO_QUEUE_FILTER *pFilter, SIZE_T *pFilterByteLength); + void ClearStorageFilter(); + HRESULT PushEmptyStorageFilter(); + HRESULT PushCopyOfStorageFilter(); + HRESULT PushStorageFilter(D3D11_INFO_QUEUE_FILTER *pFilter); + void PopStorageFilter(); + UINT GetStorageFilterStackSize(); + HRESULT AddRetrievalFilterEntries(D3D11_INFO_QUEUE_FILTER *pFilter); + HRESULT GetRetrievalFilter(D3D11_INFO_QUEUE_FILTER *pFilter, SIZE_T *pFilterByteLength); + void ClearRetrievalFilter(); + HRESULT PushEmptyRetrievalFilter(); + HRESULT PushCopyOfRetrievalFilter(); + HRESULT PushRetrievalFilter(D3D11_INFO_QUEUE_FILTER *pFilter); + void PopRetrievalFilter(); + UINT GetRetrievalFilterStackSize(); + HRESULT AddMessage(D3D11_MESSAGE_CATEGORY Category, D3D11_MESSAGE_SEVERITY Severity, + D3D11_MESSAGE_ID ID, LPCSTR pDescription); + HRESULT AddApplicationMessage(D3D11_MESSAGE_SEVERITY Severity, LPCSTR pDescription); + HRESULT SetBreakOnCategory(D3D11_MESSAGE_CATEGORY Category, BOOL bEnable); + HRESULT SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY Severity, BOOL bEnable); + HRESULT SetBreakOnID(D3D11_MESSAGE_ID ID, BOOL bEnable); + BOOL GetBreakOnCategory(D3D11_MESSAGE_CATEGORY Category); + BOOL GetBreakOnSeverity(D3D11_MESSAGE_SEVERITY Severity); + BOOL GetBreakOnID(D3D11_MESSAGE_ID ID); + void SetMuteDebugOutput(BOOL bMute); + BOOL GetMuteDebugOutput(); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d11shader.h b/WineFix/lib/d2d1/include/windows/d3d11shader.h new file mode 100644 index 0000000..236ca02 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d11shader.h @@ -0,0 +1,338 @@ +/* + * Copyright 2010 Matteo Bruni for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3D11SHADER_H__ +#define __D3D11SHADER_H__ + +#include "d3dcommon.h" + +/* If not defined set d3dcompiler_47 by default. */ +#ifndef D3D_COMPILER_VERSION +#define D3D_COMPILER_VERSION 47 +#endif + +#define D3D_SHADER_REQUIRES_DOUBLES 0x00000001 +#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL 0x00000002 +#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE 0x00000004 +#define D3D_SHADER_REQUIRES_64_UAVS 0x00000008 +#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION 0x00000010 +#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS 0x00000020 +#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS 0x00000040 +#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING 0x00000080 +#define D3D_SHADER_REQUIRES_TILED_RESOURCES 0x00000100 + +/* These are defined as version-neutral in d3dcommon.h */ +typedef D3D_CBUFFER_TYPE D3D11_CBUFFER_TYPE; + +typedef D3D_RESOURCE_RETURN_TYPE D3D11_RESOURCE_RETURN_TYPE; + +typedef D3D_TESSELLATOR_DOMAIN D3D11_TESSELLATOR_DOMAIN; + +typedef D3D_TESSELLATOR_PARTITIONING D3D11_TESSELLATOR_PARTITIONING; + +typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D11_TESSELLATOR_OUTPUT_PRIMITIVE; + +typedef struct _D3D11_SHADER_DESC +{ + UINT Version; + const char *Creator; + UINT Flags; + UINT ConstantBuffers; + UINT BoundResources; + UINT InputParameters; + UINT OutputParameters; + UINT InstructionCount; + UINT TempRegisterCount; + UINT TempArrayCount; + UINT DefCount; + UINT DclCount; + UINT TextureNormalInstructions; + UINT TextureLoadInstructions; + UINT TextureCompInstructions; + UINT TextureBiasInstructions; + UINT TextureGradientInstructions; + UINT FloatInstructionCount; + UINT IntInstructionCount; + UINT UintInstructionCount; + UINT StaticFlowControlCount; + UINT DynamicFlowControlCount; + UINT MacroInstructionCount; + UINT ArrayInstructionCount; + UINT CutInstructionCount; + UINT EmitInstructionCount; + D3D_PRIMITIVE_TOPOLOGY GSOutputTopology; + UINT GSMaxOutputVertexCount; + D3D_PRIMITIVE InputPrimitive; + UINT PatchConstantParameters; + UINT cGSInstanceCount; + UINT cControlPoints; + D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive; + D3D_TESSELLATOR_PARTITIONING HSPartitioning; + D3D_TESSELLATOR_DOMAIN TessellatorDomain; + UINT cBarrierInstructions; + UINT cInterlockedInstructions; + UINT cTextureStoreInstructions; +} D3D11_SHADER_DESC; + +typedef struct _D3D11_SHADER_VARIABLE_DESC +{ + const char *Name; + UINT StartOffset; + UINT Size; + UINT uFlags; + void *DefaultValue; + UINT StartTexture; + UINT TextureSize; + UINT StartSampler; + UINT SamplerSize; +} D3D11_SHADER_VARIABLE_DESC; + +typedef struct _D3D11_SHADER_TYPE_DESC +{ + D3D_SHADER_VARIABLE_CLASS Class; + D3D_SHADER_VARIABLE_TYPE Type; + UINT Rows; + UINT Columns; + UINT Elements; + UINT Members; + UINT Offset; + const char *Name; +} D3D11_SHADER_TYPE_DESC; + +typedef struct _D3D11_SHADER_BUFFER_DESC +{ + const char *Name; + D3D_CBUFFER_TYPE Type; + UINT Variables; + UINT Size; + UINT uFlags; +} D3D11_SHADER_BUFFER_DESC; + +typedef struct _D3D11_SHADER_INPUT_BIND_DESC +{ + const char *Name; + D3D_SHADER_INPUT_TYPE Type; + UINT BindPoint; + UINT BindCount; + UINT uFlags; + D3D_RESOURCE_RETURN_TYPE ReturnType; + D3D_SRV_DIMENSION Dimension; + UINT NumSamples; +} D3D11_SHADER_INPUT_BIND_DESC; + +typedef struct _D3D11_SIGNATURE_PARAMETER_DESC +{ + const char *SemanticName; + UINT SemanticIndex; + UINT Register; + D3D_NAME SystemValueType; + D3D_REGISTER_COMPONENT_TYPE ComponentType; + BYTE Mask; + BYTE ReadWriteMask; + UINT Stream; +#if D3D_COMPILER_VERSION >= 46 + D3D_MIN_PRECISION MinPrecision; +#endif +} D3D11_SIGNATURE_PARAMETER_DESC; + +typedef struct _D3D11_PARAMETER_DESC +{ + LPCSTR Name; + LPCSTR SemanticName; + D3D_SHADER_VARIABLE_TYPE Type; + D3D_SHADER_VARIABLE_CLASS Class; + UINT Rows; + UINT Columns; + D3D_INTERPOLATION_MODE InterpolationMode; + D3D_PARAMETER_FLAGS Flags; + UINT FirstInRegister; + UINT FirstInComponent; + UINT FirstOutRegister; + UINT FirstOutComponent; +} D3D11_PARAMETER_DESC; + +DEFINE_GUID(IID_ID3D11ShaderReflectionType, 0x6e6ffa6a, 0x9bae, 0x4613, 0xa5, 0x1e, 0x91, 0x65, 0x2d, 0x50, 0x8c, 0x21); + +#define INTERFACE ID3D11ShaderReflectionType +DECLARE_INTERFACE(ID3D11ShaderReflectionType) +{ + STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_TYPE_DESC *desc) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionType *, GetMemberTypeByIndex)(THIS_ UINT index) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionType *, GetMemberTypeByName)(THIS_ const char *name) PURE; + STDMETHOD_(const char *, GetMemberTypeName)(THIS_ UINT index) PURE; + STDMETHOD(IsEqual)(THIS_ struct ID3D11ShaderReflectionType *type) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionType *, GetSubType)(THIS) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionType *, GetBaseClass)(THIS) PURE; + STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionType *, GetInterfaceByIndex)(THIS_ UINT index) PURE; + STDMETHOD(IsOfType)(THIS_ struct ID3D11ShaderReflectionType *type) PURE; + STDMETHOD(ImplementsInterface)(THIS_ ID3D11ShaderReflectionType *base) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11ShaderReflectionVariable, 0x51f23923, 0xf3e5, 0x4bd1, 0x91, 0xcb, 0x60, 0x61, 0x77, 0xd8, 0xdb, 0x4c); + +#define INTERFACE ID3D11ShaderReflectionVariable +DECLARE_INTERFACE(ID3D11ShaderReflectionVariable) +{ + STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_VARIABLE_DESC *desc) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionType *, GetType)(THIS) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionConstantBuffer *, GetBuffer)(THIS) PURE; + STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ UINT index) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11ShaderReflectionConstantBuffer, 0xeb62d63d, 0x93dd, 0x4318, 0x8a, 0xe8, 0xc6, 0xf8, 0x3a, 0xd3, 0x71, 0xb8); + +#define INTERFACE ID3D11ShaderReflectionConstantBuffer +DECLARE_INTERFACE(ID3D11ShaderReflectionConstantBuffer) +{ + STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_BUFFER_DESC *desc) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionVariable *, GetVariableByIndex)(THIS_ UINT index) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionVariable *, GetVariableByName)(THIS_ const char *name) PURE; +}; +#undef INTERFACE + +#if D3D_COMPILER_VERSION <= 42 +DEFINE_GUID(IID_ID3D11ShaderReflection, 0x17f27486, 0xa342, 0x4d10, 0x88, 0x42, 0xab, 0x08, 0x74, 0xe7, 0xf6, 0x70); +#elif D3D_COMPILER_VERSION == 43 +DEFINE_GUID(IID_ID3D11ShaderReflection, 0x0a233719, 0x3960, 0x4578, 0x9d, 0x7c, 0x20, 0x3b, 0x8b, 0x1d, 0x9c, 0xc1); +#else +DEFINE_GUID(IID_ID3D11ShaderReflection, 0x8d536ca1, 0x0cca, 0x4956, 0xa8, 0x37, 0x78, 0x69, 0x63, 0x75, 0x55, 0x84); +#endif + +#define INTERFACE ID3D11ShaderReflection +DECLARE_INTERFACE_(ID3D11ShaderReflection, IUnknown) +{ + /* IUnknown methods */ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /* ID3D11ShaderReflection methods */ + STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_DESC *desc) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ UINT index) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ const char *name) PURE; + STDMETHOD(GetResourceBindingDesc)(THIS_ UINT index, D3D11_SHADER_INPUT_BIND_DESC *desc) PURE; + STDMETHOD(GetInputParameterDesc)(THIS_ UINT index, D3D11_SIGNATURE_PARAMETER_DESC *desc) PURE; + STDMETHOD(GetOutputParameterDesc)(THIS_ UINT index, D3D11_SIGNATURE_PARAMETER_DESC *desc) PURE; + STDMETHOD(GetPatchConstantParameterDesc)(THIS_ UINT index, D3D11_SIGNATURE_PARAMETER_DESC *desc) PURE; + STDMETHOD_(struct ID3D11ShaderReflectionVariable *, GetVariableByName)(THIS_ const char *name) PURE; + STDMETHOD(GetResourceBindingDescByName)(THIS_ const char *name, D3D11_SHADER_INPUT_BIND_DESC *desc) PURE; + STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE; + STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE; + STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE; + STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE; + STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE; + STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE; + STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE; + STDMETHOD(GetMinFeatureLevel)(THIS_ enum D3D_FEATURE_LEVEL *level) PURE; + STDMETHOD_(UINT, GetThreadGroupSize)(THIS_ UINT *sizex, UINT *sizey, UINT *sizez) PURE; + STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11ModuleInstance, 0x469e07f7, 0x45a, 0x48d5, 0xaa, 0x12, 0x68, 0xa4, 0x78, 0xcd, 0xf7, 0x5d); + +#define INTERFACE ID3D11ModuleInstance +DECLARE_INTERFACE_(ID3D11ModuleInstance, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /* ID3D11ModuleInstance methods */ + STDMETHOD(BindConstantBuffer)(THIS_ UINT srcslot, UINT dstslot, UINT dstoffset) PURE; + STDMETHOD(BindConstantBufferByName)(THIS_ const char *name, UINT dstslot, UINT dstoffset) PURE; + + STDMETHOD(BindResource)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindResourceByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; + + STDMETHOD(BindSampler)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindSamplerByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; + + STDMETHOD(BindUnorderedAccessView)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindUnorderedAccessViewByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; + + STDMETHOD(BindResourceAsUnorderedAccessView)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindResourceAsUnorderedAccessViewByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11Module, 0xcac701ee, 0x80fc, 0x4122, 0x82, 0x42, 0x10, 0xb3, 0x9c, 0x8c, 0xec, 0x34); + +#define INTERFACE ID3D11Module +DECLARE_INTERFACE_(ID3D11Module, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /* ID3D11Module methods */ + STDMETHOD(CreateInstance)(THIS_ const char *instnamespace, ID3D11ModuleInstance **moduleinstance) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11Linker, 0x59a6cd0e, 0xe10d, 0x4c1f, 0x88, 0xc0, 0x63, 0xab, 0xa1, 0xda, 0xf3, 0x0e); + +#define INTERFACE ID3D11Linker +DECLARE_INTERFACE_(ID3D11Linker, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /* ID3D11Linker methods */ + STDMETHOD(Link)(THIS_ ID3D11ModuleInstance *instance, LPCSTR instname, LPCSTR targetname, UINT flags, ID3DBlob **shader, ID3DBlob **error) PURE; + STDMETHOD(UseLibrary)(THIS_ ID3D11ModuleInstance *libinstance) PURE; + STDMETHOD(AddClipPlaneFromCBuffer)(THIS_ UINT bufferslot, UINT bufferentry) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11LinkingNode, 0xd80dd70c, 0x8d2f, 0x4751, 0x94, 0xa1, 0x3, 0xc7, 0x9b, 0x35, 0x56, 0xdb); + +#define INTERFACE ID3D11LinkingNode +DECLARE_INTERFACE_(ID3D11LinkingNode, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11FunctionLinkingGraph, 0x54133220, 0x1ce8, 0x43d3, 0x82, 0x36, 0x98, 0x55, 0xc5, 0xce, 0xec, 0xff); + +#define INTERFACE ID3D11FunctionLinkingGraph +DECLARE_INTERFACE_(ID3D11FunctionLinkingGraph, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /* ID3D11FunctionLinkingGraph methods */ + STDMETHOD(CreateModuleInstance)(THIS_ ID3D11ModuleInstance **instance, ID3DBlob **error) PURE; + STDMETHOD(SetInputSignature)(THIS_ const D3D11_PARAMETER_DESC *parameter_desc, UINT parameter_count, ID3D11LinkingNode **input_node) PURE; + STDMETHOD(SetOutputSignature)(THIS_ const D3D11_PARAMETER_DESC *parameter_desc, UINT parameter_count, ID3D11LinkingNode **output_node) PURE; + STDMETHOD(CallFunction)(THIS_ LPCSTR _namespace, ID3D11Module *module, LPCSTR function_name, ID3D11LinkingNode **call_node) PURE; + STDMETHOD(PassValue)(THIS_ ID3D11LinkingNode *src_node, INT src_parameter_index, ID3D11LinkingNode *dst_node, INT dst_parameter_index) PURE; + STDMETHOD(PassValueWithSwizzle)(THIS_ ID3D11LinkingNode *src_node, INT src_parameter_index, LPCSTR src_swizzle, ID3D11LinkingNode *dst_node, INT dst_parameter_index,LPCSTR dst_swizzle) PURE; + STDMETHOD(GetLastError)(THIS_ ID3DBlob **error) PURE; + STDMETHOD(GenerateHlsl)(THIS_ UINT flags, ID3DBlob **buffer) PURE; +}; +#undef INTERFACE + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3d12.idl b/WineFix/lib/d2d1/include/windows/d3d12.idl new file mode 100644 index 0000000..d7b283a --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d12.idl @@ -0,0 +1,5170 @@ +/* + * Copyright 2016 Józef Kucia for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi.idl"; +import "d3dcommon.idl"; + +cpp_quote("#ifndef _D3D12_CONSTANTS") +cpp_quote("#define _D3D12_CONSTANTS") + +const UINT D3D12_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff; +const UINT D3D12_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff; +const UINT D3D12_8BIT_INDEX_STRIP_CUT_VALUE = 0xff; +const UINT D3D12_APPEND_ALIGNED_ELEMENT = 0xffffffff; +const UINT D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; +const UINT D3D12_CLIP_OR_CULL_DISTANCE_COUNT = 8; +const UINT D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const UINT D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; +const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; +const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const UINT D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; +const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; +const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; +const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; +const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; +const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; +const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; +const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; +const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; +const UINT D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; +const UINT D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; +const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; +const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; +const UINT D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; +const UINT D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; +const UINT D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; +const INT D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; +const INT D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; +const UINT D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; +const UINT D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = 256; +const UINT D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256; +const UINT D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64; +const UINT D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240; +const UINT D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68; +const UINT D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224; +const UINT D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72; +const UINT D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208; +const UINT D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76; +const UINT D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192; +const UINT D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84; +const UINT D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176; +const UINT D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92; +const UINT D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160; +const UINT D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100; +const UINT D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144; +const UINT D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112; +const UINT D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128; +const UINT D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128; +const UINT D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112; +const UINT D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144; +const UINT D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96; +const UINT D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168; +const UINT D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80; +const UINT D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204; +const UINT D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64; +const UINT D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256; +const UINT D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48; +const UINT D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340; +const UINT D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32; +const UINT D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512; +const UINT D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16; +const UINT D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768; +const UINT D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1; +const UINT D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256; +const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768; +const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_X = 768; +const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_Y = 768; +const UINT D3D12_CS_4_X_UAV_REGISTER_COUNT = 1; +const UINT D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535; +const UINT D3D12_CS_TGSM_REGISTER_COUNT = 8192; +const UINT D3D12_CS_TGSM_REGISTER_READS_PER_INST = 1; +const UINT D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1; +const UINT D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1; +const UINT D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS = 3; +const UINT D3D12_CS_THREADGROUPID_REGISTER_COUNT = 1; +const UINT D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = 1; +const UINT D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = 1; +const UINT D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS = 3; +const UINT D3D12_CS_THREADIDINGROUP_REGISTER_COUNT = 1; +const UINT D3D12_CS_THREADID_REGISTER_COMPONENTS = 3; +const UINT D3D12_CS_THREADID_REGISTER_COUNT = 1; +const UINT D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024; +const UINT D3D12_CS_THREAD_GROUP_MAX_X = 1024; +const UINT D3D12_CS_THREAD_GROUP_MAX_Y = 1024; +const UINT D3D12_CS_THREAD_GROUP_MAX_Z = 64; +const UINT D3D12_CS_THREAD_GROUP_MIN_X = 1; +const UINT D3D12_CS_THREAD_GROUP_MIN_Y = 1; +const UINT D3D12_CS_THREAD_GROUP_MIN_Z = 1; +const UINT D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384; +cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA (1.0f)") +cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_BLUE (1.0f)") +cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_GREEN (1.0f)") +cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_RED (1.0f)") +cpp_quote("#define D3D12_DEFAULT_BORDER_COLOR_COMPONENT (0.0f)") +const UINT D3D12_DEFAULT_DEPTH_BIAS = 0; +cpp_quote("#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP (0.0f)") +const UINT D3D12_DEFAULT_MAX_ANISOTROPY = 16; +cpp_quote("#define D3D12_DEFAULT_MIP_LOD_BIAS (0.0f)") +const UINT D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 4194304; +const UINT D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; +const UINT D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = 65536; +const UINT D3D12_DEFAULT_SAMPLE_MASK = 0xffffffff; +const UINT D3D12_DEFAULT_SCISSOR_ENDX = 0; +const UINT D3D12_DEFAULT_SCISSOR_ENDY = 0; +const UINT D3D12_DEFAULT_SCISSOR_STARTX = 0; +const UINT D3D12_DEFAULT_SCISSOR_STARTY = 0; +cpp_quote("#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS (0.0f)") +const UINT D3D12_DEFAULT_STENCIL_READ_MASK = 0xff; +const UINT D3D12_DEFAULT_STENCIL_REFERENCE = 0; +const UINT D3D12_DEFAULT_STENCIL_WRITE_MASK = 0xff; +const UINT D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; +const UINT D3D12_DEFAULT_VIEWPORT_HEIGHT = 0; +cpp_quote("#define D3D12_DEFAULT_VIEWPORT_MAX_DEPTH (0.0f)") +cpp_quote("#define D3D12_DEFAULT_VIEWPORT_MIN_DEPTH (0.0f)") +const UINT D3D12_DEFAULT_VIEWPORT_TOPLEFTX = 0; +const UINT D3D12_DEFAULT_VIEWPORT_TOPLEFTY = 0; +const UINT D3D12_DEFAULT_VIEWPORT_WIDTH = 0; +const UINT D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND = 0xffffffff; +const UINT D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END = 0xfffffff7; +const UINT D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff0; +const UINT D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968; +const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = 4; +const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = 32; +const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = 1; +const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = 3; +const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = 1; +const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = 1; +const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4; +const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = 32; +const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1; +const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1; +const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1; +const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2; +const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1; +const UINT D3D12_DS_OUTPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_DS_OUTPUT_REGISTER_COUNT = 32; +cpp_quote("#define D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP (0.6)") +cpp_quote("#define D3D12_FLOAT32_MAX (3.402823466e+38f)") +cpp_quote("#define D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP (0.6f)") +cpp_quote("#define D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR (2.4f)") +cpp_quote("#define D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR (1.0f)") +cpp_quote("#define D3D12_FLOAT_TO_SRGB_OFFSET (0.055f)") +cpp_quote("#define D3D12_FLOAT_TO_SRGB_SCALE_1 (12.92f)") +cpp_quote("#define D3D12_FLOAT_TO_SRGB_SCALE_2 (1.055f)") +cpp_quote("#define D3D12_FLOAT_TO_SRGB_THRESHOLD (0.0031308f)") +cpp_quote("#define D3D12_FTOI_INSTRUCTION_MAX_INPUT (2147483647.999f)") +cpp_quote("#define D3D12_FTOI_INSTRUCTION_MIN_INPUT (-2147483648.999f)") +cpp_quote("#define D3D12_FTOU_INSTRUCTION_MAX_INPUT (4294967295.999f)") +cpp_quote("#define D3D12_FTOU_INSTRUCTION_MIN_INPUT (0.0f)") +const UINT D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST = 2; +const UINT D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS = 1; +const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = 1; +const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = 1; +const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1; +const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1; +const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2; +const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1; +const UINT D3D12_GS_INPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_GS_INPUT_REGISTER_COUNT = 32; +const UINT D3D12_GS_INPUT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_GS_INPUT_REGISTER_READ_PORTS = 1; +const UINT D3D12_GS_INPUT_REGISTER_VERTICES = 32; +const UINT D3D12_GS_MAX_INSTANCE_COUNT = 32; +const UINT D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = 1024; +const UINT D3D12_GS_OUTPUT_ELEMENTS = 32; +const UINT D3D12_GS_OUTPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_GS_OUTPUT_REGISTER_COUNT = 32; +const UINT D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = 32; +const UINT D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = 32; +const UINT D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS = 4; +const UINT D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS = 1; +const UINT D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xffffffff; +const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = 1; +const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = 1; +const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = 2; +const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = 1; +const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = 1; +const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = 1; +const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = 2; +const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = 1; +const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1; +const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1; +const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2; +const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1; +const UINT D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xffffffff; +cpp_quote("#define D3D12_HS_MAXTESSFACTOR_LOWER_BOUND (1.0f)") +cpp_quote("#define D3D12_HS_MAXTESSFACTOR_UPPER_BOUND (64.0f)") +const UINT D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968; +const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = 1; +const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = 1; +const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = 2; +const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = 1; +const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4; +const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = 32; +const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1; +const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = 128; +const UINT D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; +const UINT D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; +const UINT D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; +const UINT D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; +const UINT D3D12_IA_INSTANCE_ID_BIT_COUNT = 32; +const UINT D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; +const UINT D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32; +const UINT D3D12_IA_PRIMITIVE_ID_BIT_COUNT = 32; +const UINT D3D12_IA_VERTEX_ID_BIT_COUNT = 32; +const UINT D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32; +const UINT D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128; +const UINT D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32; +const UINT D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff; +const UINT D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff; +const UINT D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 0xffffffff; +const UINT D3D12_KEEP_UNORDERED_ACCESS_VIEWS = 0xffffffff; +cpp_quote("#define D3D12_LINEAR_GAMMA (1.0f)") +const UINT D3D12_MAJOR_VERSION = 12; +cpp_quote("#define D3D12_MAX_BORDER_COLOR_COMPONENT (1.0f)") +cpp_quote("#define D3D12_MAX_DEPTH (1.0f)") +const UINT D3D12_MAX_LIVE_STATIC_SAMPLERS = 2032; +const UINT D3D12_MAX_MAXANISOTROPY = 16; +const UINT D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; +cpp_quote("#define D3D12_MAX_POSITION_VALUE (3.402823466e+34f)") +const UINT D3D12_MAX_ROOT_COST = 64; +const UINT D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 = 1000000; +const UINT D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 = 1000000; +const UINT D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE = 2048; +const UINT D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17; +const UINT D3D12_MAX_VIEW_INSTANCE_COUNT = 4; +const UINT D3D12_MINOR_VERSION = 0; +cpp_quote("#define D3D12_MIN_BORDER_COLOR_COMPONENT (0.0f)") +cpp_quote("#define D3D12_MIN_DEPTH (0.0f)") +const UINT D3D12_MIN_MAXANISOTROPY = 0; +cpp_quote("#define D3D12_MIP_LOD_BIAS_MAX (15.99f)") +cpp_quote("#define D3D12_MIP_LOD_BIAS_MIN (-16.0f)") +const UINT D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT = 8; +const UINT D3D12_MIP_LOD_RANGE_BIT_COUNT = 8; +cpp_quote("#define D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH (1.4f)") +const UINT D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0; +const UINT D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END = 0xffffffff; +const UINT D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff8; +const UINT D3D12_PACKED_TILE = 0xffffffff; +const UINT D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; +const UINT D3D12_PREVIEW_SDK_VERSION = 702; +const UINT D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16; +const UINT D3D12_PS_CS_UAV_REGISTER_COMPONENTS = 1; +const UINT D3D12_PS_CS_UAV_REGISTER_COUNT = 8; +const UINT D3D12_PS_CS_UAV_REGISTER_READS_PER_INST = 1; +const UINT D3D12_PS_CS_UAV_REGISTER_READ_PORTS = 1; +const UINT D3D12_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff; +const UINT D3D12_PS_FRONTFACING_FALSE_VALUE = 0x00000000; +const UINT D3D12_PS_FRONTFACING_TRUE_VALUE = 0xffffffff; +const UINT D3D12_PS_INPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_PS_INPUT_REGISTER_COUNT = 32; +const UINT D3D12_PS_INPUT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_PS_INPUT_REGISTER_READ_PORTS = 1; +cpp_quote("#define D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.0f)") +const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; +const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; +const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1; +const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COUNT = 1; +const UINT D3D12_PS_OUTPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_PS_OUTPUT_REGISTER_COUNT = 8; +cpp_quote("#define D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.5f)") +const UINT D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = 16; +const UINT D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT = 8; +const UINT D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT = 256; +const UINT D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT = 16; +const UINT D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES = 32; +const UINT D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH = 31; +const UINT D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 16777216; +const UINT D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE = 16777216; +const UINT D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 536870912; +const UINT D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS = 1073741824; +const UINT D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE = 4096; +const UINT D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT = 32; +const UINT D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT = 64; +const UINT D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT = 16; +const UINT D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; +const UINT D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const UINT D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; +const UINT D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; +const UINT D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384; +const UINT D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; +const UINT D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const UINT D3D12_REQ_MAXANISOTROPY = 16; +const UINT D3D12_REQ_MIP_LEVELS = 15; +const UINT D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; +const UINT D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384; +const UINT D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128; +cpp_quote("#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM (0.25f)") +const UINT D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048; +const UINT D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20; +const UINT D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096; +const UINT D3D12_REQ_SUBRESOURCES = 30720; +const UINT D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048; +const UINT D3D12_REQ_TEXTURE1D_U_DIMENSION = 16384; +const UINT D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048; +const UINT D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384; +const UINT D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; +const UINT D3D12_REQ_TEXTURECUBE_DIMENSION = 16384; +const UINT D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; +const UINT D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES = 0xffffffff; +const UINT D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT = 2; +const UINT D3D12_SDK_VERSION = 602; +const UINT D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES = 32; +const UINT D3D12_SHADER_MAJOR_VERSION = 5; +const UINT D3D12_SHADER_MAX_INSTANCES = 65535; +const UINT D3D12_SHADER_MAX_INTERFACES = 253; +const UINT D3D12_SHADER_MAX_INTERFACE_CALL_SITES = 4096; +const UINT D3D12_SHADER_MAX_TYPES = 65535; +const UINT D3D12_SHADER_MINOR_VERSION = 1; +const UINT D3D12_SHIFT_INSTRUCTION_PAD_VALUE = 0; +const UINT D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; +const UINT D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; +const UINT D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 65536; +const UINT D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 4096; +const UINT D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; +const UINT D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512; +const UINT D3D12_SO_BUFFER_SLOT_COUNT = 4; +const UINT D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff; +const UINT D3D12_SO_NO_RASTERIZED_STREAM = 0xffffffff; +const UINT D3D12_SO_OUTPUT_COMPONENT_COUNT = 128; +const UINT D3D12_SO_STREAM_COUNT = 4; +const UINT D3D12_SPEC_DATE_DAY = 14; +const UINT D3D12_SPEC_DATE_MONTH = 11; +const UINT D3D12_SPEC_DATE_YEAR = 2014; +cpp_quote("#define D3D12_SPEC_VERSION (1.16)") +cpp_quote("#define D3D12_SRGB_GAMMA (2.2f)") +cpp_quote("#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 (12.92f)") +cpp_quote("#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 (1.055f)") +cpp_quote("#define D3D12_SRGB_TO_FLOAT_EXPONENT (2.4f)") +cpp_quote("#define D3D12_SRGB_TO_FLOAT_OFFSET (0.055f)") +cpp_quote("#define D3D12_SRGB_TO_FLOAT_THRESHOLD (0.04045f)") +cpp_quote("#define D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP (0.5f)") +const UINT D3D12_STANDARD_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; +const UINT D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; +const UINT D3D12_STANDARD_PIXEL_COMPONENT_COUNT = 128; +const UINT D3D12_STANDARD_PIXEL_ELEMENT_COUNT = 32; +const UINT D3D12_STANDARD_VECTOR_SIZE = 4; +const UINT D3D12_STANDARD_VERTEX_ELEMENT_COUNT = 32; +const UINT D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; +const UINT D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; +const UINT D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT = 8; +const UINT D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END = 0xffffffff; +const UINT D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff0; +const UINT D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = 64; +const UINT D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = 64; +const UINT D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = 63; +const UINT D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR = 64; +const UINT D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = 2; +const UINT D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = 1; +const UINT D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = 1; +const UINT D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT = 16; +const UINT D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = 256; +const UINT D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512; +const UINT D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536; +const UINT D3D12_TRACKED_WORKLOAD_MAX_INSTANCES = 32; +const UINT D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT = 4096; +const UINT D3D12_UAV_SLOT_COUNT = 64; +const UINT D3D12_UNBOUND_MEMORY_ACCESS_RESULT = 0; +const UINT D3D12_VIDEO_DECODE_MAX_ARGUMENTS = 10; +const UINT D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS = 4; +const UINT D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT = 256; +const UINT D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT = 256; +const UINT D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN = 0xffffffff; +const UINT D3D12_VIDEO_PROCESS_MAX_FILTERS = 32; +const UINT D3D12_VIDEO_PROCESS_STEREO_VIEWS = 2; +const UINT D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; +const UINT D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; +const UINT D3D12_VIEWPORT_BOUNDS_MAX = 32767; +const INT D3D12_VIEWPORT_BOUNDS_MIN = -32768; +const UINT D3D12_VS_INPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_VS_INPUT_REGISTER_COUNT = 32; +const UINT D3D12_VS_INPUT_REGISTER_READS_PER_INST = 2; +const UINT D3D12_VS_INPUT_REGISTER_READ_PORTS = 1; +const UINT D3D12_VS_OUTPUT_REGISTER_COMPONENTS = 4; +const UINT D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const UINT D3D12_VS_OUTPUT_REGISTER_COUNT = 32; +const UINT D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10; +const UINT D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25; +const UINT D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25; + +cpp_quote("#endif") + +const UINT D3D12_SHADER_COMPONENT_MAPPING_MASK = 0x7; +const UINT D3D12_SHADER_COMPONENT_MAPPING_SHIFT = 3; +const UINT D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES + = 1 << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 4); + +typedef enum D3D12_SHADER_MIN_PRECISION_SUPPORT +{ + D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = 0x0, + D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = 0x1, + D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2, +} D3D12_SHADER_MIN_PRECISION_SUPPORT; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_MIN_PRECISION_SUPPORT);") + +typedef enum D3D12_TILED_RESOURCES_TIER +{ + D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED = 0, + D3D12_TILED_RESOURCES_TIER_1 = 1, + D3D12_TILED_RESOURCES_TIER_2 = 2, + D3D12_TILED_RESOURCES_TIER_3 = 3, +} D3D12_TILED_RESOURCES_TIER; + +typedef enum D3D12_RESOURCE_BINDING_TIER +{ + D3D12_RESOURCE_BINDING_TIER_1 = 1, + D3D12_RESOURCE_BINDING_TIER_2 = 2, + D3D12_RESOURCE_BINDING_TIER_3 = 3, +} D3D12_RESOURCE_BINDING_TIER; + +typedef enum D3D12_CONSERVATIVE_RASTERIZATION_TIER +{ + D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED = 0, + D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 = 1, + D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 = 2, + D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 = 3, +} D3D12_CONSERVATIVE_RASTERIZATION_TIER; + +typedef enum D3D12_CROSS_NODE_SHARING_TIER +{ + D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED = 0, + D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = 1, + D3D12_CROSS_NODE_SHARING_TIER_1 = 2, + D3D12_CROSS_NODE_SHARING_TIER_2 = 3, + D3D12_CROSS_NODE_SHARING_TIER_3 = 4, +} D3D12_CROSS_NODE_SHARING_TIER; + +typedef enum D3D12_RESOURCE_HEAP_TIER +{ + D3D12_RESOURCE_HEAP_TIER_1 = 1, + D3D12_RESOURCE_HEAP_TIER_2 = 2, +} D3D12_RESOURCE_HEAP_TIER; + +typedef enum D3D12_FORMAT_SUPPORT1 +{ + D3D12_FORMAT_SUPPORT1_NONE = 0x00000000, + D3D12_FORMAT_SUPPORT1_BUFFER = 0x00000001, + D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER = 0x00000002, + D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER = 0x00000004, + D3D12_FORMAT_SUPPORT1_SO_BUFFER = 0x00000008, + D3D12_FORMAT_SUPPORT1_TEXTURE1D = 0x00000010, + D3D12_FORMAT_SUPPORT1_TEXTURE2D = 0x00000020, + D3D12_FORMAT_SUPPORT1_TEXTURE3D = 0x00000040, + D3D12_FORMAT_SUPPORT1_TEXTURECUBE = 0x00000080, + D3D12_FORMAT_SUPPORT1_SHADER_LOAD = 0x00000100, + D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE = 0x00000200, + D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON = 0x00000400, + D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT = 0x00000800, + D3D12_FORMAT_SUPPORT1_MIP = 0x00001000, + D3D12_FORMAT_SUPPORT1_RENDER_TARGET = 0x00004000, + D3D12_FORMAT_SUPPORT1_BLENDABLE = 0x00008000, + D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL = 0x00010000, + D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE = 0x00040000, + D3D12_FORMAT_SUPPORT1_DISPLAY = 0x00080000, + D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT = 0x00100000, + D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET = 0x00200000, + D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD = 0x00400000, + D3D12_FORMAT_SUPPORT1_SHADER_GATHER = 0x00800000, + D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST = 0x01000000, + D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW = 0x02000000, + D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON = 0x04000000, + D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT = 0x08000000, + D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT = 0x10000000, + D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = 0x20000000, + D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000, +} D3D12_FORMAT_SUPPORT1; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT1);") + +typedef enum D3D12_FORMAT_SUPPORT2 +{ + D3D12_FORMAT_SUPPORT2_NONE = 0x00000000, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x00000001, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x00000002, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x00000004, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x00000008, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x00000010, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x00000020, + D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x00000040, + D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x00000080, + D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x00000100, + D3D12_FORMAT_SUPPORT2_TILED = 0x00000200, + D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x00004000, + D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK = 0x00008000, +} D3D12_FORMAT_SUPPORT2; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT2);") + +typedef enum D3D12_WRITEBUFFERIMMEDIATE_MODE +{ + D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT = 0x0, + D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN = 0x1, + D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT = 0x2, +} D3D12_WRITEBUFFERIMMEDIATE_MODE; + +typedef enum D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER +{ + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED = 0x0, + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 = 0x1, + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 = 0x2, +} D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER; + +typedef enum D3D12_SHADER_CACHE_SUPPORT_FLAGS +{ + D3D12_SHADER_CACHE_SUPPORT_NONE = 0x0, + D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = 0x1, + D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 0x2, + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4, + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8, + D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE = 0x10, + D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR = 0x20, + D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE = 0x40, +} D3D12_SHADER_CACHE_SUPPORT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_SUPPORT_FLAGS);") + +typedef enum D3D12_COMMAND_LIST_SUPPORT_FLAGS +{ + D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = 0x0, + D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = 0x1, + D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = 0x2, + D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = 0x4, + D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = 0x8, + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE = 0x10, + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = 0x20, + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = 0x40, +} D3D12_COMMAND_LIST_SUPPORT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_SUPPORT_FLAGS);") + +typedef enum D3D12_VIEW_INSTANCING_TIER +{ + D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED = 0x0, + D3D12_VIEW_INSTANCING_TIER_1 = 0x1, + D3D12_VIEW_INSTANCING_TIER_2 = 0x2, + D3D12_VIEW_INSTANCING_TIER_3 = 0x3, +} D3D12_VIEW_INSTANCING_TIER; + +typedef enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER +{ + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = 0x0, + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = 0x1, + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2 = 0x2, +} D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER; + +typedef struct D3D12_FEATURE_DATA_DISPLAYABLE +{ + BOOL DisplayableTexture; + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier; +} D3D12_FEATURE_DATA_DISPLAYABLE; + +typedef enum D3D12_HEAP_SERIALIZATION_TIER +{ + D3D12_HEAP_SERIALIZATION_TIER_0 = 0x0, + D3D12_HEAP_SERIALIZATION_TIER_10 = 0xa, +} D3D12_HEAP_SERIALIZATION_TIER; + +typedef enum D3D12_RENDER_PASS_TIER +{ + D3D12_RENDER_PASS_TIER_0 = 0x0, + D3D12_RENDER_PASS_TIER_1 = 0x1, + D3D12_RENDER_PASS_TIER_2 = 0x2, +} D3D12_RENDER_PASS_TIER; + +typedef enum D3D12_RAYTRACING_TIER +{ + D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0x0, + D3D12_RAYTRACING_TIER_1_0 = 0xa, + D3D12_RAYTRACING_TIER_1_1 = 0xb, +} D3D12_RAYTRACING_TIER; + +typedef enum D3D12_RESIDENCY_FLAGS +{ + D3D12_RESIDENCY_FLAG_NONE = 0x0, + D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1, +} D3D12_RESIDENCY_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESIDENCY_FLAGS);") + +interface ID3D12Fence; +interface ID3D12RootSignature; +interface ID3D12Heap; +interface ID3D12DescriptorHeap; +interface ID3D12Resource; +interface ID3D12CommandAllocator; +interface ID3D12GraphicsCommandList; +interface ID3D12CommandQueue; +interface ID3D12PipelineState; +interface ID3D12Device; + +typedef RECT D3D12_RECT; + +typedef struct D3D12_BOX +{ + UINT left; + UINT top; + UINT front; + UINT right; + UINT bottom; + UINT back; +} D3D12_BOX; + +typedef struct D3D12_VIEWPORT +{ + FLOAT TopLeftX; + FLOAT TopLeftY; + FLOAT Width; + FLOAT Height; + FLOAT MinDepth; + FLOAT MaxDepth; +} D3D12_VIEWPORT; + +typedef struct D3D12_RANGE +{ + SIZE_T Begin; + SIZE_T End; +} D3D12_RANGE; + +typedef struct D3D12_RANGE_UINT64 +{ + UINT64 Begin; + UINT64 End; +} D3D12_RANGE_UINT64; + +typedef struct D3D12_SUBRESOURCE_RANGE_UINT64 +{ + UINT Subresource; + D3D12_RANGE_UINT64 Range; +} D3D12_SUBRESOURCE_RANGE_UINT64; + +typedef struct D3D12_SUBRESOURCE_INFO +{ + UINT64 Offset; + UINT RowPitch; + UINT DepthPitch; +} D3D12_SUBRESOURCE_INFO; + +typedef struct D3D12_RESOURCE_ALLOCATION_INFO +{ + UINT64 SizeInBytes; + UINT64 Alignment; +} D3D12_RESOURCE_ALLOCATION_INFO; + +typedef struct D3D12_RESOURCE_ALLOCATION_INFO1 +{ + UINT64 Offset; + UINT64 Alignment; + UINT64 SizeInBytes; +} D3D12_RESOURCE_ALLOCATION_INFO1; + +typedef struct D3D12_DRAW_ARGUMENTS +{ + UINT VertexCountPerInstance; + UINT InstanceCount; + UINT StartVertexLocation; + UINT StartInstanceLocation; +} D3D12_DRAW_ARGUMENTS; + +typedef struct D3D12_DRAW_INDEXED_ARGUMENTS +{ + UINT IndexCountPerInstance; + UINT InstanceCount; + UINT StartIndexLocation; + INT BaseVertexLocation; + UINT StartInstanceLocation; +} D3D12_DRAW_INDEXED_ARGUMENTS; + +typedef struct D3D12_DISPATCH_ARGUMENTS +{ + UINT ThreadGroupCountX; + UINT ThreadGroupCountY; + UINT ThreadGroupCountZ; +} D3D12_DISPATCH_ARGUMENTS; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS +{ + BOOL DoublePrecisionFloatShaderOps; + BOOL OutputMergerLogicOp; + D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport; + D3D12_TILED_RESOURCES_TIER TiledResourcesTier; + D3D12_RESOURCE_BINDING_TIER ResourceBindingTier; + BOOL PSSpecifiedStencilRefSupported; + BOOL TypedUAVLoadAdditionalFormats; + BOOL ROVsSupported; + D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier; + UINT MaxGPUVirtualAddressBitsPerResource; + BOOL StandardSwizzle64KBSupported; + D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier; + BOOL CrossAdapterRowMajorTextureSupported; + BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation; + D3D12_RESOURCE_HEAP_TIER ResourceHeapTier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS; + +typedef struct D3D12_FEATURE_DATA_FORMAT_SUPPORT +{ + DXGI_FORMAT Format; + D3D12_FORMAT_SUPPORT1 Support1; + D3D12_FORMAT_SUPPORT2 Support2; +} D3D12_FEATURE_DATA_FORMAT_SUPPORT; + +typedef enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS +{ + D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0x00000000, + D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x00000001, +} D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS);") + +typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS +{ + DXGI_FORMAT Format; + UINT SampleCount; + D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags; + UINT NumQualityLevels; +} D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS; + +typedef enum D3D12_HEAP_TYPE +{ + D3D12_HEAP_TYPE_DEFAULT = 1, + D3D12_HEAP_TYPE_UPLOAD = 2, + D3D12_HEAP_TYPE_READBACK = 3, + D3D12_HEAP_TYPE_CUSTOM = 4, +} D3D12_HEAP_TYPE; + +typedef enum D3D12_CPU_PAGE_PROPERTY +{ + D3D12_CPU_PAGE_PROPERTY_UNKNOWN = 0, + D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE = 1, + D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE = 2, + D3D12_CPU_PAGE_PROPERTY_WRITE_BACK = 3, +} D3D12_CPU_PAGE_PROPERTY; + +typedef enum D3D12_MEMORY_POOL +{ + D3D12_MEMORY_POOL_UNKNOWN = 0, + D3D12_MEMORY_POOL_L0 = 1, + D3D12_MEMORY_POOL_L1 = 2, +} D3D12_MEMORY_POOL; + +typedef struct D3D12_HEAP_PROPERTIES +{ + D3D12_HEAP_TYPE Type; + D3D12_CPU_PAGE_PROPERTY CPUPageProperty; + D3D12_MEMORY_POOL MemoryPoolPreference; + UINT CreationNodeMask; + UINT VisibleNodeMask; +} D3D12_HEAP_PROPERTIES; + +typedef enum D3D12_HEAP_FLAGS +{ + D3D12_HEAP_FLAG_NONE = 0x00, + D3D12_HEAP_FLAG_SHARED = 0x01, + D3D12_HEAP_FLAG_DENY_BUFFERS = 0x04, + D3D12_HEAP_FLAG_ALLOW_DISPLAY = 0x08, + D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20, + D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40, + D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80, + D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100, + D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200, + D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400, + D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = 0x800, + D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = 0x1000, + D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0x00, + D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0, + D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44, + D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84, +} D3D12_HEAP_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_HEAP_FLAGS);") + +typedef struct D3D12_HEAP_DESC +{ + UINT64 SizeInBytes; + D3D12_HEAP_PROPERTIES Properties; + UINT64 Alignment; + D3D12_HEAP_FLAGS Flags; +} D3D12_HEAP_DESC; + +typedef struct D3D12_TILED_RESOURCE_COORDINATE +{ + UINT X; + UINT Y; + UINT Z; + UINT Subresource; +} D3D12_TILED_RESOURCE_COORDINATE; + +typedef struct D3D12_TILE_REGION_SIZE +{ + UINT NumTiles; + BOOL UseBox; + UINT Width; + UINT16 Height; + UINT16 Depth; +} D3D12_TILE_REGION_SIZE; + +typedef struct D3D12_SUBRESOURCE_TILING +{ + UINT WidthInTiles; + UINT16 HeightInTiles; + UINT16 DepthInTiles; + UINT StartTileIndexInOverallResource; +} D3D12_SUBRESOURCE_TILING; + +typedef struct D3D12_TILE_SHAPE +{ + UINT WidthInTexels; + UINT HeightInTexels; + UINT DepthInTexels; +} D3D12_TILE_SHAPE; + +typedef struct D3D12_SHADER_BYTECODE +{ + const void *pShaderBytecode; + SIZE_T BytecodeLength; +} D3D12_SHADER_BYTECODE; + +typedef struct D3D12_DEPTH_STENCIL_VALUE +{ + FLOAT Depth; + UINT8 Stencil; +} D3D12_DEPTH_STENCIL_VALUE; + +typedef struct D3D12_CLEAR_VALUE +{ + DXGI_FORMAT Format; + union + { + FLOAT Color[4]; + D3D12_DEPTH_STENCIL_VALUE DepthStencil; + }; +} D3D12_CLEAR_VALUE; + +typedef struct D3D12_PACKED_MIP_INFO +{ + UINT8 NumStandardMips; + UINT8 NumPackedMips; + UINT NumTilesForPackedMips; + UINT StartTileIndexInOverallResource; +} D3D12_PACKED_MIP_INFO; + +typedef enum D3D12_RESOURCE_STATES +{ + D3D12_RESOURCE_STATE_COMMON = 0, + D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 0x1, + D3D12_RESOURCE_STATE_INDEX_BUFFER = 0x2, + D3D12_RESOURCE_STATE_RENDER_TARGET = 0x4, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS = 0x8, + D3D12_RESOURCE_STATE_DEPTH_WRITE = 0x10, + D3D12_RESOURCE_STATE_DEPTH_READ = 0x20, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 0x40, + D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 0x80, + D3D12_RESOURCE_STATE_STREAM_OUT = 0x100, + D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = 0x200, + D3D12_RESOURCE_STATE_COPY_DEST = 0x400, + D3D12_RESOURCE_STATE_COPY_SOURCE = 0x800, + D3D12_RESOURCE_STATE_RESOLVE_DEST = 0x1000, + D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000, + D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000, + D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000, + D3D12_RESOURCE_STATE_GENERIC_READ = 0x1 | 0x2 | 0x40 | 0x80 | 0x200 | 0x800, + D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE = 0x40 | 0x80, + D3D12_RESOURCE_STATE_PRESENT = 0x0, + D3D12_RESOURCE_STATE_PREDICATION = 0x200, + D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000, + D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = 0x20000, + D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = 0x40000, + D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = 0x80000, + D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = 0x200000, + D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000, +} D3D12_RESOURCE_STATES; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_STATES);") + +typedef enum D3D12_RESOURCE_BARRIER_TYPE +{ + D3D12_RESOURCE_BARRIER_TYPE_TRANSITION = 0, + D3D12_RESOURCE_BARRIER_TYPE_ALIASING = 1, + D3D12_RESOURCE_BARRIER_TYPE_UAV = 2, +} D3D12_RESOURCE_BARRIER_TYPE; + +typedef enum D3D12_RESOURCE_BARRIER_FLAGS +{ + D3D12_RESOURCE_BARRIER_FLAG_NONE = 0x0, + D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1, + D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2, +} D3D12_RESOURCE_BARRIER_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_BARRIER_FLAGS);") + +typedef struct D3D12_RESOURCE_TRANSITION_BARRIER +{ + ID3D12Resource *pResource; + UINT Subresource; + D3D12_RESOURCE_STATES StateBefore; + D3D12_RESOURCE_STATES StateAfter; +} D3D12_RESOURCE_TRANSITION_BARRIER; + +typedef struct D3D12_RESOURCE_ALIASING_BARRIER_ALIASING +{ + ID3D12Resource *pResourceBefore; + ID3D12Resource *pResourceAfter; +} D3D12_RESOURCE_ALIASING_BARRIER; + +typedef struct D3D12_RESOURCE_UAV_BARRIER +{ + ID3D12Resource *pResource; +} D3D12_RESOURCE_UAV_BARRIER; + +typedef struct D3D12_RESOURCE_BARRIER +{ + D3D12_RESOURCE_BARRIER_TYPE Type; + D3D12_RESOURCE_BARRIER_FLAGS Flags; + union + { + D3D12_RESOURCE_TRANSITION_BARRIER Transition; + D3D12_RESOURCE_ALIASING_BARRIER Aliasing; + D3D12_RESOURCE_UAV_BARRIER UAV; + }; +} D3D12_RESOURCE_BARRIER; + +typedef enum D3D12_RESOURCE_DIMENSION +{ + D3D12_RESOURCE_DIMENSION_UNKNOWN = 0, + D3D12_RESOURCE_DIMENSION_BUFFER = 1, + D3D12_RESOURCE_DIMENSION_TEXTURE1D = 2, + D3D12_RESOURCE_DIMENSION_TEXTURE2D = 3, + D3D12_RESOURCE_DIMENSION_TEXTURE3D = 4, +} D3D12_RESOURCE_DIMENSION; + +typedef enum D3D12_TEXTURE_LAYOUT +{ + D3D12_TEXTURE_LAYOUT_UNKNOWN = 0, + D3D12_TEXTURE_LAYOUT_ROW_MAJOR = 1, + D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE = 2, + D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = 3, +} D3D12_TEXTURE_LAYOUT; + +typedef enum D3D12_RESOURCE_FLAGS +{ + D3D12_RESOURCE_FLAG_NONE = 0x0, + D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = 0x1, + D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 0x2, + D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 0x4, + D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8, + D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10, + D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20, + D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40, + D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = 0x80, + D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE = 0x100, +} D3D12_RESOURCE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_FLAGS);") + +typedef struct D3D12_MIP_REGION +{ + UINT Width; + UINT Height; + UINT Depth; +} D3D12_MIP_REGION; + +typedef struct D3D12_RESOURCE_DESC +{ + D3D12_RESOURCE_DIMENSION Dimension; + UINT64 Alignment; + UINT64 Width; + UINT Height; + UINT16 DepthOrArraySize; + UINT16 MipLevels; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D12_TEXTURE_LAYOUT Layout; + D3D12_RESOURCE_FLAGS Flags; +} D3D12_RESOURCE_DESC; + +typedef struct D3D12_RESOURCE_DESC1 +{ + D3D12_RESOURCE_DIMENSION Dimension; + UINT64 Alignment; + UINT64 Width; + UINT Height; + UINT16 DepthOrArraySize; + UINT16 MipLevels; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D12_TEXTURE_LAYOUT Layout; + D3D12_RESOURCE_FLAGS Flags; + D3D12_MIP_REGION SamplerFeedbackMipRegion; +} D3D12_RESOURCE_DESC1; + +typedef enum D3D12_RESOLVE_MODE +{ + D3D12_RESOLVE_MODE_DECOMPRESS = 0, + D3D12_RESOLVE_MODE_MIN = 1, + D3D12_RESOLVE_MODE_MAX = 2, + D3D12_RESOLVE_MODE_AVERAGE = 3, + D3D12_RESOLVE_MODE_ENCODE_SAMPLER_FEEDBACK = 4, + D3D12_RESOLVE_MODE_DECODE_SAMPLER_FEEDBACK = 5, +} D3D12_RESOLVE_MODE; + +typedef struct D3D12_SAMPLE_POSITION +{ + INT8 X; + INT8 Y; +} D3D12_SAMPLE_POSITION; + +typedef enum D3D12_TEXTURE_COPY_TYPE +{ + D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX = 0, + D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT = 1, +} D3D12_TEXTURE_COPY_TYPE; + +typedef struct D3D12_SUBRESOURCE_FOOTPRINT +{ + DXGI_FORMAT Format; + UINT Width; + UINT Height; + UINT Depth; + UINT RowPitch; +} D3D12_SUBRESOURCE_FOOTPRINT; + +typedef struct D3D12_PLACED_SUBRESOURCE_FOOTPRINT +{ + UINT64 Offset; + D3D12_SUBRESOURCE_FOOTPRINT Footprint; +} D3D12_PLACED_SUBRESOURCE_FOOTPRINT; + +typedef struct D3D12_TEXTURE_COPY_LOCATION +{ + ID3D12Resource *pResource; + D3D12_TEXTURE_COPY_TYPE Type; + union + { + D3D12_PLACED_SUBRESOURCE_FOOTPRINT PlacedFootprint; + UINT SubresourceIndex; + }; +} D3D12_TEXTURE_COPY_LOCATION; + +typedef enum D3D12_DESCRIPTOR_RANGE_TYPE +{ + D3D12_DESCRIPTOR_RANGE_TYPE_SRV = 0, + D3D12_DESCRIPTOR_RANGE_TYPE_UAV = 1, + D3D12_DESCRIPTOR_RANGE_TYPE_CBV = 2, + D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER = 3, +} D3D12_DESCRIPTOR_RANGE_TYPE; + +typedef struct D3D12_DESCRIPTOR_RANGE +{ + D3D12_DESCRIPTOR_RANGE_TYPE RangeType; + UINT NumDescriptors; + UINT BaseShaderRegister; + UINT RegisterSpace; + UINT OffsetInDescriptorsFromTableStart; +} D3D12_DESCRIPTOR_RANGE; + +typedef enum D3D12_DESCRIPTOR_RANGE_FLAGS +{ + D3D12_DESCRIPTOR_RANGE_FLAG_NONE = 0x0, + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE = 0x1, + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = 0x2, + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4, + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 0x8, + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000, +} D3D12_DESCRIPTOR_RANGE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_RANGE_FLAGS);") + +typedef struct D3D12_DESCRIPTOR_RANGE1 +{ + D3D12_DESCRIPTOR_RANGE_TYPE RangeType; + UINT NumDescriptors; + UINT BaseShaderRegister; + UINT RegisterSpace; + D3D12_DESCRIPTOR_RANGE_FLAGS Flags; + UINT OffsetInDescriptorsFromTableStart; +} D3D12_DESCRIPTOR_RANGE1; + +typedef struct D3D12_ROOT_DESCRIPTOR_TABLE +{ + UINT NumDescriptorRanges; + const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges; +} D3D12_ROOT_DESCRIPTOR_TABLE; + +typedef struct D3D12_ROOT_DESCRIPTOR_TABLE1 +{ + UINT NumDescriptorRanges; + const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges; +} D3D12_ROOT_DESCRIPTOR_TABLE1; + +typedef struct D3D12_ROOT_CONSTANTS +{ + UINT ShaderRegister; + UINT RegisterSpace; + UINT Num32BitValues; +} D3D12_ROOT_CONSTANTS; + +typedef struct D3D12_ROOT_DESCRIPTOR +{ + UINT ShaderRegister; + UINT RegisterSpace; +} D3D12_ROOT_DESCRIPTOR; + +typedef enum D3D12_ROOT_DESCRIPTOR_FLAGS +{ + D3D12_ROOT_DESCRIPTOR_FLAG_NONE = 0x0, + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE = 0x2, + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4, + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 0x8, +} D3D12_ROOT_DESCRIPTOR_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_DESCRIPTOR_FLAGS);") + +typedef struct D3D12_ROOT_DESCRIPTOR1 +{ + UINT ShaderRegister; + UINT RegisterSpace; + D3D12_ROOT_DESCRIPTOR_FLAGS Flags; +} D3D12_ROOT_DESCRIPTOR1; + +typedef enum D3D12_ROOT_PARAMETER_TYPE +{ + D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0, + D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = 1, + D3D12_ROOT_PARAMETER_TYPE_CBV = 2, + D3D12_ROOT_PARAMETER_TYPE_SRV = 3, + D3D12_ROOT_PARAMETER_TYPE_UAV = 4, +} D3D12_ROOT_PARAMETER_TYPE; + +typedef enum D3D12_SHADER_VISIBILITY +{ + D3D12_SHADER_VISIBILITY_ALL = 0, + D3D12_SHADER_VISIBILITY_VERTEX = 1, + D3D12_SHADER_VISIBILITY_HULL = 2, + D3D12_SHADER_VISIBILITY_DOMAIN = 3, + D3D12_SHADER_VISIBILITY_GEOMETRY = 4, + D3D12_SHADER_VISIBILITY_PIXEL = 5, + D3D12_SHADER_VISIBILITY_AMPLIFICATION = 6, + D3D12_SHADER_VISIBILITY_MESH = 7, +} D3D12_SHADER_VISIBILITY; + +typedef struct D3D12_ROOT_PARAMETER +{ + D3D12_ROOT_PARAMETER_TYPE ParameterType; + union + { + D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable; + D3D12_ROOT_CONSTANTS Constants; + D3D12_ROOT_DESCRIPTOR Descriptor; + }; + D3D12_SHADER_VISIBILITY ShaderVisibility; +} D3D12_ROOT_PARAMETER; + +typedef struct D3D12_ROOT_PARAMETER1 +{ + D3D12_ROOT_PARAMETER_TYPE ParameterType; + union + { + D3D12_ROOT_DESCRIPTOR_TABLE1 DescriptorTable; + D3D12_ROOT_CONSTANTS Constants; + D3D12_ROOT_DESCRIPTOR1 Descriptor; + }; + D3D12_SHADER_VISIBILITY ShaderVisibility; +} D3D12_ROOT_PARAMETER1; + +typedef enum D3D12_STATIC_BORDER_COLOR +{ + D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = 0, + D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK = 1, + D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE = 2, +} D3D12_STATIC_BORDER_COLOR; + +typedef enum D3D12_FILTER +{ + D3D12_FILTER_MIN_MAG_MIP_POINT = 0x00, + D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01, + D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04, + D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05, + D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D3D12_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D12_FILTER_ANISOTROPIC = 0x55, + D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, + D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, + D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, + D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, + D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, + D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, + D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, + D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D12_FILTER_COMPARISON_ANISOTROPIC = 0xd5, + D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100, + D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101, + D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104, + D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105, + D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110, + D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111, + D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114, + D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115, + D3D12_FILTER_MINIMUM_ANISOTROPIC = 0x155, + D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180, + D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181, + D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184, + D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185, + D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190, + D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191, + D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194, + D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195, + D3D12_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5, +} D3D12_FILTER; + +typedef enum D3D12_FILTER_TYPE +{ + D3D12_FILTER_TYPE_POINT = 0, + D3D12_FILTER_TYPE_LINEAR = 1, +} D3D12_FILTER_TYPE; + +const UINT D3D12_MIP_FILTER_SHIFT = 0; +const UINT D3D12_MAG_FILTER_SHIFT = 2; +const UINT D3D12_MIN_FILTER_SHIFT = 4; +const UINT D3D12_FILTER_TYPE_MASK = 0x3; + +const UINT D3D12_ANISOTROPIC_FILTERING_BIT = 0x40; + +typedef enum D3D12_FILTER_REDUCTION_TYPE +{ + D3D12_FILTER_REDUCTION_TYPE_STANDARD = 0, + D3D12_FILTER_REDUCTION_TYPE_COMPARISON = 1, + D3D12_FILTER_REDUCTION_TYPE_MINIMUM = 2, + D3D12_FILTER_REDUCTION_TYPE_MAXIMUM = 3, +} D3D12_FILTER_REDUCTION_TYPE; + +const UINT D3D12_FILTER_REDUCTION_TYPE_MASK = 0x3; +const UINT D3D12_FILTER_REDUCTION_TYPE_SHIFT = 7; + +cpp_quote("#define D3D12_ENCODE_BASIC_FILTER(min, mag, mip, reduction) \\") +cpp_quote(" ((D3D12_FILTER) ( \\") +cpp_quote(" (((min) & D3D12_FILTER_TYPE_MASK) << D3D12_MIN_FILTER_SHIFT) \\") +cpp_quote(" | (((mag) & D3D12_FILTER_TYPE_MASK) << D3D12_MAG_FILTER_SHIFT) \\") +cpp_quote(" | (((mip) & D3D12_FILTER_TYPE_MASK) << D3D12_MIP_FILTER_SHIFT) \\") +cpp_quote(" | (((reduction) & D3D12_FILTER_REDUCTION_TYPE_MASK) << D3D12_FILTER_REDUCTION_TYPE_SHIFT)))") + +cpp_quote("#define D3D12_ENCODE_ANISOTROPIC_FILTER(reduction) \\") +cpp_quote(" ((D3D12_FILTER) ( \\") +cpp_quote(" D3D12_ANISOTROPIC_FILTERING_BIT \\") +cpp_quote(" | D3D12_ENCODE_BASIC_FILTER(D3D12_FILTER_TYPE_LINEAR, \\") +cpp_quote(" D3D12_FILTER_TYPE_LINEAR, \\") +cpp_quote(" D3D12_FILTER_TYPE_LINEAR, \\") +cpp_quote(" reduction)))") + +cpp_quote("#define D3D12_DECODE_MAG_FILTER(filter) \\") +cpp_quote(" ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MAG_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D12_DECODE_MIN_FILTER(filter) \\") +cpp_quote(" ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MIN_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D12_DECODE_MIP_FILTER(filter) \\") +cpp_quote(" ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MIP_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D12_DECODE_IS_ANISOTROPIC_FILTER(filter) \\") +cpp_quote(" (((filter) & D3D12_ANISOTROPIC_FILTERING_BIT) \\") +cpp_quote(" && (D3D12_DECODE_MIN_FILTER(filter) == D3D12_FILTER_TYPE_LINEAR) \\") +cpp_quote(" && (D3D12_DECODE_MAG_FILTER(filter) == D3D12_FILTER_TYPE_LINEAR) \\") +cpp_quote(" && (D3D12_DECODE_MIP_FILTER(filter) == D3D12_FILTER_TYPE_LINEAR))") + +cpp_quote("#define D3D12_DECODE_FILTER_REDUCTION(filter) \\") +cpp_quote(" ((D3D12_FILTER_REDUCTION_TYPE)(((filter) >> D3D12_FILTER_REDUCTION_TYPE_SHIFT) \\") +cpp_quote(" & D3D12_FILTER_REDUCTION_TYPE_MASK))") + +cpp_quote("#define D3D12_DECODE_IS_COMPARISON_FILTER(filter) \\") +cpp_quote(" (D3D12_DECODE_FILTER_REDUCTION(filter) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON)") + +typedef enum D3D12_TEXTURE_ADDRESS_MODE +{ + D3D12_TEXTURE_ADDRESS_MODE_WRAP = 1, + D3D12_TEXTURE_ADDRESS_MODE_MIRROR = 2, + D3D12_TEXTURE_ADDRESS_MODE_CLAMP = 3, + D3D12_TEXTURE_ADDRESS_MODE_BORDER = 4, + D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5, +} D3D12_TEXTURE_ADDRESS_MODE; + +typedef enum D3D12_COMPARISON_FUNC +{ + D3D12_COMPARISON_FUNC_NEVER = 1, + D3D12_COMPARISON_FUNC_LESS = 2, + D3D12_COMPARISON_FUNC_EQUAL = 3, + D3D12_COMPARISON_FUNC_LESS_EQUAL = 4, + D3D12_COMPARISON_FUNC_GREATER = 5, + D3D12_COMPARISON_FUNC_NOT_EQUAL = 6, + D3D12_COMPARISON_FUNC_GREATER_EQUAL = 7, + D3D12_COMPARISON_FUNC_ALWAYS = 8, +} D3D12_COMPARISON_FUNC; + +typedef struct D3D12_STATIC_SAMPLER_DESC +{ + D3D12_FILTER Filter; + D3D12_TEXTURE_ADDRESS_MODE AddressU; + D3D12_TEXTURE_ADDRESS_MODE AddressV; + D3D12_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D12_COMPARISON_FUNC ComparisonFunc; + D3D12_STATIC_BORDER_COLOR BorderColor; + FLOAT MinLOD; + FLOAT MaxLOD; + UINT ShaderRegister; + UINT RegisterSpace; + D3D12_SHADER_VISIBILITY ShaderVisibility; +} D3D12_STATIC_SAMPLER_DESC; + +typedef enum D3D12_ROOT_SIGNATURE_FLAGS +{ + D3D12_ROOT_SIGNATURE_FLAG_NONE = 0x00, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x01, + D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 0x02, + D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 0x04, + D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 0x08, + D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10, + D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40, + D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 0x80, + D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 0x100, + D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS = 0x200, + D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 0x400, + D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = 0x800, +} D3D12_ROOT_SIGNATURE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_SIGNATURE_FLAGS);") + +typedef struct D3D12_ROOT_SIGNATURE_DESC +{ + UINT NumParameters; + const D3D12_ROOT_PARAMETER *pParameters; + UINT NumStaticSamplers; + const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers; + D3D12_ROOT_SIGNATURE_FLAGS Flags; +} D3D12_ROOT_SIGNATURE_DESC; + +typedef struct D3D12_ROOT_SIGNATURE_DESC1 +{ + UINT NumParameters; + const D3D12_ROOT_PARAMETER1 *pParameters; + UINT NumStaticSamplers; + const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers; + D3D12_ROOT_SIGNATURE_FLAGS Flags; +} D3D12_ROOT_SIGNATURE_DESC1; + +typedef enum D3D_ROOT_SIGNATURE_VERSION +{ + D3D_ROOT_SIGNATURE_VERSION_1 = 0x1, + D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1, + D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2, +} D3D_ROOT_SIGNATURE_VERSION; + +typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC +{ + D3D_ROOT_SIGNATURE_VERSION Version; + union + { + D3D12_ROOT_SIGNATURE_DESC Desc_1_0; + D3D12_ROOT_SIGNATURE_DESC1 Desc_1_1; + }; +} D3D12_VERSIONED_ROOT_SIGNATURE_DESC; + +typedef enum D3D12_DESCRIPTOR_HEAP_TYPE +{ + D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, + D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, + D3D12_DESCRIPTOR_HEAP_TYPE_RTV, + D3D12_DESCRIPTOR_HEAP_TYPE_DSV, + D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES, +} D3D12_DESCRIPTOR_HEAP_TYPE; + +typedef enum D3D12_DESCRIPTOR_HEAP_FLAGS +{ + D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0x0, + D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1, +} D3D12_DESCRIPTOR_HEAP_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_HEAP_FLAGS);") + +typedef struct D3D12_DESCRIPTOR_HEAP_DESC +{ + D3D12_DESCRIPTOR_HEAP_TYPE Type; + UINT NumDescriptors; + D3D12_DESCRIPTOR_HEAP_FLAGS Flags; + UINT NodeMask; +} D3D12_DESCRIPTOR_HEAP_DESC; + +typedef UINT64 D3D12_GPU_VIRTUAL_ADDRESS; + +typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC +{ + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT SizeInBytes; +} D3D12_CONSTANT_BUFFER_VIEW_DESC; + +typedef enum D3D12_SRV_DIMENSION +{ + D3D12_SRV_DIMENSION_UNKNOWN = 0, + D3D12_SRV_DIMENSION_BUFFER = 1, + D3D12_SRV_DIMENSION_TEXTURE1D = 2, + D3D12_SRV_DIMENSION_TEXTURE1DARRAY = 3, + D3D12_SRV_DIMENSION_TEXTURE2D = 4, + D3D12_SRV_DIMENSION_TEXTURE2DARRAY = 5, + D3D12_SRV_DIMENSION_TEXTURE2DMS = 6, + D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY = 7, + D3D12_SRV_DIMENSION_TEXTURE3D = 8, + D3D12_SRV_DIMENSION_TEXTURECUBE = 9, + D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = 10, + D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE = 11, +} D3D12_SRV_DIMENSION; + +typedef enum D3D12_BUFFER_SRV_FLAGS +{ + D3D12_BUFFER_SRV_FLAG_NONE = 0x0, + D3D12_BUFFER_SRV_FLAG_RAW = 0x1, +} D3D12_BUFFER_SRV_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BUFFER_SRV_FLAGS);") + +typedef enum D3D12_SHADER_COMPONENT_MAPPING +{ + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 = 0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 = 1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 = 2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 = 3, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 = 4, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 = 5, +} D3D12_SHADER_COMPONENT_MAPPING; + +cpp_quote("#define D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(x, y, z, w) \\") +cpp_quote(" (((x) & D3D12_SHADER_COMPONENT_MAPPING_MASK) \\") +cpp_quote(" | (((y) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << D3D12_SHADER_COMPONENT_MAPPING_SHIFT) \\") +cpp_quote(" | (((z) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 2)) \\") +cpp_quote(" | (((w) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 3)) \\") +cpp_quote(" | D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES)") +cpp_quote("#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0, 1, 2, 3)") + +cpp_quote("#define D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(i, mapping) \\") +cpp_quote(" ((D3D12_SHADER_COMPONENT_MAPPING)(mapping >> (i * D3D12_SHADER_COMPONENT_MAPPING_SHIFT) \\") +cpp_quote(" & D3D12_SHADER_COMPONENT_MAPPING_MASK))") + +typedef struct D3D12_BUFFER_SRV +{ + UINT64 FirstElement; + UINT NumElements; + UINT StructureByteStride; + D3D12_BUFFER_SRV_FLAGS Flags; +} D3D12_BUFFER_SRV; + +typedef struct D3D12_TEX1D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + FLOAT ResourceMinLODClamp; +} D3D12_TEX1D_SRV; + +typedef struct D3D12_TEX1D_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; + FLOAT ResourceMinLODClamp; +} D3D12_TEX1D_ARRAY_SRV; + +typedef struct D3D12_TEX2D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT PlaneSlice; + FLOAT ResourceMinLODClamp; +} D3D12_TEX2D_SRV; + +typedef struct D3D12_TEX2D_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; + FLOAT ResourceMinLODClamp; +} D3D12_TEX2D_ARRAY_SRV; + +typedef struct D3D12_TEX2DMS_SRV +{ + UINT UnusedField_NothingToDefine; +} D3D12_TEX2DMS_SRV; + +typedef struct D3D12_TEX2DMS_ARRAY_SRV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX2DMS_ARRAY_SRV; + +typedef struct D3D12_TEX3D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + FLOAT ResourceMinLODClamp; +} D3D12_TEX3D_SRV; + +typedef struct D3D12_TEXCUBE_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + FLOAT ResourceMinLODClamp; +} D3D12_TEXCUBE_SRV; + +typedef struct D3D12_TEXCUBE_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT First2DArrayFace; + UINT NumCubes; + FLOAT ResourceMinLODClamp; +} D3D12_TEXCUBE_ARRAY_SRV; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV +{ + D3D12_GPU_VIRTUAL_ADDRESS Location; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV; + +typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D12_SRV_DIMENSION ViewDimension; + UINT Shader4ComponentMapping; + union + { + D3D12_BUFFER_SRV Buffer; + D3D12_TEX1D_SRV Texture1D; + D3D12_TEX1D_ARRAY_SRV Texture1DArray; + D3D12_TEX2D_SRV Texture2D; + D3D12_TEX2D_ARRAY_SRV Texture2DArray; + D3D12_TEX2DMS_SRV Texture2DMS; + D3D12_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D12_TEX3D_SRV Texture3D; + D3D12_TEXCUBE_SRV TextureCube; + D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV RaytracingAccelerationStructure; + }; +} D3D12_SHADER_RESOURCE_VIEW_DESC; + +typedef enum D3D12_UAV_DIMENSION +{ + D3D12_UAV_DIMENSION_UNKNOWN = 0, + D3D12_UAV_DIMENSION_BUFFER = 1, + D3D12_UAV_DIMENSION_TEXTURE1D = 2, + D3D12_UAV_DIMENSION_TEXTURE1DARRAY = 3, + D3D12_UAV_DIMENSION_TEXTURE2D = 4, + D3D12_UAV_DIMENSION_TEXTURE2DARRAY = 5, + D3D12_UAV_DIMENSION_TEXTURE3D = 8, +} D3D12_UAV_DIMENSION; + +typedef enum D3D12_BUFFER_UAV_FLAGS +{ + D3D12_BUFFER_UAV_FLAG_NONE = 0x0, + D3D12_BUFFER_UAV_FLAG_RAW = 0x1, +} D3D12_BUFFER_UAV_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BUFFER_UAV_FLAGS);") + +typedef struct D3D12_BUFFER_UAV +{ + UINT64 FirstElement; + UINT NumElements; + UINT StructureByteStride; + UINT64 CounterOffsetInBytes; + D3D12_BUFFER_UAV_FLAGS Flags; +} D3D12_BUFFER_UAV; + +typedef struct D3D12_TEX1D_UAV +{ + UINT MipSlice; +} D3D12_TEX1D_UAV; + +typedef struct D3D12_TEX1D_ARRAY_UAV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX1D_ARRAY_UAV; + +typedef struct D3D12_TEX2D_UAV +{ + UINT MipSlice; + UINT PlaneSlice; +} D3D12_TEX2D_UAV; + +typedef struct D3D12_TEX2D_ARRAY_UAV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; +} D3D12_TEX2D_ARRAY_UAV; + +typedef struct D3D12_TEX3D_UAV +{ + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D12_TEX3D_UAV; + +typedef struct D3D12_UNORDERED_ACCESS_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D12_UAV_DIMENSION ViewDimension; + union + { + D3D12_BUFFER_UAV Buffer; + D3D12_TEX1D_UAV Texture1D; + D3D12_TEX1D_ARRAY_UAV Texture1DArray; + D3D12_TEX2D_UAV Texture2D; + D3D12_TEX2D_ARRAY_UAV Texture2DArray; + D3D12_TEX3D_UAV Texture3D; + }; +} D3D12_UNORDERED_ACCESS_VIEW_DESC; + +typedef enum D3D12_RTV_DIMENSION +{ + D3D12_RTV_DIMENSION_UNKNOWN = 0, + D3D12_RTV_DIMENSION_BUFFER = 1, + D3D12_RTV_DIMENSION_TEXTURE1D = 2, + D3D12_RTV_DIMENSION_TEXTURE1DARRAY = 3, + D3D12_RTV_DIMENSION_TEXTURE2D = 4, + D3D12_RTV_DIMENSION_TEXTURE2DARRAY = 5, + D3D12_RTV_DIMENSION_TEXTURE2DMS = 6, + D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY = 7, + D3D12_RTV_DIMENSION_TEXTURE3D = 8, +} D3D12_RTV_DIMENSION; + +typedef struct D3D12_BUFFER_RTV +{ + UINT64 FirstElement; + UINT NumElements; +} D3D12_BUFFER_RTV; + +typedef struct D3D12_TEX1D_RTV +{ + UINT MipSlice; +} D3D12_TEX1D_RTV; + +typedef struct D3D12_TEX1D_ARRAY_RTV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX1D_ARRAY_RTV; + +typedef struct D3D12_TEX2D_RTV +{ + UINT MipSlice; + UINT PlaneSlice; +} D3D12_TEX2D_RTV; + +typedef struct D3D12_TEX2D_ARRAY_RTV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; +} D3D12_TEX2D_ARRAY_RTV; + +typedef struct D3D12_TEX2DMS_RTV +{ + UINT UnusedField_NothingToDefine; +} D3D12_TEX2DMS_RTV; + +typedef struct D3D12_TEX2DMS_ARRAY_RTV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX2DMS_ARRAY_RTV; + +typedef struct D3D12_TEX3D_RTV +{ + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D12_TEX3D_RTV; + +typedef struct D3D12_RENDER_TARGET_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D12_RTV_DIMENSION ViewDimension; + union + { + D3D12_BUFFER_RTV Buffer; + D3D12_TEX1D_RTV Texture1D; + D3D12_TEX1D_ARRAY_RTV Texture1DArray; + D3D12_TEX2D_RTV Texture2D; + D3D12_TEX2D_ARRAY_RTV Texture2DArray; + D3D12_TEX2DMS_RTV Texture2DMS; + D3D12_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D12_TEX3D_RTV Texture3D; + }; +} D3D12_RENDER_TARGET_VIEW_DESC; + +typedef enum D3D12_DSV_DIMENSION +{ + D3D12_DSV_DIMENSION_UNKNOWN = 0, + D3D12_DSV_DIMENSION_TEXTURE1D = 1, + D3D12_DSV_DIMENSION_TEXTURE1DARRAY = 2, + D3D12_DSV_DIMENSION_TEXTURE2D = 3, + D3D12_DSV_DIMENSION_TEXTURE2DARRAY = 4, + D3D12_DSV_DIMENSION_TEXTURE2DMS = 5, + D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY = 6, +} D3D12_DSV_DIMENSION; + +typedef enum D3D12_DSV_FLAGS +{ + D3D12_DSV_FLAG_NONE = 0x0, + D3D12_DSV_FLAG_READ_ONLY_DEPTH = 0x1, + D3D12_DSV_FLAG_READ_ONLY_STENCIL = 0x2, +} D3D12_DSV_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DSV_FLAGS);") + +typedef struct D3D12_TEX1D_DSV +{ + UINT MipSlice; +} D3D12_TEX1D_DSV; + +typedef struct D3D12_TEX1D_ARRAY_DSV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX1D_ARRAY_DSV; + +typedef struct D3D12_TEX2D_DSV +{ + UINT MipSlice; +} D3D12_TEX2D_DSV; + +typedef struct D3D12_TEX2D_ARRAY_DSV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX2D_ARRAY_DSV; + +typedef struct D3D12_TEX2DMS_DSV +{ + UINT UnusedField_NothingToDefine; +} D3D12_TEX2DMS_DSV; + +typedef struct D3D12_TEX2DMS_ARRAY_DSV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D12_TEX2DMS_ARRAY_DSV; + +typedef struct D3D12_DEPTH_STENCIL_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D12_DSV_DIMENSION ViewDimension; + D3D12_DSV_FLAGS Flags; + union + { + D3D12_TEX1D_DSV Texture1D; + D3D12_TEX1D_ARRAY_DSV Texture1DArray; + D3D12_TEX2D_DSV Texture2D; + D3D12_TEX2D_ARRAY_DSV Texture2DArray; + D3D12_TEX2DMS_DSV Texture2DMS; + D3D12_TEX2DMS_ARRAY_DSV Texture2DMSArray; + }; +} D3D12_DEPTH_STENCIL_VIEW_DESC; + +typedef struct D3D12_SAMPLER_DESC +{ + D3D12_FILTER Filter; + D3D12_TEXTURE_ADDRESS_MODE AddressU; + D3D12_TEXTURE_ADDRESS_MODE AddressV; + D3D12_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D12_COMPARISON_FUNC ComparisonFunc; + FLOAT BorderColor[4]; + FLOAT MinLOD; + FLOAT MaxLOD; +} D3D12_SAMPLER_DESC; + +typedef struct D3D12_CPU_DESCRIPTOR_HANDLE +{ + SIZE_T ptr; +} D3D12_CPU_DESCRIPTOR_HANDLE; + +typedef struct D3D12_GPU_DESCRIPTOR_HANDLE +{ + UINT64 ptr; +} D3D12_GPU_DESCRIPTOR_HANDLE; + +typedef enum D3D12_STENCIL_OP +{ + D3D12_STENCIL_OP_KEEP = 1, + D3D12_STENCIL_OP_ZERO = 2, + D3D12_STENCIL_OP_REPLACE = 3, + D3D12_STENCIL_OP_INCR_SAT = 4, + D3D12_STENCIL_OP_DECR_SAT = 5, + D3D12_STENCIL_OP_INVERT = 6, + D3D12_STENCIL_OP_INCR = 7, + D3D12_STENCIL_OP_DECR = 8, +} D3D12_STENCIL_OP; + +typedef struct D3D12_DEPTH_STENCILOP_DESC +{ + D3D12_STENCIL_OP StencilFailOp; + D3D12_STENCIL_OP StencilDepthFailOp; + D3D12_STENCIL_OP StencilPassOp; + D3D12_COMPARISON_FUNC StencilFunc; +} D3D12_DEPTH_STENCILOP_DESC; + +typedef enum D3D12_DEPTH_WRITE_MASK +{ + D3D12_DEPTH_WRITE_MASK_ZERO = 0, + D3D12_DEPTH_WRITE_MASK_ALL = 1, +} D3D12_DEPTH_WRITE_MASK; + +typedef struct D3D12_DEPTH_STENCIL_DESC +{ + BOOL DepthEnable; + D3D12_DEPTH_WRITE_MASK DepthWriteMask; + D3D12_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D12_DEPTH_STENCILOP_DESC FrontFace; + D3D12_DEPTH_STENCILOP_DESC BackFace; +} D3D12_DEPTH_STENCIL_DESC; + +typedef struct D3D12_DEPTH_STENCIL_DESC1 +{ + BOOL DepthEnable; + D3D12_DEPTH_WRITE_MASK DepthWriteMask; + D3D12_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D12_DEPTH_STENCILOP_DESC FrontFace; + D3D12_DEPTH_STENCILOP_DESC BackFace; + BOOL DepthBoundsTestEnable; +} D3D12_DEPTH_STENCIL_DESC1; + +typedef enum D3D12_BLEND +{ + D3D12_BLEND_ZERO = 1, + D3D12_BLEND_ONE = 2, + D3D12_BLEND_SRC_COLOR = 3, + D3D12_BLEND_INV_SRC_COLOR = 4, + D3D12_BLEND_SRC_ALPHA = 5, + D3D12_BLEND_INV_SRC_ALPHA = 6, + D3D12_BLEND_DEST_ALPHA = 7, + D3D12_BLEND_INV_DEST_ALPHA = 8, + D3D12_BLEND_DEST_COLOR = 9, + D3D12_BLEND_INV_DEST_COLOR = 10, + D3D12_BLEND_SRC_ALPHA_SAT = 11, + D3D12_BLEND_BLEND_FACTOR = 14, + D3D12_BLEND_INV_BLEND_FACTOR = 15, + D3D12_BLEND_SRC1_COLOR = 16, + D3D12_BLEND_INV_SRC1_COLOR = 17, + D3D12_BLEND_SRC1_ALPHA = 18, + D3D12_BLEND_INV_SRC1_ALPHA = 19, + D3D12_BLEND_ALPHA_FACTOR = 20, + D3D12_BLEND_INV_ALPHA_FACTOR = 21, +} D3D12_BLEND; + +typedef enum D3D12_BLEND_OP +{ + D3D12_BLEND_OP_ADD = 1, + D3D12_BLEND_OP_SUBTRACT = 2, + D3D12_BLEND_OP_REV_SUBTRACT = 3, + D3D12_BLEND_OP_MIN = 4, + D3D12_BLEND_OP_MAX = 5, +} D3D12_BLEND_OP; + +typedef enum D3D12_LOGIC_OP +{ + D3D12_LOGIC_OP_CLEAR = 0x0, + D3D12_LOGIC_OP_SET = 0x1, + D3D12_LOGIC_OP_COPY = 0x2, + D3D12_LOGIC_OP_COPY_INVERTED = 0x3, + D3D12_LOGIC_OP_NOOP = 0x4, + D3D12_LOGIC_OP_INVERT = 0x5, + D3D12_LOGIC_OP_AND = 0x6, + D3D12_LOGIC_OP_NAND = 0x7, + D3D12_LOGIC_OP_OR = 0x8, + D3D12_LOGIC_OP_NOR = 0x9, + D3D12_LOGIC_OP_XOR = 0xa, + D3D12_LOGIC_OP_EQUIV = 0xb, + D3D12_LOGIC_OP_AND_REVERSE = 0xc, + D3D12_LOGIC_OP_AND_INVERTED = 0xd, + D3D12_LOGIC_OP_OR_REVERSE = 0xe, + D3D12_LOGIC_OP_OR_INVERTED = 0xf, +} D3D12_LOGIC_OP; + +typedef enum D3D12_COLOR_WRITE_ENABLE +{ + D3D12_COLOR_WRITE_ENABLE_RED = 0x1, + D3D12_COLOR_WRITE_ENABLE_GREEN = 0x2, + D3D12_COLOR_WRITE_ENABLE_BLUE = 0x4, + D3D12_COLOR_WRITE_ENABLE_ALPHA = 0x8, + D3D12_COLOR_WRITE_ENABLE_ALL = (D3D12_COLOR_WRITE_ENABLE_RED + | D3D12_COLOR_WRITE_ENABLE_GREEN | D3D12_COLOR_WRITE_ENABLE_BLUE + | D3D12_COLOR_WRITE_ENABLE_ALPHA), +} D3D12_COLOR_WRITE_ENABLE; + +typedef struct D3D12_RENDER_TARGET_BLEND_DESC +{ + BOOL BlendEnable; + BOOL LogicOpEnable; + D3D12_BLEND SrcBlend; + D3D12_BLEND DestBlend; + D3D12_BLEND_OP BlendOp; + D3D12_BLEND SrcBlendAlpha; + D3D12_BLEND DestBlendAlpha; + D3D12_BLEND_OP BlendOpAlpha; + D3D12_LOGIC_OP LogicOp; + UINT8 RenderTargetWriteMask; +} D3D12_RENDER_TARGET_BLEND_DESC; + +typedef struct D3D12_BLEND_DESC +{ + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + D3D12_RENDER_TARGET_BLEND_DESC RenderTarget[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; +} D3D12_BLEND_DESC; + +typedef enum D3D12_FILL_MODE +{ + D3D12_FILL_MODE_WIREFRAME = 2, + D3D12_FILL_MODE_SOLID = 3, +} D3D12_FILL_MODE; + +typedef enum D3D12_CULL_MODE +{ + D3D12_CULL_MODE_NONE = 1, + D3D12_CULL_MODE_FRONT = 2, + D3D12_CULL_MODE_BACK = 3, +} D3D12_CULL_MODE; + +typedef enum D3D12_CONSERVATIVE_RASTERIZATION_MODE +{ + D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF = 0, + D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON = 1, +} D3D12_CONSERVATIVE_RASTERIZATION_MODE; + +typedef struct D3D12_RASTERIZER_DESC +{ + D3D12_FILL_MODE FillMode; + D3D12_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; + UINT ForcedSampleCount; + D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; +} D3D12_RASTERIZER_DESC; + +typedef struct D3D12_SO_DECLARATION_ENTRY +{ + UINT Stream; + const char *SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; +} D3D12_SO_DECLARATION_ENTRY; + +typedef struct D3D12_STREAM_OUTPUT_DESC +{ + const D3D12_SO_DECLARATION_ENTRY *pSODeclaration; + UINT NumEntries; + const UINT *pBufferStrides; + UINT NumStrides; + UINT RasterizedStream; +} D3D12_STREAM_OUTPUT_DESC; + +typedef enum D3D12_INPUT_CLASSIFICATION +{ + D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA = 0, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA = 1, +} D3D12_INPUT_CLASSIFICATION; + +typedef struct D3D12_INPUT_ELEMENT_DESC +{ + const char *SemanticName; + UINT SemanticIndex; + DXGI_FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + D3D12_INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; +} D3D12_INPUT_ELEMENT_DESC; + +typedef struct D3D12_INPUT_LAYOUT_DESC +{ + const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs; + UINT NumElements; +} D3D12_INPUT_LAYOUT_DESC; + +typedef enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE +{ + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED = 0, + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF = 1, + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = 2, +} D3D12_INDEX_BUFFER_STRIP_CUT_VALUE; + +typedef D3D_PRIMITIVE_TOPOLOGY D3D12_PRIMITIVE_TOPOLOGY; + +typedef D3D_PRIMITIVE D3D12_PRIMITIVE; + +typedef enum D3D12_PRIMITIVE_TOPOLOGY_TYPE +{ + D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = 0, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT = 1, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE = 2, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE = 3, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH = 4, +} D3D12_PRIMITIVE_TOPOLOGY_TYPE; + +typedef struct D3D12_CACHED_PIPELINE_STATE +{ + const void *pCachedBlob; + SIZE_T CachedBlobSizeInBytes; +} D3D12_CACHED_PIPELINE_STATE; + +typedef enum D3D12_PIPELINE_STATE_FLAGS +{ + D3D12_PIPELINE_STATE_FLAG_NONE = 0x0, + D3D12_PIPELINE_STATE_FLAG_DEBUG = 0x1, +} D3D12_PIPELINE_STATE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PIPELINE_STATE_FLAGS);") + +typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC +{ + ID3D12RootSignature *pRootSignature; + D3D12_SHADER_BYTECODE VS; + D3D12_SHADER_BYTECODE PS; + D3D12_SHADER_BYTECODE DS; + D3D12_SHADER_BYTECODE HS; + D3D12_SHADER_BYTECODE GS; + D3D12_STREAM_OUTPUT_DESC StreamOutput; + D3D12_BLEND_DESC BlendState; + UINT SampleMask; + D3D12_RASTERIZER_DESC RasterizerState; + D3D12_DEPTH_STENCIL_DESC DepthStencilState; + D3D12_INPUT_LAYOUT_DESC InputLayout; + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue; + D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType; + UINT NumRenderTargets; + DXGI_FORMAT RTVFormats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; + DXGI_FORMAT DSVFormat; + DXGI_SAMPLE_DESC SampleDesc; + UINT NodeMask; + D3D12_CACHED_PIPELINE_STATE CachedPSO; + D3D12_PIPELINE_STATE_FLAGS Flags; +} D3D12_GRAPHICS_PIPELINE_STATE_DESC; + +typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC +{ + ID3D12RootSignature *pRootSignature; + D3D12_SHADER_BYTECODE CS; + UINT NodeMask; + D3D12_CACHED_PIPELINE_STATE CachedPSO; + D3D12_PIPELINE_STATE_FLAGS Flags; +} D3D12_COMPUTE_PIPELINE_STATE_DESC; + +typedef struct D3D12_PIPELINE_STATE_STREAM_DESC +{ + SIZE_T SizeInBytes; + void *pPipelineStateSubobjectStream; +} D3D12_PIPELINE_STATE_STREAM_DESC; + +struct D3D12_RT_FORMAT_ARRAY +{ + DXGI_FORMAT RTFormats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; + UINT NumRenderTargets; +}; + +typedef enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE +{ + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE = 0x0, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS = 0x1, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS = 0x2, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS = 0x3, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS = 0x4, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS = 0x5, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS = 0x6, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = 0x7, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND = 0x8, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = 0x9, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER = 0xa, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = 0xb, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = 0xc, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = 0xd, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = 0xe, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = 0xf, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = 0x10, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = 0x11, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x12, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO = 0x13, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS = 0x14, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = 0x15, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = 0x16, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS = 0x18, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS = 0x19, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = 0x1a, +} D3D12_PIPELINE_STATE_SUBOBJECT_TYPE; + +typedef struct D3D12_VIEW_INSTANCE_LOCATION +{ + UINT ViewportArrayIndex; + UINT RenderTargetArrayIndex; +} D3D12_VIEW_INSTANCE_LOCATION; + +typedef enum D3D12_VIEW_INSTANCING_FLAGS +{ + D3D12_VIEW_INSTANCING_FLAG_NONE = 0x0, + D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 0x1, +} D3D12_VIEW_INSTANCING_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIEW_INSTANCING_FLAGS);") + +typedef struct D3D12_VIEW_INSTANCING_DESC +{ + UINT ViewInstanceCount; + const D3D12_VIEW_INSTANCE_LOCATION *pViewInstanceLocations; + D3D12_VIEW_INSTANCING_FLAGS Flags; +} D3D12_VIEW_INSTANCING_DESC; + +typedef enum D3D12_COMMAND_LIST_TYPE +{ + D3D12_COMMAND_LIST_TYPE_DIRECT = 0, + D3D12_COMMAND_LIST_TYPE_BUNDLE = 1, + D3D12_COMMAND_LIST_TYPE_COMPUTE = 2, + D3D12_COMMAND_LIST_TYPE_COPY = 3, + D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE = 4, + D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS = 5, + D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE = 6, +} D3D12_COMMAND_LIST_TYPE; + +typedef enum D3D12_COMMAND_QUEUE_PRIORITY +{ + D3D12_COMMAND_QUEUE_PRIORITY_NORMAL = 0, + D3D12_COMMAND_QUEUE_PRIORITY_HIGH = 100, + D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME = 10000, +} D3D12_COMMAND_QUEUE_PRIORITY; + +typedef enum D3D12_COMMAND_QUEUE_FLAGS +{ + D3D12_COMMAND_QUEUE_FLAG_NONE = 0x0, + D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1, +} D3D12_COMMAND_QUEUE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_QUEUE_FLAGS);") + +typedef struct D3D12_COMMAND_QUEUE_DESC +{ + D3D12_COMMAND_LIST_TYPE Type; + INT Priority; + D3D12_COMMAND_QUEUE_FLAGS Flags; + UINT NodeMask; +} D3D12_COMMAND_QUEUE_DESC; + +typedef struct D3D12_FEATURE_DATA_ARCHITECTURE +{ + UINT NodeIndex; + BOOL TileBasedRenderer; + BOOL UMA; + BOOL CacheCoherentUMA; +} D3D12_FEATURE_DATA_ARCHITECTURE; + +typedef struct D3D12_FEATURE_DATA_FORMAT_INFO +{ + DXGI_FORMAT Format; + UINT8 PlaneCount; +} D3D12_FEATURE_DATA_FORMAT_INFO; + +typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS +{ + UINT NumFeatureLevels; + const D3D_FEATURE_LEVEL *pFeatureLevelsRequested; + D3D_FEATURE_LEVEL MaxSupportedFeatureLevel; +} D3D12_FEATURE_DATA_FEATURE_LEVELS; + +typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE +{ + D3D_ROOT_SIGNATURE_VERSION HighestVersion; +} D3D12_FEATURE_DATA_ROOT_SIGNATURE; + +typedef struct D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT +{ + UINT MaxGPUVirtualAddressBitsPerResource; + UINT MaxGPUVirtualAddressBitsPerProcess; +} D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT; + +typedef enum D3D_SHADER_MODEL +{ + D3D_SHADER_MODEL_5_1 = 0x51, + D3D_SHADER_MODEL_6_0 = 0x60, + D3D_SHADER_MODEL_6_1 = 0x61, + D3D_SHADER_MODEL_6_2 = 0x62, + D3D_SHADER_MODEL_6_3 = 0x63, + D3D_SHADER_MODEL_6_4 = 0x64, + D3D_SHADER_MODEL_6_5 = 0x65, + D3D_SHADER_MODEL_6_6 = 0x66, + D3D_SHADER_MODEL_6_7 = 0x67, + D3D_HIGHEST_SHADER_MODEL = D3D_SHADER_MODEL_6_7, +} D3D_SHADER_MODEL; + +typedef struct D3D12_FEATURE_DATA_SHADER_MODEL +{ + D3D_SHADER_MODEL HighestShaderModel; +} D3D12_FEATURE_DATA_SHADER_MODEL; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1 +{ + BOOL WaveOps; + UINT WaveLaneCountMin; + UINT WaveLaneCountMax; + UINT TotalLaneCount; + BOOL ExpandedComputeResourceStates; + BOOL Int64ShaderOps; +} D3D12_FEATURE_DATA_D3D12_OPTIONS1; + +typedef struct D3D12_FEATURE_DATA_ARCHITECTURE1 +{ + UINT NodeIndex; + BOOL TileBasedRenderer; + BOOL UMA; + BOOL CacheCoherentUMA; + BOOL IsolatedMMU; +} D3D12_FEATURE_DATA_ARCHITECTURE1; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2 +{ + BOOL DepthBoundsTestSupported; + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS2; + +typedef struct D3D12_FEATURE_DATA_SHADER_CACHE +{ + D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags; +} D3D12_FEATURE_DATA_SHADER_CACHE; + +typedef struct D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY +{ + D3D12_COMMAND_LIST_TYPE CommandListType; + UINT Priority; + BOOL PriorityForTypeIsSupported; +} D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3 +{ + BOOL CopyQueueTimestampQueriesSupported; + BOOL CastingFullyTypedFormatSupported; + D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags; + D3D12_VIEW_INSTANCING_TIER ViewInstancingTier; + BOOL BarycentricsSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS3; + +typedef struct D3D12_FEATURE_DATA_EXISTING_HEAPS +{ + BOOL Supported; +} D3D12_FEATURE_DATA_EXISTING_HEAPS; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS4 +{ + BOOL MSAA64KBAlignedTextureSupported; + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier; + BOOL Native16BitShaderOpsSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS4; + +typedef struct D3D12_FEATURE_DATA_SERIALIZATION +{ + UINT NodeIndex; + D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier; +} D3D12_FEATURE_DATA_SERIALIZATION; + +typedef struct D3D12_FEATURE_DATA_CROSS_NODE +{ + D3D12_CROSS_NODE_SHARING_TIER SharingTier; + BOOL AtomicShaderInstructions; +} D3D12_FEATURE_DATA_CROSS_NODE; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5 +{ + BOOL SRVOnlyTiledResourceTier3; + D3D12_RENDER_PASS_TIER RenderPassesTier; + D3D12_RAYTRACING_TIER RaytracingTier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS5; + +typedef enum D3D12_VARIABLE_SHADING_RATE_TIER +{ + D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = 0x0, + D3D12_VARIABLE_SHADING_RATE_TIER_1 = 0x1, + D3D12_VARIABLE_SHADING_RATE_TIER_2 = 0x2, +} D3D12_VARIABLE_SHADING_RATE_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS6 +{ + BOOL AdditionalShadingRatesSupported; + BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing; + D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier; + UINT ShadingRateImageTileSize; + BOOL BackgroundProcessingSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS6; + +typedef enum D3D12_MESH_SHADER_TIER +{ + D3D12_MESH_SHADER_TIER_NOT_SUPPORTED = 0x0, + D3D12_MESH_SHADER_TIER_1 = 0xa, +} D3D12_MESH_SHADER_TIER; + +typedef enum D3D12_SAMPLER_FEEDBACK_TIER +{ + D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED = 0x0, + D3D12_SAMPLER_FEEDBACK_TIER_0_9 = 0x5a, + D3D12_SAMPLER_FEEDBACK_TIER_1_0 = 0x64, +} D3D12_SAMPLER_FEEDBACK_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS7 +{ + D3D12_MESH_SHADER_TIER MeshShaderTier; + D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS7; + +typedef struct D3D12_FEATURE_DATA_QUERY_META_COMMAND +{ + GUID CommandId; + UINT NodeMask; + const void *pQueryInputData; + SIZE_T QueryInputDataSizeInBytes; + void *pQueryOutputData; + SIZE_T QueryOutputDataSizeInBytes; +} D3D12_FEATURE_DATA_QUERY_META_COMMAND; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS8 +{ + BOOL UnalignedBlockTexturesSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS8; + +typedef enum D3D12_WAVE_MMA_TIER +{ + D3D12_WAVE_MMA_TIER_NOT_SUPPORTED = 0x0, + D3D12_WAVE_MMA_TIER_1_0 = 0xa, +} D3D12_WAVE_MMA_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS9 +{ + BOOL MeshShaderPipelineStatsSupported; + BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex; + BOOL AtomicInt64OnTypedResourceSupported; + BOOL AtomicInt64OnGroupSharedSupported; + BOOL DerivativesInMeshAndAmplificationShadersSupported; + D3D12_WAVE_MMA_TIER WaveMMATier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS9; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS10 +{ + BOOL VariableRateShadingSumCombinerSupported; + BOOL MeshShaderPerPrimitiveShadingRateSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS10; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS11 +{ + BOOL AtomicInt64OnDescriptorHeapResourceSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS11; + +typedef enum D3D12_TRI_STATE +{ + D3D12_TRI_STATE_UNKNOWN = -0x1, + D3D12_TRI_STATE_FALSE = 0x0, + D3D12_TRI_STATE_TRUE = 0x1, +} D3D12_TRI_STATE; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS12 +{ + D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives; + BOOL EnhancedBarriersSupported; + BOOL RelaxedFormatCastingSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS12; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS13 +{ + BOOL UnrestrictedBufferTextureCopyPitchSupported; + BOOL UnrestrictedVertexElementAlignmentSupported; + BOOL InvertedViewportHeightFlipsYSupported; + BOOL InvertedViewportDepthFlipsZSupported; + BOOL TextureCopyBetweenDimensionsSupported; + BOOL AlphaBlendFactorSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS13; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS14 +{ + BOOL AdvancedTextureOpsSupported; + BOOL WriteableMSAATexturesSupported; + BOOL IndependentFrontAndBackStencilRefMaskSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS14; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS15 +{ + BOOL TriangleFanSupported; + BOOL DynamicIndexBufferStripCutSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS15; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS16 +{ + BOOL DynamicDepthBiasSupported; + BOOL GPUUploadHeapSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS16; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS17 +{ + BOOL NonNormalizedCoordinateSamplersSupported; + BOOL ManualWriteTrackingResourceSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS17; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS18 +{ + BOOL RenderPassesValid; +} D3D12_FEATURE_DATA_D3D12_OPTIONS18; + +typedef enum D3D12_FEATURE +{ + D3D12_FEATURE_D3D12_OPTIONS = 0, + D3D12_FEATURE_ARCHITECTURE = 1, + D3D12_FEATURE_FEATURE_LEVELS = 2, + D3D12_FEATURE_FORMAT_SUPPORT = 3, + D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4, + D3D12_FEATURE_FORMAT_INFO = 5, + D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6, + D3D12_FEATURE_SHADER_MODEL = 7, + D3D12_FEATURE_D3D12_OPTIONS1 = 8, + D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = 10, + D3D12_FEATURE_ROOT_SIGNATURE = 12, + D3D12_FEATURE_ARCHITECTURE1 = 16, + D3D12_FEATURE_D3D12_OPTIONS2 = 18, + D3D12_FEATURE_SHADER_CACHE = 19, + D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20, + D3D12_FEATURE_D3D12_OPTIONS3 = 21, + D3D12_FEATURE_EXISTING_HEAPS = 22, + D3D12_FEATURE_D3D12_OPTIONS4 = 23, + D3D12_FEATURE_SERIALIZATION = 24, + D3D12_FEATURE_CROSS_NODE = 25, + D3D12_FEATURE_D3D12_OPTIONS5 = 27, + D3D12_FEATURE_DISPLAYABLE = 28, + D3D12_FEATURE_D3D12_OPTIONS6 = 30, + D3D12_FEATURE_QUERY_META_COMMAND = 31, + D3D12_FEATURE_D3D12_OPTIONS7 = 32, + D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33, + D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES = 34, + D3D12_FEATURE_D3D12_OPTIONS8 = 36, + D3D12_FEATURE_D3D12_OPTIONS9 = 37, + D3D12_FEATURE_D3D12_OPTIONS10 = 39, + D3D12_FEATURE_D3D12_OPTIONS11 = 40, + D3D12_FEATURE_D3D12_OPTIONS12 = 41, + D3D12_FEATURE_D3D12_OPTIONS13 = 42, + D3D12_FEATURE_D3D12_OPTIONS14 = 43, + D3D12_FEATURE_D3D12_OPTIONS15 = 44, + D3D12_FEATURE_D3D12_OPTIONS16 = 45, + D3D12_FEATURE_D3D12_OPTIONS17 = 46, + D3D12_FEATURE_D3D12_OPTIONS18 = 47, +} D3D12_FEATURE; + +typedef struct D3D12_MEMCPY_DEST +{ + void *pData; + SIZE_T RowPitch; + SIZE_T SlicePitch; +} D3D12_MEMCPY_DEST; + +typedef struct D3D12_SUBRESOURCE_DATA +{ + const void *pData; + LONG_PTR RowPitch; + LONG_PTR SlicePitch; +} D3D12_SUBRESOURCE_DATA; + +typedef enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS +{ + D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = 0x0, + D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = 0x1, + D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0x0, +} D3D12_MULTIPLE_FENCE_WAIT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MULTIPLE_FENCE_WAIT_FLAGS);") + +typedef enum D3D12_RESIDENCY_PRIORITY +{ + D3D12_RESIDENCY_PRIORITY_MINIMUM = 0x28000000, + D3D12_RESIDENCY_PRIORITY_LOW = 0x50000000, + D3D12_RESIDENCY_PRIORITY_NORMAL = 0x78000000, + D3D12_RESIDENCY_PRIORITY_HIGH = 0xa0010000, + D3D12_RESIDENCY_PRIORITY_MAXIMUM = 0xc8000000, +} D3D12_RESIDENCY_PRIORITY; + +typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER +{ + D3D12_GPU_VIRTUAL_ADDRESS Dest; + UINT32 Value; +} D3D12_WRITEBUFFERIMMEDIATE_PARAMETER; + +typedef enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS +{ + D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0, +} D3D12_PROTECTED_RESOURCE_SESSION_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_FLAGS);") + +typedef enum D3D12_PROTECTED_SESSION_STATUS +{ + D3D12_PROTECTED_SESSION_STATUS_OK = 0, + D3D12_PROTECTED_SESSION_STATUS_INVALID = 1, +} D3D12_PROTECTED_SESSION_STATUS; + +typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC +{ + UINT NodeMask; + D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags; +} D3D12_PROTECTED_RESOURCE_SESSION_DESC; + +[ + uuid(c4fec28f-7966-4e95-9f94-f431cb56c3b8), + object, + local, + pointer_default(unique) +] +interface ID3D12Object : IUnknown +{ + HRESULT GetPrivateData(REFGUID guid, UINT *data_size, void *data); + HRESULT SetPrivateData(REFGUID guid, UINT data_size, const void *data); + HRESULT SetPrivateDataInterface(REFGUID guid, const IUnknown *data); + HRESULT SetName(const WCHAR *name); +} + +[ + uuid(905db94b-a00c-4140-9df5-2b64ca9ea357), + object, + local, + pointer_default(unique) +] +interface ID3D12DeviceChild : ID3D12Object +{ + HRESULT GetDevice(REFIID riid, void **device); +} + +[ + uuid(63ee58fb-1268-4835-86da-f008ce62f0d6), + object, + local, + pointer_default(unique) +] +interface ID3D12Pageable : ID3D12DeviceChild +{ +} + +[ + uuid(6b3b2502-6e51-45b3-90ee-9884265e8df3), + object, + local, + pointer_default(unique) +] +interface ID3D12Heap : ID3D12Pageable +{ + D3D12_HEAP_DESC GetDesc(); +} + +[ + uuid(696442be-a72e-4059-bc79-5b5c98040fad), + object, + local, + pointer_default(unique) +] +interface ID3D12Resource : ID3D12Pageable +{ + HRESULT Map(UINT sub_resource, const D3D12_RANGE *read_range, void **data); + void Unmap(UINT sub_resource, const D3D12_RANGE *written_range); + + D3D12_RESOURCE_DESC GetDesc(); + + D3D12_GPU_VIRTUAL_ADDRESS GetGPUVirtualAddress(); + + HRESULT WriteToSubresource(UINT dst_sub_resource, const D3D12_BOX *dst_box, + const void *src_data, UINT src_row_pitch, UINT src_slice_pitch); + HRESULT ReadFromSubresource(void *dst_data, UINT dst_row_pitch, UINT dst_slice_pitch, + UINT src_sub_resource, const D3D12_BOX *src_box); + + HRESULT GetHeapProperties(D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS *flags); +} + +[ + uuid(7116d91c-e7e4-47ce-b8c6-ec8168f437e5), + object, + local, + pointer_default(unique) +] +interface ID3D12CommandList : ID3D12DeviceChild +{ + D3D12_COMMAND_LIST_TYPE GetType(); +} + +typedef enum D3D12_TILE_COPY_FLAGS +{ + D3D12_TILE_COPY_FLAG_NONE = 0x0, + D3D12_TILE_COPY_FLAG_NO_HAZARD = 0x1, + D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2, + D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4, +} D3D12_TILE_COPY_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_COPY_FLAGS);") + +typedef struct D3D12_INDEX_BUFFER_VIEW +{ + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT SizeInBytes; + DXGI_FORMAT Format; +} D3D12_INDEX_BUFFER_VIEW; + +typedef struct D3D12_VERTEX_BUFFER_VIEW +{ + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT SizeInBytes; + UINT StrideInBytes; +} D3D12_VERTEX_BUFFER_VIEW; + +typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW +{ + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT64 SizeInBytes; + D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation; +} D3D12_STREAM_OUTPUT_BUFFER_VIEW; + +typedef enum D3D12_CLEAR_FLAGS +{ + D3D12_CLEAR_FLAG_DEPTH = 0x1, + D3D12_CLEAR_FLAG_STENCIL = 0x2, +} D3D12_CLEAR_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_CLEAR_FLAGS);") + +typedef struct D3D12_DISCARD_REGION +{ + UINT NumRects; + const D3D12_RECT *pRects; + UINT FirstSubresource; + UINT NumSubresources; +} D3D12_DISCARD_REGION; + +typedef enum D3D12_QUERY_TYPE +{ + D3D12_QUERY_TYPE_OCCLUSION = 0, + D3D12_QUERY_TYPE_BINARY_OCCLUSION = 1, + D3D12_QUERY_TYPE_TIMESTAMP = 2, + D3D12_QUERY_TYPE_PIPELINE_STATISTICS = 3, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = 4, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7, + D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = 8, + D3D12_QUERY_TYPE_PIPELINE_STATISTICS1 = 10, +} D3D12_QUERY_TYPE; + +typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS +{ + UINT64 IAVertices; + UINT64 IAPrimitives; + UINT64 VSInvocations; + UINT64 GSInvocations; + UINT64 GSPrimitives; + UINT64 CInvocations; + UINT64 CPrimitives; + UINT64 PSInvocations; + UINT64 HSInvocations; + UINT64 DSInvocations; + UINT64 CSInvocations; +} D3D12_QUERY_DATA_PIPELINE_STATISTICS; + +typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS1 +{ + UINT64 IAVertices; + UINT64 IAPrimitives; + UINT64 VSInvocations; + UINT64 GSInvocations; + UINT64 GSPrimitives; + UINT64 CInvocations; + UINT64 CPrimitives; + UINT64 PSInvocations; + UINT64 HSInvocations; + UINT64 DSInvocations; + UINT64 CSInvocations; + UINT64 ASInvocations; + UINT64 MSInvocations; + UINT64 MSPrimitives; +} D3D12_QUERY_DATA_PIPELINE_STATISTICS1; + +typedef struct D3D12_QUERY_DATA_SO_STATISTICS +{ + UINT64 NumPrimitivesWritten; + UINT64 PrimitivesStorageNeeded; +} D3D12_QUERY_DATA_SO_STATISTICS; + +typedef enum D3D12_PREDICATION_OP +{ + D3D12_PREDICATION_OP_EQUAL_ZERO = 0, + D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = 1, +} D3D12_PREDICATION_OP; + +[ + uuid(8efb471d-616c-4f49-90f7-127bb763fa51), + object, + local, + pointer_default(unique) +] +interface ID3D12DescriptorHeap : ID3D12Pageable +{ + D3D12_DESCRIPTOR_HEAP_DESC GetDesc(); + + D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandleForHeapStart(); + D3D12_GPU_DESCRIPTOR_HANDLE GetGPUDescriptorHandleForHeapStart(); +} + +[ + uuid(0d9658ae-ed45-469e-a61d-970ec583cab4), + object, + local, + pointer_default(unique) +] +interface ID3D12QueryHeap : ID3D12Pageable +{ +} + +[ + uuid(c36a797c-ec80-4f0a-8985-a7b2475082d1), + object, + local, + pointer_default(unique) +] +interface ID3D12CommandSignature : ID3D12Pageable +{ +} + +[ + uuid(5b160d0f-ac1b-4185-8ba8-b3ae42a5a455), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList : ID3D12CommandList +{ + HRESULT Close(); + + HRESULT Reset(ID3D12CommandAllocator *allocator, ID3D12PipelineState *initial_state); + + void ClearState(ID3D12PipelineState *pipeline_state); + + void DrawInstanced(UINT vertex_count_per_instance, UINT instance_count, + UINT start_vertex_location, UINT start_instance_location); + void DrawIndexedInstanced(UINT index_count_per_instance, UINT instance_count, + UINT start_vertex_location, INT base_vertex_location, UINT start_instance_location); + + void Dispatch(UINT x, UINT u, UINT z); + + void CopyBufferRegion(ID3D12Resource *dst_buffer, UINT64 dst_offset, + ID3D12Resource *src_buffer, UINT64 src_offset, UINT64 byte_count); + void CopyTextureRegion(const D3D12_TEXTURE_COPY_LOCATION *dst, + UINT dst_x, UINT dst_y, UINT dst_z, + const D3D12_TEXTURE_COPY_LOCATION *src, const D3D12_BOX *src_box); + void CopyResource(ID3D12Resource *dst_resource, ID3D12Resource *src_resource); + + void CopyTiles(ID3D12Resource *tiled_resource, + const D3D12_TILED_RESOURCE_COORDINATE *tile_region_start_coordinate, + const D3D12_TILE_REGION_SIZE *tile_region_size, + ID3D12Resource *buffer, + UINT64 buffer_offset, + D3D12_TILE_COPY_FLAGS flags); + + void ResolveSubresource(ID3D12Resource *dst_resource, UINT dst_sub_resource, + ID3D12Resource *src_resource, UINT src_sub_resource, + DXGI_FORMAT format); + + void IASetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitive_topology); + + void RSSetViewports(UINT viewport_count, const D3D12_VIEWPORT *viewports); + void RSSetScissorRects(UINT rect_count, const D3D12_RECT *rects); + + void OMSetBlendFactor(const FLOAT blend_factor[4]); + void OMSetStencilRef(UINT stencil_ref); + + void SetPipelineState(ID3D12PipelineState *pipeline_state); + + void ResourceBarrier(UINT barrier_count, const D3D12_RESOURCE_BARRIER *barriers); + + void ExecuteBundle(ID3D12GraphicsCommandList *command_list); + + void SetDescriptorHeaps(UINT heap_count, ID3D12DescriptorHeap * const *heaps); + + void SetComputeRootSignature(ID3D12RootSignature *root_signature); + void SetGraphicsRootSignature(ID3D12RootSignature *root_signature); + + void SetComputeRootDescriptorTable(UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor); + void SetGraphicsRootDescriptorTable(UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor); + + void SetComputeRoot32BitConstant(UINT root_parameter_index, UINT data, UINT dst_offset); + void SetGraphicsRoot32BitConstant(UINT root_parameter_index, UINT data, UINT dst_offset); + + void SetComputeRoot32BitConstants(UINT root_parameter_index, UINT constant_count, const void *data, + UINT dst_offset); + void SetGraphicsRoot32BitConstants(UINT root_parameter_index, UINT constant_count, const void *data, + UINT dst_offset); + + void SetComputeRootConstantBufferView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address); + void SetGraphicsRootConstantBufferView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address); + + void SetComputeRootShaderResourceView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address); + void SetGraphicsRootShaderResourceView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address); + + void SetComputeRootUnorderedAccessView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address); + void SetGraphicsRootUnorderedAccessView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address); + + void IASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW *view); + void IASetVertexBuffers(UINT start_slot, UINT view_count, const D3D12_VERTEX_BUFFER_VIEW *views); + + void SOSetTargets(UINT start_slot, UINT view_count, const D3D12_STREAM_OUTPUT_BUFFER_VIEW *views); + + void OMSetRenderTargets(UINT render_target_descriptor_count, + const D3D12_CPU_DESCRIPTOR_HANDLE *render_target_descriptors, + BOOL single_descriptor_handle, + const D3D12_CPU_DESCRIPTOR_HANDLE *depth_stencil_descriptor); + + void ClearDepthStencilView(D3D12_CPU_DESCRIPTOR_HANDLE dsv, D3D12_CLEAR_FLAGS flags, + FLOAT depth, UINT8 stencil, UINT rect_count, const D3D12_RECT *rects); + void ClearRenderTargetView(D3D12_CPU_DESCRIPTOR_HANDLE rtv, const FLOAT color[4], + UINT rect_count, const D3D12_RECT *rects); + void ClearUnorderedAccessViewUint(D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle, + D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, const UINT values[4], + UINT rect_count, const D3D12_RECT *rects); + void ClearUnorderedAccessViewFloat(D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle, + D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, const float values[4], + UINT rect_count, const D3D12_RECT *rects); + + void DiscardResource(ID3D12Resource *resource, const D3D12_DISCARD_REGION *region); + + void BeginQuery(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index); + void EndQuery(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index); + void ResolveQueryData(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, + UINT start_index, UINT query_count, + ID3D12Resource *dst_buffer, UINT64 aligned_dst_buffer_offset); + + void SetPredication(ID3D12Resource *buffer, UINT64 aligned_buffer_offset, + D3D12_PREDICATION_OP operation); + + void SetMarker(UINT metadata, const void *data, UINT size); + void BeginEvent(UINT metadata, const void *data, UINT size); + void EndEvent(); + + void ExecuteIndirect(ID3D12CommandSignature *command_signature, + UINT max_command_count, ID3D12Resource *arg_buffer, UINT64 arg_buffer_offset, + ID3D12Resource *count_buffer, UINT64 count_buffer_offset); +} + +[ + uuid(553103fb-1fe7-4557-bb38-946d7d0e7ca7), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandList +{ + void AtomicCopyBufferUINT(ID3D12Resource *dst_buffer, UINT64 dst_offset, + ID3D12Resource *src_buffer, UINT64 src_offset, + UINT dependent_resource_count, ID3D12Resource * const *dependent_resources, + const D3D12_SUBRESOURCE_RANGE_UINT64 *dependent_sub_resource_ranges); + + void AtomicCopyBufferUINT64(ID3D12Resource *dst_buffer, UINT64 dst_offset, + ID3D12Resource *src_buffer, UINT64 src_offset, + UINT dependent_resource_count, ID3D12Resource * const *dependent_resources, + const D3D12_SUBRESOURCE_RANGE_UINT64 *dependent_sub_resource_ranges); + + void OMSetDepthBounds(FLOAT min, FLOAT max); + + void SetSamplePositions(UINT sample_count, UINT pixel_count, + D3D12_SAMPLE_POSITION *sample_positions); + + void ResolveSubresourceRegion(ID3D12Resource *dst_resource, + UINT dst_sub_resource_idx, UINT dst_x, UINT dst_y, + ID3D12Resource *src_resource, UINT src_sub_resource_idx, + D3D12_RECT *src_rect, DXGI_FORMAT format, D3D12_RESOLVE_MODE mode); + + void SetViewInstanceMask(UINT mask); +} + +[ + uuid(38c3e585-ff17-412c-9150-4fc6f9d72a28), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandList1 +{ + void WriteBufferImmediate(UINT count, + const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *parameters, + const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes); +} + +[ + uuid(a1533d18-0ac1-4084-85b9-89a96116806b), + object, + local, + pointer_default(unique) +] +interface ID3D12ProtectedSession : ID3D12DeviceChild +{ + HRESULT GetStatusFence(REFIID riid, void **fence); + + D3D12_PROTECTED_SESSION_STATUS GetSessionStatus(); +} + +typedef enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS +{ + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0x0, + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1, +} D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS);") + +typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT +{ + UINT NodeIndex; + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support; +} D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT; + +[ + uuid(6cd696f4-f289-40cc-8091-5a6c0a099c3d), + object, + local, + pointer_default(unique) +] +interface ID3D12ProtectedResourceSession : ID3D12ProtectedSession +{ + D3D12_PROTECTED_RESOURCE_SESSION_DESC GetDesc(); +} + +[ + uuid(6fda83a7-b84c-4e38-9ac8-c7bd22016b3d), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandList2 +{ + void SetProtectedResourceSession(ID3D12ProtectedResourceSession *protected_resource_session); +} + +typedef enum D3D12_TILE_RANGE_FLAGS +{ + D3D12_TILE_RANGE_FLAG_NONE = 0x0, + D3D12_TILE_RANGE_FLAG_NULL = 0x1, + D3D12_TILE_RANGE_FLAG_SKIP = 0x2, + D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 0x4 +} D3D12_TILE_RANGE_FLAGS; + +typedef enum D3D12_TILE_MAPPING_FLAGS +{ + D3D12_TILE_MAPPING_FLAG_NONE = 0x0, + D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1, +} D3D12_TILE_MAPPING_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_MAPPING_FLAGS);") + +[ + uuid(0ec870a6-5d7e-4c22-8cfc-5baae07616ed), + object, + local, + pointer_default(unique) +] +interface ID3D12CommandQueue : ID3D12Pageable +{ + void UpdateTileMappings(ID3D12Resource *resource, UINT region_count, + const D3D12_TILED_RESOURCE_COORDINATE *region_start_coordinates, + const D3D12_TILE_REGION_SIZE *region_sizes, + ID3D12Heap *heap, + UINT range_count, + const D3D12_TILE_RANGE_FLAGS *range_flags, + const UINT *heap_range_offsets, + const UINT *range_tile_counts, + D3D12_TILE_MAPPING_FLAGS flags); + + void CopyTileMappings(ID3D12Resource *dst_resource, + const D3D12_TILED_RESOURCE_COORDINATE *dst_region_start_coordinate, + ID3D12Resource *src_resource, + const D3D12_TILED_RESOURCE_COORDINATE *src_region_start_coordinate, + const D3D12_TILE_REGION_SIZE *region_size, + D3D12_TILE_MAPPING_FLAGS flags); + + void ExecuteCommandLists(UINT command_list_count, + ID3D12CommandList * const * command_lists); + + void SetMarker(UINT metadata, const void *data, UINT size); + void BeginEvent(UINT metadata, const void *data, UINT size); + void EndEvent(); + + HRESULT Signal(ID3D12Fence *fence, UINT64 value); + HRESULT Wait(ID3D12Fence *fence, UINT64 value); + + HRESULT GetTimestampFrequency(UINT64 *frequency); + HRESULT GetClockCalibration(UINT64 *gpu_timestamp, UINT64 *cpu_timestamp); + + D3D12_COMMAND_QUEUE_DESC GetDesc(); +} + +typedef enum D3D12_FENCE_FLAGS +{ + D3D12_FENCE_FLAG_NONE = 0x0, + D3D12_FENCE_FLAG_SHARED = 0x1, + D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2, + D3D12_FENCE_FLAG_NON_MONITORED = 0x4, +} D3D12_FENCE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FENCE_FLAGS);") + +typedef enum D3D12_QUERY_HEAP_TYPE +{ + D3D12_QUERY_HEAP_TYPE_OCCLUSION = 0, + D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1, + D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2, + D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3, + D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = 4, + D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = 5, + D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1 = 7, +} D3D12_QUERY_HEAP_TYPE; + +typedef struct D3D12_QUERY_HEAP_DESC +{ + D3D12_QUERY_HEAP_TYPE Type; + UINT Count; + UINT NodeMask; +} D3D12_QUERY_HEAP_DESC; + +typedef enum D3D12_INDIRECT_ARGUMENT_TYPE +{ + D3D12_INDIRECT_ARGUMENT_TYPE_DRAW, + D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED, + D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH, + D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW, + D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW, + D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT, + D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW, + D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW, + D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW, + D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS, + D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH, +} D3D12_INDIRECT_ARGUMENT_TYPE; + +typedef struct D3D12_INDIRECT_ARGUMENT_DESC +{ + D3D12_INDIRECT_ARGUMENT_TYPE Type; + union + { + struct + { + UINT Slot; + } VertexBuffer; + struct + { + UINT RootParameterIndex; + UINT DestOffsetIn32BitValues; + UINT Num32BitValuesToSet; + } Constant; + struct + { + UINT RootParameterIndex; + } ConstantBufferView; + struct + { + UINT RootParameterIndex; + } ShaderResourceView; + struct + { + UINT RootParameterIndex; + } UnorderedAccessView; + }; +} D3D12_INDIRECT_ARGUMENT_DESC; + +typedef struct D3D12_COMMAND_SIGNATURE_DESC +{ + UINT ByteStride; + UINT NumArgumentDescs; + const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs; + UINT NodeMask; +} D3D12_COMMAND_SIGNATURE_DESC; + +[ + uuid(c54a6b66-72df-4ee8-8be5-a946a1429214), + object, + local, + pointer_default(unique) +] +interface ID3D12RootSignature : ID3D12DeviceChild +{ +} + +[ + uuid(765a30f3-f624-4c6f-a828-ace948622445), + object, + local, + pointer_default(unique) +] +interface ID3D12PipelineState : ID3D12Pageable +{ + HRESULT GetCachedBlob(ID3DBlob **blob); +} + +[ + uuid(0a753dcf-c4d8-4b91-adf6-be5a60d95a76), + object, + local, + pointer_default(unique) +] +interface ID3D12Fence : ID3D12Pageable +{ + UINT64 GetCompletedValue(); + HRESULT SetEventOnCompletion(UINT64 value, HANDLE event); + HRESULT Signal(UINT64 value); +} + +[ + uuid(433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a), + object, + local, + pointer_default(unique) +] +interface ID3D12Fence1 : ID3D12Fence +{ + D3D12_FENCE_FLAGS GetCreationFlags(); +} + +[ + uuid(6102dee4-af59-4b09-b999-b44d73f09b24), + object, + local, + pointer_default(unique) +] +interface ID3D12CommandAllocator : ID3D12Pageable +{ + HRESULT Reset(); +} + +[ + uuid(189819f1-1db6-4b57-be54-1821339b85f7), + object, + local, + pointer_default(unique) +] +interface ID3D12Device : ID3D12Object +{ + UINT GetNodeCount(); + + HRESULT CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC *desc, + REFIID riid, void **command_queue); + HRESULT CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type, + REFIID riid, void **command_allocator); + HRESULT CreateGraphicsPipelineState(const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, + REFIID riid, void **pipeline_state); + HRESULT CreateComputePipelineState(const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, + REFIID riid, void **pipeline_state); + HRESULT CreateCommandList(UINT node_mask, + D3D12_COMMAND_LIST_TYPE type, + ID3D12CommandAllocator *command_allocator, + ID3D12PipelineState *initial_pipeline_state, + REFIID riid, void **command_list); + + HRESULT CheckFeatureSupport(D3D12_FEATURE feature, + void *feature_data, UINT feature_data_size); + + HRESULT CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DESC *desc, + REFIID riid, void **descriptor_heap); + UINT GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type); + + HRESULT CreateRootSignature(UINT node_mask, + const void *bytecode, SIZE_T bytecode_length, + REFIID riid, void **root_signature); + + void CreateConstantBufferView(const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc, + D3D12_CPU_DESCRIPTOR_HANDLE descriptor); + void CreateShaderResourceView(ID3D12Resource *resource, + const D3D12_SHADER_RESOURCE_VIEW_DESC *desc, + D3D12_CPU_DESCRIPTOR_HANDLE descriptor); + void CreateUnorderedAccessView(ID3D12Resource *resource, ID3D12Resource *counter_resource, + const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc, + D3D12_CPU_DESCRIPTOR_HANDLE descriptor); + void CreateRenderTargetView(ID3D12Resource *resource, + const D3D12_RENDER_TARGET_VIEW_DESC *desc, + D3D12_CPU_DESCRIPTOR_HANDLE descriptor); + void CreateDepthStencilView(ID3D12Resource *resource, + const D3D12_DEPTH_STENCIL_VIEW_DESC *desc, + D3D12_CPU_DESCRIPTOR_HANDLE descriptor); + void CreateSampler(const D3D12_SAMPLER_DESC *desc, + D3D12_CPU_DESCRIPTOR_HANDLE descriptor); + + void CopyDescriptors(UINT dst_descriptor_range_count, + const D3D12_CPU_DESCRIPTOR_HANDLE *dst_descriptor_range_offsets, + const UINT *dst_descriptor_range_sizes, + UINT src_descriptor_range_count, + const D3D12_CPU_DESCRIPTOR_HANDLE *src_descriptor_range_offsets, + const UINT *src_descriptor_range_sizes, + D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type); + void CopyDescriptorsSimple(UINT descriptor_count, + const D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor_range_offset, + const D3D12_CPU_DESCRIPTOR_HANDLE src_descriptor_range_offset, + D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type); + + D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo(UINT visible_mask, + UINT reource_desc_count, const D3D12_RESOURCE_DESC *resource_descs); + + D3D12_HEAP_PROPERTIES GetCustomHeapProperties(UINT node_mask, + D3D12_HEAP_TYPE heap_type); + + HRESULT CreateCommittedResource(const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + REFIID riid, void **resource); + + HRESULT CreateHeap(const D3D12_HEAP_DESC *desc, REFIID riid, void **heap); + + HRESULT CreatePlacedResource(ID3D12Heap *heap, UINT64 heap_offset, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + REFIID riid, void **resource); + HRESULT CreateReservedResource(const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + REFIID riid, void **resource); + + HRESULT CreateSharedHandle(ID3D12DeviceChild *object, + const SECURITY_ATTRIBUTES *attributes, DWORD access, + const WCHAR *name, HANDLE *handle); + HRESULT OpenSharedHandle(HANDLE handle, + REFIID riid, void **object); + HRESULT OpenSharedHandleByName(const WCHAR *name, DWORD access, HANDLE *handle); + + HRESULT MakeResident(UINT object_count, ID3D12Pageable * const *objects); + HRESULT Evict(UINT object_count, ID3D12Pageable * const *objects); + + HRESULT CreateFence(UINT64 initial_value, D3D12_FENCE_FLAGS flags, REFIID riid, void **fence); + + HRESULT GetDeviceRemovedReason(); + + void GetCopyableFootprints(const D3D12_RESOURCE_DESC *desc, + UINT first_sub_resource, + UINT sub_resource_count, + UINT64 base_offset, + D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts, + UINT *row_count, + UINT64 *row_size, + UINT64 *total_bytes); + + HRESULT CreateQueryHeap(const D3D12_QUERY_HEAP_DESC *desc, + REFIID riid, void **heap); + + HRESULT SetStablePowerState(BOOL enable); + + HRESULT CreateCommandSignature(const D3D12_COMMAND_SIGNATURE_DESC *desc, + ID3D12RootSignature *root_signature, + REFIID riid, void **command_signature); + + void GetResourceTiling(ID3D12Resource *resource, + UINT *total_tile_count, + D3D12_PACKED_MIP_INFO *packed_mip_info, + D3D12_TILE_SHAPE *standard_tile_shape, + UINT *sub_resource_tiling_count, + UINT first_sub_resource_tiling, + D3D12_SUBRESOURCE_TILING *sub_resource_tilings); + + LUID GetAdapterLuid(); +} + +[ + uuid(c64226a8-9201-46af-b4cc-53fb9ff7414f), + object, + local, + pointer_default(unique) +] +interface ID3D12PipelineLibrary : ID3D12DeviceChild +{ + HRESULT StorePipeline(const WCHAR *name, ID3D12PipelineState *pipeline); + + HRESULT LoadGraphicsPipeline(const WCHAR *name, + const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, REFIID riid, + void **pipeline_state); + + HRESULT LoadComputePipeline(const WCHAR *name, + const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, REFIID riid, + void **pipeline_state); + + SIZE_T GetSerializedSize(); + + HRESULT Serialize(void *data, SIZE_T data_size_in_bytes); +} + +[ + uuid(80eabf42-2568-4e5e-bd82-c37f86961dc3), + object, + local, + pointer_default(unique) +] +interface ID3D12PipelineLibrary1 : ID3D12PipelineLibrary +{ + HRESULT LoadPipeline(const WCHAR *name, + const D3D12_PIPELINE_STATE_STREAM_DESC *desc, REFIID riid, + void **pipeline_state); +} + +[ + uuid(77acce80-638e-4e65-8895-c1f23386863e), + object, + local, + pointer_default(unique) +] +interface ID3D12Device1 : ID3D12Device +{ + HRESULT CreatePipelineLibrary(const void *blob, SIZE_T blob_size, REFIID iid, void **lib); + + HRESULT SetEventOnMultipleFenceCompletion(ID3D12Fence * const *fences, + const UINT64 *values, UINT fence_count, D3D12_MULTIPLE_FENCE_WAIT_FLAGS flags, HANDLE event); + + HRESULT SetResidencyPriority(UINT object_count, ID3D12Pageable * const *objects, + const D3D12_RESIDENCY_PRIORITY *priorities); +} + +[ + uuid(30baa41e-b15b-475c-a0bb-1af5c5b64328), + object, + local, + pointer_default(unique) +] +interface ID3D12Device2 : ID3D12Device1 +{ + HRESULT CreatePipelineState( + [in] const D3D12_PIPELINE_STATE_STREAM_DESC *desc, + [in] REFIID riid, + [out, iid_is(riid)] void **pipeline_state); +} + +[ + uuid(81dadc15-2bad-4392-93c5-101345c4aa98), + object, + local, + pointer_default(unique) +] +interface ID3D12Device3 : ID3D12Device2 +{ + HRESULT OpenExistingHeapFromAddress( + [in] const void *address, + [in] REFIID riid, + [out, iid_is(riid)] void **heap); + + HRESULT OpenExistingHeapFromFileMapping( + [in] HANDLE file_mapping, + [in] REFIID riid, + [out, iid_is(riid)] void **heap); + + HRESULT EnqueueMakeResident( + [in] D3D12_RESIDENCY_FLAGS flags, + [in] UINT num_objects, + [in] ID3D12Pageable *const *objects, + [in] ID3D12Fence *fence, + [in] UINT64 fence_value); +} + +[ + uuid(34ab647b-3cc8-46ac-841b-c0965645c046), + object, + local, + pointer_default(unique) +] +interface ID3D12RootSignatureDeserializer : IUnknown +{ + const D3D12_ROOT_SIGNATURE_DESC *GetRootSignatureDesc(); +} + +[ + uuid(7f91ce67-090c-4bb7-b78e-ed8ff2e31da0), + object, + local, + pointer_default(unique) +] +interface ID3D12VersionedRootSignatureDeserializer : IUnknown +{ + HRESULT GetRootSignatureDescAtVersion(D3D_ROOT_SIGNATURE_VERSION version, + const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **desc); + + const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *GetUnconvertedRootSignatureDesc(); +}; + +typedef enum D3D12_COMMAND_LIST_FLAGS +{ + D3D12_COMMAND_LIST_FLAG_NONE = 0x0, +} D3D12_COMMAND_LIST_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_FLAGS);") + +typedef enum D3D12_COMMAND_POOL_FLAGS +{ + D3D12_COMMAND_POOL_FLAG_NONE = 0x0, +} D3D12_COMMAND_POOL_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_POOL_FLAGS);") + +typedef enum D3D12_COMMAND_RECORDER_FLAGS +{ + D3D12_COMMAND_RECORDER_FLAG_NONE = 0x0, +} D3D12_COMMAND_RECORDER_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_RECORDER_FLAGS);") + +[ + uuid(e865df17-a9ee-46f9-a463-3098315aa2e5), + object, + local, + pointer_default(unique) +] +interface ID3D12Device4 : ID3D12Device3 +{ + HRESULT CreateCommandList1( + UINT node_mask, D3D12_COMMAND_LIST_TYPE type, + D3D12_COMMAND_LIST_FLAGS flags, REFIID riid, + void **command_list); + + HRESULT CreateProtectedResourceSession( + const D3D12_PROTECTED_RESOURCE_SESSION_DESC *desc, REFIID riid, + void **session); + + HRESULT CreateCommittedResource1( + const D3D12_HEAP_PROPERTIES *heap_properties, + D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, + D3D12_RESOURCE_STATES initial_resource_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + ID3D12ProtectedResourceSession *protected_session, + REFIID riid_resource, + void **resource); + + HRESULT CreateHeap1( + const D3D12_HEAP_DESC *desc, + ID3D12ProtectedResourceSession *protected_session, + REFIID riid, void **heap); + + HRESULT CreateReservedResource1( + const D3D12_RESOURCE_DESC *desc, + D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + ID3D12ProtectedResourceSession *protected_session, + REFIID riid, void **resource); + + D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo1( + UINT visible_mask, + UINT resource_descs_count, + const D3D12_RESOURCE_DESC *resource_descs, + D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1); +} + +typedef enum D3D12_LIFETIME_STATE +{ + D3D12_LIFETIME_STATE_IN_USE = 0x0, + D3D12_LIFETIME_STATE_NOT_IN_USE = 0x1, +} D3D12_LIFETIME_STATE; + +[ + uuid(e667af9f-cd56-4f46-83ce-032e595d70a8), + object, + local, + pointer_default(unique) +] +interface ID3D12LifetimeOwner : IUnknown +{ + void LifetimeStateUpdated(D3D12_LIFETIME_STATE NewState); +} + +[ + uuid(f1df64b6-57fd-49cd-8807-c0eb88b45c8f), + object, + local, + pointer_default(unique) +] +interface ID3D12SwapChainAssistant : IUnknown +{ + LUID GetLUID(); + HRESULT GetSwapChainObject(REFIID riid, void **ppv); + HRESULT GetCurrentResourceAndCommandQueue( + REFIID riid_resource, void **resource, + REFIID riid_queue, void **queue); + HRESULT InsertImplicitSync(); +} + +[ + uuid(3fd03d36-4eb1-424a-a582-494ecb8ba813), + object, + local, + pointer_default(unique) +] +interface ID3D12LifetimeTracker : ID3D12DeviceChild +{ + HRESULT DestroyOwnedObject(ID3D12DeviceChild *object); +} + +typedef enum D3D12_META_COMMAND_PARAMETER_TYPE +{ + D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = 0x0, + D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = 0x1, + D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = 0x2, + D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x3, + D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x4, +} D3D12_META_COMMAND_PARAMETER_TYPE; + +typedef enum D3D12_META_COMMAND_PARAMETER_FLAGS +{ + D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 0x1, + D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2, +} D3D12_META_COMMAND_PARAMETER_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_META_COMMAND_PARAMETER_FLAGS);") + +typedef enum D3D12_META_COMMAND_PARAMETER_STAGE +{ + D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = 0x0, + D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = 0x1, + D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = 0x2, +} D3D12_META_COMMAND_PARAMETER_STAGE; + +typedef struct D3D12_META_COMMAND_PARAMETER_DESC +{ + const WCHAR *Name; + D3D12_META_COMMAND_PARAMETER_TYPE Type; + D3D12_META_COMMAND_PARAMETER_FLAGS Flags; + D3D12_RESOURCE_STATES RequiredResourceState; + UINT StructureOffset; +} D3D12_META_COMMAND_PARAMETER_DESC; + +typedef enum D3D12_GRAPHICS_STATES +{ + D3D12_GRAPHICS_STATE_NONE = 0x0, + D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = 0x1, + D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = 0x2, + D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = 0x4, + D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = 0x8, + D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = 0x10, + D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = 0x20, + D3D12_GRAPHICS_STATE_RS_VIEWPORTS = 0x40, + D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = 0x80, + D3D12_GRAPHICS_STATE_PREDICATION = 0x100, + D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = 0x200, + D3D12_GRAPHICS_STATE_OM_STENCIL_REF = 0x400, + D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = 0x800, + D3D12_GRAPHICS_STATE_PIPELINE_STATE = 0x1000, + D3D12_GRAPHICS_STATE_SO_TARGETS = 0x2000, + D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = 0x4000, + D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = 0x8000, + D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = 0x10000, +} D3D12_GRAPHICS_STATES; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GRAPHICS_STATES);") + +typedef struct D3D12_META_COMMAND_DESC +{ + GUID Id; + const WCHAR *Name; + D3D12_GRAPHICS_STATES InitializationDirtyState; + D3D12_GRAPHICS_STATES ExecutionDirtyState; +} D3D12_META_COMMAND_DESC; + +[ + uuid(47016943-fca8-4594-93ea-af258b55346d), + object, + local, + pointer_default(unique) +] +interface ID3D12StateObject : ID3D12Pageable +{ +} + +[ + uuid(de5fa827-9bf9-4f26-89ff-d7f56fde3860), + object, + local, + pointer_default(unique) +] +interface ID3D12StateObjectProperties : IUnknown +{ + void *GetShaderIdentifier(const WCHAR *export_name); + UINT64 GetShaderStackSize(const WCHAR *export_name); + UINT64 GetPipelineStackSize(); + void SetPipelineStackSize(UINT64 pipeline_stack_size_in_bytes); +} + +typedef enum D3D12_STATE_SUBOBJECT_TYPE +{ + D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0x0, + D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 0x1, + D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 0x2, + D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x3, + D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 0x5, + D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 0x6, + D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x7, + D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x8, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 0x9, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 0xa, + D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 0xb, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = 0xc, + D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = 0xd, +} D3D12_STATE_SUBOBJECT_TYPE; + +typedef struct D3D12_STATE_SUBOBJECT +{ + D3D12_STATE_SUBOBJECT_TYPE Type; + const void *pDesc; +} D3D12_STATE_SUBOBJECT; + +typedef enum D3D12_STATE_OBJECT_FLAGS +{ + D3D12_STATE_OBJECT_FLAG_NONE = 0x0, + D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1, + D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2, + D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4, +} D3D12_STATE_OBJECT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_STATE_OBJECT_FLAGS);") + +typedef struct D3D12_STATE_OBJECT_CONFIG +{ + D3D12_STATE_OBJECT_FLAGS Flags; +} D3D12_STATE_OBJECT_CONFIG; + +typedef struct D3D12_GLOBAL_ROOT_SIGNATURE +{ + ID3D12RootSignature *pGlobalRootSignature; +} D3D12_GLOBAL_ROOT_SIGNATURE; + +typedef struct D3D12_LOCAL_ROOT_SIGNATURE +{ + ID3D12RootSignature *pLocalRootSignature; +} D3D12_LOCAL_ROOT_SIGNATURE; + +typedef struct D3D12_NODE_MASK +{ + UINT NodeMask; +} D3D12_NODE_MASK; + +typedef enum D3D12_EXPORT_FLAGS +{ + D3D12_EXPORT_FLAG_NONE = 0x0, +} D3D12_EXPORT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_EXPORT_FLAGS);") + +typedef struct D3D12_EXPORT_DESC +{ + const WCHAR *Name; + const WCHAR *ExportToRename; + D3D12_EXPORT_FLAGS Flags; +} D3D12_EXPORT_DESC; + +typedef struct D3D12_DXIL_LIBRARY_DESC +{ + D3D12_SHADER_BYTECODE DXILLibrary; + UINT NumExports; + D3D12_EXPORT_DESC *pExports; +} D3D12_DXIL_LIBRARY_DESC; + +typedef struct D3D12_EXISTING_COLLECTION_DESC +{ + ID3D12StateObject *pExistingCollection; + UINT NumExports; + D3D12_EXPORT_DESC *pExports; +} D3D12_EXISTING_COLLECTION_DESC; + +typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION +{ + const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate; + UINT NumExports; + const WCHAR **pExports; +} D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + +typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION +{ + const WCHAR *SubobjectToAssociate; + UINT NumExports; + const WCHAR **pExports; +} D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + +typedef enum D3D12_HIT_GROUP_TYPE +{ + D3D12_HIT_GROUP_TYPE_TRIANGLES = 0x0, + D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1, +} D3D12_HIT_GROUP_TYPE; + +typedef struct D3D12_HIT_GROUP_DESC +{ + const WCHAR *HitGroupExport; + D3D12_HIT_GROUP_TYPE Type; + const WCHAR *AnyHitShaderImport; + const WCHAR *ClosestHitShaderImport; + const WCHAR *IntersectionShaderImport; +} D3D12_HIT_GROUP_DESC; + +typedef struct D3D12_RAYTRACING_SHADER_CONFIG +{ + UINT MaxPayloadSizeInBytes; + UINT MaxAttributeSizeInBytes; +} D3D12_RAYTRACING_SHADER_CONFIG; + +typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG +{ + UINT MaxTraceRecursionDepth; +} D3D12_RAYTRACING_PIPELINE_CONFIG; + +typedef enum D3D12_RAYTRACING_PIPELINE_FLAGS +{ + D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0x0, + D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100, + D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200, +} D3D12_RAYTRACING_PIPELINE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_PIPELINE_FLAGS);") + +typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1 +{ + UINT MaxTraceRecursionDepth; + D3D12_RAYTRACING_PIPELINE_FLAGS Flags; +} D3D12_RAYTRACING_PIPELINE_CONFIG1; + +typedef enum D3D12_STATE_OBJECT_TYPE +{ + D3D12_STATE_OBJECT_TYPE_COLLECTION = 0x0, + D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 0x3, +} D3D12_STATE_OBJECT_TYPE; + +typedef struct D3D12_STATE_OBJECT_DESC +{ + D3D12_STATE_OBJECT_TYPE Type; + UINT NumSubobjects; + const D3D12_STATE_SUBOBJECT *pSubobjects; +} D3D12_STATE_OBJECT_DESC; + +typedef enum D3D12_RAYTRACING_GEOMETRY_FLAGS +{ + D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0x0, + D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1, + D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2, +} D3D12_RAYTRACING_GEOMETRY_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_GEOMETRY_FLAGS);") + +typedef enum D3D12_RAYTRACING_GEOMETRY_TYPE +{ + D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0x0, + D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = 0x1, +} D3D12_RAYTRACING_GEOMETRY_TYPE; + +typedef enum D3D12_RAYTRACING_INSTANCE_FLAGS +{ + D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0x0, + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1, + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8 +} D3D12_RAYTRACING_INSTANCE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_INSTANCE_FLAGS);") + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE +{ + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 StrideInBytes; +} D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE; + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE +{ + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 SizeInBytes; +} D3D12_GPU_VIRTUAL_ADDRESS_RANGE; + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE +{ + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 SizeInBytes; + UINT64 StrideInBytes; +} D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE; + +typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC +{ + D3D12_GPU_VIRTUAL_ADDRESS Transform3x4; + DXGI_FORMAT IndexFormat; + DXGI_FORMAT VertexFormat; + UINT IndexCount; + UINT VertexCount; + D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer; +} D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC; + +typedef struct D3D12_RAYTRACING_AABB +{ + FLOAT MinX; + FLOAT MinY; + FLOAT MinZ; + FLOAT MaxX; + FLOAT MaxY; + FLOAT MaxZ; +} D3D12_RAYTRACING_AABB; + +typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC +{ + UINT64 AABBCount; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs; +} D3D12_RAYTRACING_GEOMETRY_AABBS_DESC; + +typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS +{ + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0x00, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x01, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x02, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x04, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x08, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20, +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS);") + +typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE +{ + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0x0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4, +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE; + +typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE +{ + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0x0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1 +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE; + +typedef enum D3D12_ELEMENTS_LAYOUT +{ + D3D12_ELEMENTS_LAYOUT_ARRAY = 0x0, + D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1 +} D3D12_ELEMENTS_LAYOUT; + +typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE +{ + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0x0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = 0x3, +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC +{ + D3D12_GPU_VIRTUAL_ADDRESS DestBuffer; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC +{ + UINT64 CompactedSizeInBytes; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC +{ + UINT64 DecodedSizeInBytes; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER +{ + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; + UINT NumDescs; +} D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC +{ + UINT64 SerializedSizeInBytes; + UINT64 NumBottomLevelAccelerationStructurePointers; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC; + +typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER +{ + GUID DriverOpaqueGUID; + BYTE DriverOpaqueVersioningData[16]; +} D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER; + +typedef enum D3D12_SERIALIZED_DATA_TYPE +{ + D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0x0, +} D3D12_SERIALIZED_DATA_TYPE; + +typedef enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS +{ + D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0x0, + D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1, + D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2, + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3, + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4, +} D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS; + +typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER +{ + D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier; + UINT64 SerializedSizeInBytesIncludingHeader; + UINT64 DeserializedSizeInBytes; + UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader; +} D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC +{ + UINT64 CurrentSizeInBytes; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_INSTANCE_DESC +{ + FLOAT Transform[3][4]; + UINT InstanceID : 24; + UINT InstanceMask : 8; + UINT InstanceContributionToHitGroupIndex : 24; + UINT Flags : 8; + D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure; +} D3D12_RAYTRACING_INSTANCE_DESC; + +typedef struct D3D12_RAYTRACING_GEOMETRY_DESC +{ + D3D12_RAYTRACING_GEOMETRY_TYPE Type; + D3D12_RAYTRACING_GEOMETRY_FLAGS Flags; + union + { + D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles; + D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs; + }; +} D3D12_RAYTRACING_GEOMETRY_DESC; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS +{ + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags; + UINT NumDescs; + D3D12_ELEMENTS_LAYOUT DescsLayout; + union + { + D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs; + const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs; + const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs; + }; +} D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC +{ + D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData; + D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs; + D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData; + D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData; +} D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO +{ + UINT64 ResultDataMaxSizeInBytes; + UINT64 ScratchDataSizeInBytes; + UINT64 UpdateScratchDataSizeInBytes; +} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO; + +typedef enum D3D12_RAY_FLAGS +{ + D3D12_RAY_FLAG_NONE = 0x00, + D3D12_RAY_FLAG_FORCE_OPAQUE = 0x01, + D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x02, + D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x04, + D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x08, + D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10, + D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20, + D3D12_RAY_FLAG_CULL_OPAQUE = 0x40, + D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80, + D3D12_RAY_FLAG_SKIP_TRIANGLES = 0x100, + D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200, +} D3D12_RAY_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAY_FLAGS);") + +typedef enum D3D12_HIT_KIND +{ + D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe, + D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff, +} D3D12_HIT_KIND; + +[ + uuid(8b4f173b-2fea-4b80-8f58-4307191ab95d), + object, + local, + pointer_default(unique) +] +interface ID3D12Device5 : ID3D12Device4 +{ + HRESULT CreateLifetimeTracker( + ID3D12LifetimeOwner *owner, REFIID riid, + void **tracker); + + void RemoveDevice(); + + HRESULT EnumerateMetaCommands( + UINT *meta_commands_count, + D3D12_META_COMMAND_DESC *descs); + + HRESULT EnumerateMetaCommandParameters( + REFGUID command_id, + D3D12_META_COMMAND_PARAMETER_STAGE stage, + UINT *total_structure_size_in_bytes, + UINT *parameter_count, + D3D12_META_COMMAND_PARAMETER_DESC *parameter_descs); + + HRESULT CreateMetaCommand( + REFGUID command_id, UINT node_mask, + const void *creation_parameters_data, + SIZE_T creation_parameters_data_size_in_bytes, + REFIID riid, void **meta_command); + + HRESULT CreateStateObject( + const D3D12_STATE_OBJECT_DESC *desc, REFIID riid, + void **state_object); + + void GetRaytracingAccelerationStructurePrebuildInfo( + const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *desc, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *info); + + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS CheckDriverMatchingIdentifier( + D3D12_SERIALIZED_DATA_TYPE serialized_data_type, + const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *identifier_to_check); +} + +typedef enum D3D12_AUTO_BREADCRUMB_OP +{ + D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0x0, + D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 0x1, + D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 0x2, + D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 0x3, + D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 0x4, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 0x5, + D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 0x6, + D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 0x7, + D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 0x8, + D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 0x9, + D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 0xa, + D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 0xb, + D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 0xc, + D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 0xd, + D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 0xe, + D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 0xf, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 0x10, + D3D12_AUTO_BREADCRUMB_OP_PRESENT = 0x11, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 0x12, + D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 0x13, + D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 0x14, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 0x15, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 0x16, + D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 0x17, + D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 0x18, + D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 0x19, + D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 0x1a, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 0x1b, + D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 0x1c, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 0x1d, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 0x1e, + D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 0x1f, + D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 0x20, + D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 0x21, + D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 0x22, + D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 0x23, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 0x24, + D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 0x25, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 0x26, + D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 0x27, + D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 0x28, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 0x29, + D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = 0x2a, + D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = 0x2b, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = 0x2c, +} D3D12_AUTO_BREADCRUMB_OP; + +typedef struct D3D12_AUTO_BREADCRUMB_NODE +{ + const char *pCommandListDebugNameA; + const WCHAR *pCommandListDebugNameW; + const char *pCommandQueueDebugNameA; + const WCHAR *pCommandQueueDebugNameW; + ID3D12GraphicsCommandList *pCommandList; + ID3D12CommandQueue *pCommandQueue; + UINT32 BreadcrumbCount; + const UINT32 *pLastBreadcrumbValue; + const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; + const struct D3D12_AUTO_BREADCRUMB_NODE *pNext; +} D3D12_AUTO_BREADCRUMB_NODE; + +typedef struct D3D12_DRED_BREADCRUMB_CONTEXT +{ + UINT BreadcrumbIndex; + const WCHAR *pContextString; +} D3D12_DRED_BREADCRUMB_CONTEXT; + +typedef struct D3D12_AUTO_BREADCRUMB_NODE1 +{ + const char *pCommandListDebugNameA; + const WCHAR *pCommandListDebugNameW; + const char *pCommandQueueDebugNameA; + const WCHAR *pCommandQueueDebugNameW; + ID3D12GraphicsCommandList *pCommandList; + ID3D12CommandQueue *pCommandQueue; + UINT BreadcrumbCount; + const UINT *pLastBreadcrumbValue; + const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; + const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext; + UINT BreadcrumbContextsCount; + D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts; +} D3D12_AUTO_BREADCRUMB_NODE1; + +typedef enum D3D12_DRED_VERSION +{ + D3D12_DRED_VERSION_1_0 = 0x1, + D3D12_DRED_VERSION_1_1 = 0x2, + D3D12_DRED_VERSION_1_2 = 0x3, + D3D12_DRED_VERSION_1_3 = 0x4, +} D3D12_DRED_VERSION; + +typedef enum D3D12_DRED_FLAGS +{ + D3D12_DRED_FLAG_NONE = 0x0, + D3D12_DRED_FLAG_FORCE_ENABLE = 0x1, + D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 0x2, +} D3D12_DRED_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_FLAGS);") + +typedef enum D3D12_DRED_ENABLEMENT +{ + D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0x0, + D3D12_DRED_ENABLEMENT_FORCED_OFF = 0x1, + D3D12_DRED_ENABLEMENT_FORCED_ON = 0x2, +} D3D12_DRED_ENABLEMENT; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA +{ + D3D12_DRED_FLAGS Flags; + D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; +} D3D12_DEVICE_REMOVED_EXTENDED_DATA; + +typedef enum D3D12_DRED_ALLOCATION_TYPE +{ + D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 0x13, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 0x14, + D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 0x15, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 0x16, + D3D12_DRED_ALLOCATION_TYPE_FENCE = 0x17, + D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 0x18, + D3D12_DRED_ALLOCATION_TYPE_HEAP = 0x19, + D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 0x1b, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 0x1c, + D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 0x1d, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 0x1e, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 0x20, + D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 0x22, + D3D12_DRED_ALLOCATION_TYPE_PASS = 0x23, + D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 0x24, + D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 0x25, + D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 0x26, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 0x27, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 0x28, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 0x29, + D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 0x2a, + D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 0x2b, + D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 0x2c, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 0x2d, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 0x2e, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 0x2f, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = 0x30, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = 0x31, + D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff, +} D3D12_DRED_ALLOCATION_TYPE; + +typedef struct D3D12_DRED_ALLOCATION_NODE +{ + const char *ObjectNameA; + const WCHAR *ObjectNameW; + D3D12_DRED_ALLOCATION_TYPE AllocationType; + const struct D3D12_DRED_ALLOCATION_NODE *pNext; +} D3D12_DRED_ALLOCATION_NODE; + +typedef struct D3D12_DRED_ALLOCATION_NODE1 +{ + const char *ObjectNameA; + const WCHAR *ObjectNameW; + D3D12_DRED_ALLOCATION_TYPE AllocationType; + const struct D3D12_DRED_ALLOCATION_NODE1 *pNext; + const IUnknown *pObject; +} D3D12_DRED_ALLOCATION_NODE1; + +typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT +{ + const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; +} D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT; + +typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 +{ + const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode; +} D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT +{ + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode; + const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode; +} D3D12_DRED_PAGE_FAULT_OUTPUT; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1 +{ + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode; + const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode; +} D3D12_DRED_PAGE_FAULT_OUTPUT1; + +typedef enum D3D12_DRED_PAGE_FAULT_FLAGS +{ + D3D12_DRED_PAGE_FAULT_FLAGS_NONE = 0x0, +} D3D12_DRED_PAGE_FAULT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_PAGE_FAULT_FLAGS);") + +typedef enum D3D12_DRED_DEVICE_STATE +{ + D3D12_DRED_DEVICE_STATE_UNKNOWN = 0x0, + D3D12_DRED_DEVICE_STATE_HUNG = 0x3, + D3D12_DRED_DEVICE_STATE_FAULT = 0x6, + D3D12_DRED_DEVICE_STATE_PAGEFAULT = 0x7, +} D3D12_DRED_DEVICE_STATE; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2 +{ + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode; + const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode; + D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags; +} D3D12_DRED_PAGE_FAULT_OUTPUT2; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1 +{ + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput; +} D3D12_DEVICE_REMOVED_EXTENDED_DATA1; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2 +{ + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput; +} D3D12_DEVICE_REMOVED_EXTENDED_DATA2; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3 +{ + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput; + D3D12_DRED_DEVICE_STATE DeviceState; +} D3D12_DEVICE_REMOVED_EXTENDED_DATA3; + +typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA +{ + D3D12_DRED_VERSION Version; + union + { + D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0; + D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1; + D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2; + D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3; + }; +} D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA; + +[ + uuid(82bc481c-6b9b-4030-aedb-7ee3d1df1e63), + object, + local, + pointer_default(unique) +] +interface ID3D12DeviceRemovedExtendedDataSettings : IUnknown +{ + void SetAutoBreadcrumbsEnablement(D3D12_DRED_ENABLEMENT enablement); + void SetPageFaultEnablement(D3D12_DRED_ENABLEMENT enablement); + void SetWatsonDumpEnablement(D3D12_DRED_ENABLEMENT enablement); +} + +[ + uuid(dbd5ae51-3317-4f0a-adf9-1d7cedcaae0b), + object, + local, + pointer_default(unique) +] +interface ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12DeviceRemovedExtendedDataSettings +{ + void SetBreadcrumbContextEnablement(D3D12_DRED_ENABLEMENT enablement); +} + +[ + uuid(98931d33-5ae8-4791-aa3c-1a73a2934e71), + object, + local, + pointer_default(unique) +] +interface ID3D12DeviceRemovedExtendedData : IUnknown +{ + HRESULT GetAutoBreadcrumbsOutput(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *output); + HRESULT GetPageFaultAllocationOutput(D3D12_DRED_PAGE_FAULT_OUTPUT *output); +} + +[ + uuid(9727a022-cf1d-4dda-9eba-effa653fc506), + object, + local, + pointer_default(unique) +] +interface ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemovedExtendedData +{ + HRESULT GetAutoBreadcrumbsOutput1(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *output); + HRESULT GetPageFaultAllocationOutput1(D3D12_DRED_PAGE_FAULT_OUTPUT1 *output); +} + +[ + uuid(67fc5816-e4ca-4915-bf18-42541272da54), + object, + local, + pointer_default(unique) +] +interface ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemovedExtendedData1 +{ + HRESULT GetPageFaultAllocationOutput2(D3D12_DRED_PAGE_FAULT_OUTPUT2 *output); + D3D12_DRED_DEVICE_STATE GetDeviceState(); +} + +typedef enum D3D12_BACKGROUND_PROCESSING_MODE +{ + D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0x0, + D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = 0x1, + D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = 0x2, + D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = 0x3, +} D3D12_BACKGROUND_PROCESSING_MODE; + +typedef enum D3D12_MEASUREMENTS_ACTION +{ + D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0x0, + D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = 0x1, + D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = 0x2, + D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = 0x3, +} D3D12_MEASUREMENTS_ACTION; + +[ + uuid(c70b221b-40e4-4a17-89af-025a0727a6dc), + object, + local, + pointer_default(unique) +] +interface ID3D12Device6 : ID3D12Device5 +{ + HRESULT SetBackgroundProcessingMode( + D3D12_BACKGROUND_PROCESSING_MODE mode, + D3D12_MEASUREMENTS_ACTION action, + HANDLE event, + BOOL *further_measurements_desired); +} + +cpp_quote("DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED, 0x62b0084e, 0xc70e, 0x4daa, 0xa1, 0x09, 0x30, 0xff, 0x8d, 0x5a, 0x04, 0x82);") + +typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT +{ + UINT NodeIndex; + UINT Count; +} D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT; + +typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES +{ + UINT NodeIndex; + UINT Count; + GUID *pTypes; +} D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES; + +typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1 +{ + UINT NodeMask; + D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags; + GUID ProtectionType; +} D3D12_PROTECTED_RESOURCE_SESSION_DESC1; + +[ + uuid(d6f12dd6-76fb-406e-8961-4296eefc0409), + object, + local, + pointer_default(unique) +] +interface ID3D12ProtectedResourceSession1 : ID3D12ProtectedResourceSession +{ + D3D12_PROTECTED_RESOURCE_SESSION_DESC1 GetDesc1(); +} + +[ + uuid(5c014b53-68a1-4b9b-8bd1-dd6046b9358b), + object, + local, + pointer_default(unique) +] +interface ID3D12Device7 : ID3D12Device6 +{ + HRESULT AddToStateObject( + const D3D12_STATE_OBJECT_DESC *addition, + ID3D12StateObject *state_object_to_grow_from, + REFIID riid, void **new_state_object); + + HRESULT CreateProtectedResourceSession1( + const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *desc, + REFIID riid, void **session); +} + +[ + uuid(9218e6bb-f944-4f7e-a75c-b1b2c7b701f3), + object, + local, + pointer_default(unique) +] +interface ID3D12Device8 : ID3D12Device7 +{ + D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo2( + UINT visible_mask, + UINT resource_descs_count, + const D3D12_RESOURCE_DESC1 *resource_descs, + D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1); + + HRESULT CreateCommittedResource2( + const D3D12_HEAP_PROPERTIES *heap_properties, + D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC1 *desc, + D3D12_RESOURCE_STATES initial_resource_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + ID3D12ProtectedResourceSession *protected_session, + REFIID riid_resource, void **resource); + + HRESULT CreatePlacedResource1( + ID3D12Heap *heap, + UINT64 heap_offset, + const D3D12_RESOURCE_DESC1 *desc, + D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, + REFIID riid, void **resource); + + void CreateSamplerFeedbackUnorderedAccessView( + ID3D12Resource *targeted_resource, + ID3D12Resource *feedback_resource, + D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor); + + void GetCopyableFootprints1( + const D3D12_RESOURCE_DESC1 *resource_desc, + UINT first_subresource, + UINT subresources_count, + UINT64 base_offset, + D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts, + UINT *rows_count, + UINT64 *row_size_in_bytes, + UINT64 *total_bytes); +} + +[ + uuid(9d5e227a-4430-4161-88b3-3eca6bb16e19), + object, + local, + pointer_default(unique) +] +interface ID3D12Resource1 : ID3D12Resource +{ + HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session); +} + +[ + uuid(be36ec3b-ea85-4aeb-a45a-e9d76404a495), + object, + local, + pointer_default(unique) +] +interface ID3D12Resource2 : ID3D12Resource1 +{ + D3D12_RESOURCE_DESC1 GetDesc1(); +} + +[ + uuid(572f7389-2168-49e3-9693-d6df5871bf6d), + object, + local, + pointer_default(unique) +] +interface ID3D12Heap1 : ID3D12Heap +{ + HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session); +} + +typedef enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE +{ + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0x0, + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = 0x1, + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = 0x2, + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = 0x3, +} D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE; + +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS +{ + D3D12_CLEAR_VALUE ClearValue; +} D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS; + +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS +{ + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type; + + union + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear; + }; +} D3D12_RENDER_PASS_BEGINNING_ACCESS; + +typedef enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE +{ + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0x0, + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = 0x1, + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = 0x2, + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = 0x3, +} D3D12_RENDER_PASS_ENDING_ACCESS_TYPE; + +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS +{ + UINT SrcSubresource; + UINT DstSubresource; + UINT DstX; + UINT DstY; + D3D12_RECT SrcRect; +} D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS; + +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS +{ + ID3D12Resource *pSrcResource; + ID3D12Resource *pDstResource; + UINT SubresourceCount; + const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters; + DXGI_FORMAT Format; + D3D12_RESOLVE_MODE ResolveMode; + BOOL PreserveResolveSource; +} D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS; + +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS +{ + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type; + union + { + D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve; + }; +} D3D12_RENDER_PASS_ENDING_ACCESS; + +typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC +{ + D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; + D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess; + D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess; +} D3D12_RENDER_PASS_RENDER_TARGET_DESC; + +typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC +{ + D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; + D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess; + D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess; + D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess; + D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess; +} D3D12_RENDER_PASS_DEPTH_STENCIL_DESC; + +typedef enum D3D12_RENDER_PASS_FLAGS +{ + D3D12_RENDER_PASS_FLAG_NONE = 0x0, + D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1, + D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2, + D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4 +} D3D12_RENDER_PASS_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RENDER_PASS_FLAGS);") + +[ + uuid(dbb84c27-36ce-4fc9-b801-f048c46ac570), + object, + local, + pointer_default(unique) +] +interface ID3D12MetaCommand : ID3D12Pageable +{ + UINT64 GetRequiredParameterResourceSize( + D3D12_META_COMMAND_PARAMETER_STAGE stage, + UINT parameter_index); +} + +typedef struct D3D12_DISPATCH_RAYS_DESC +{ + D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable; + UINT Width; + UINT Height; + UINT Depth; +} D3D12_DISPATCH_RAYS_DESC; + +[ + uuid(8754318e-d3a9-4541-98cf-645b50dc4874), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandList3 +{ + void BeginRenderPass( + UINT render_targets_count, + const D3D12_RENDER_PASS_RENDER_TARGET_DESC *render_targets, + const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *depth_stencil, + D3D12_RENDER_PASS_FLAGS flags); + + void EndRenderPass(); + + void InitializeMetaCommand( + ID3D12MetaCommand *meta_command, + const void *initialization_parameters_data, + SIZE_T initialization_parameters_data_size_in_bytes); + + void ExecuteMetaCommand( + ID3D12MetaCommand *meta_command, + const void *execution_parameters_data, + SIZE_T execution_parameters_data_size_in_bytes); + + void BuildRaytracingAccelerationStructure( + const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *desc, + UINT postbuild_info_descs_count, + const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *postbuild_info_descs); + + void EmitRaytracingAccelerationStructurePostbuildInfo( + const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *desc, + UINT src_acceleration_structures_count, + const D3D12_GPU_VIRTUAL_ADDRESS *src_acceleration_structure_data); + + void CopyRaytracingAccelerationStructure( + D3D12_GPU_VIRTUAL_ADDRESS dst_acceleration_structure_data, + D3D12_GPU_VIRTUAL_ADDRESS src_acceleration_structure_data, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode); + + void SetPipelineState1(ID3D12StateObject *state_object); + + void DispatchRays(const D3D12_DISPATCH_RAYS_DESC *desc); +} + +typedef enum D3D12_SHADER_CACHE_MODE +{ + D3D12_SHADER_CACHE_MODE_MEMORY = 0x0, + D3D12_SHADER_CACHE_MODE_DISK = 0x1, +} D3D12_SHADER_CACHE_MODE; + +typedef enum D3D12_SHADER_CACHE_FLAGS +{ + D3D12_SHADER_CACHE_FLAG_NONE = 0x0, + D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1, + D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2, +} D3D12_SHADER_CACHE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_FLAGS);") + +typedef struct D3D12_SHADER_CACHE_SESSION_DESC +{ + GUID Identifier; + D3D12_SHADER_CACHE_MODE Mode; + D3D12_SHADER_CACHE_FLAGS Flags; + + UINT MaximumInMemoryCacheSizeBytes; + UINT MaximumInMemoryCacheEntries; + + UINT MaximumValueFileSizeBytes; + + UINT64 Version; +} D3D12_SHADER_CACHE_SESSION_DESC; + +typedef enum D3D12_BARRIER_LAYOUT +{ + D3D12_BARRIER_LAYOUT_UNDEFINED = 0xffffffff, + D3D12_BARRIER_LAYOUT_COMMON = 0x0, + D3D12_BARRIER_LAYOUT_PRESENT = 0x0, + D3D12_BARRIER_LAYOUT_GENERIC_READ = 0x1, + D3D12_BARRIER_LAYOUT_RENDER_TARGET = 0x2, + D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS = 0x3, + D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE = 0x4, + D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ = 0x5, + D3D12_BARRIER_LAYOUT_SHADER_RESOURCE = 0x6, + D3D12_BARRIER_LAYOUT_COPY_SOURCE = 0x7, + D3D12_BARRIER_LAYOUT_COPY_DEST = 0x8, + D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE = 0x9, + D3D12_BARRIER_LAYOUT_RESOLVE_DEST = 0xa, + D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE = 0xb, + D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ = 0xc, + D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE = 0xd, + D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ = 0xe, + D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE = 0xf, + D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ = 0x10, + D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE = 0x11, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON = 0x12, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ = 0x13, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS = 0x14, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE = 0x15, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE = 0x16, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST = 0x17, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON = 0x18, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ = 0x19, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS = 0x1a, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE = 0x1b, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE = 0x1c, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST = 0x1d, + D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON = 0x1e, +} D3D12_BARRIER_LAYOUT; + +typedef enum D3D12_BARRIER_SYNC +{ + D3D12_BARRIER_SYNC_NONE = 0x0, + D3D12_BARRIER_SYNC_ALL = 0x1, + D3D12_BARRIER_SYNC_DRAW = 0x2, + D3D12_BARRIER_SYNC_INPUT_ASSEMBLER = 0x4, + D3D12_BARRIER_SYNC_VERTEX_SHADING = 0x8, + D3D12_BARRIER_SYNC_PIXEL_SHADING = 0x10, + D3D12_BARRIER_SYNC_DEPTH_STENCIL = 0x20, + D3D12_BARRIER_SYNC_RENDER_TARGET = 0x40, + D3D12_BARRIER_SYNC_COMPUTE_SHADING = 0x80, + D3D12_BARRIER_SYNC_RAYTRACING = 0x100, + D3D12_BARRIER_SYNC_COPY = 0x200, + D3D12_BARRIER_SYNC_RESOLVE = 0x400, + D3D12_BARRIER_SYNC_EXECUTE_INDIRECT = 0x800, + D3D12_BARRIER_SYNC_PREDICATION = 0x800, + D3D12_BARRIER_SYNC_ALL_SHADING = 0x1000, + D3D12_BARRIER_SYNC_NON_PIXEL_SHADING = 0x2000, + D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO = 0x4000, + D3D12_BARRIER_SYNC_VIDEO_DECODE = 0x100000, + D3D12_BARRIER_SYNC_VIDEO_PROCESS = 0x200000, + D3D12_BARRIER_SYNC_VIDEO_ENCODE = 0x400000, + D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE = 0x800000, + D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE = 0x1000000, + D3D12_BARRIER_SYNC_SPLIT = 0x80000000, +} D3D12_BARRIER_SYNC; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_SYNC);") + +typedef enum D3D12_BARRIER_ACCESS +{ + D3D12_BARRIER_ACCESS_COMMON = 0, + D3D12_BARRIER_ACCESS_VERTEX_BUFFER = 0x1, + D3D12_BARRIER_ACCESS_CONSTANT_BUFFER = 0x2, + D3D12_BARRIER_ACCESS_INDEX_BUFFER = 0x4, + D3D12_BARRIER_ACCESS_RENDER_TARGET = 0x8, + D3D12_BARRIER_ACCESS_UNORDERED_ACCESS = 0x10, + D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE = 0x20, + D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ = 0x40, + D3D12_BARRIER_ACCESS_SHADER_RESOURCE = 0x80, + D3D12_BARRIER_ACCESS_STREAM_OUTPUT = 0x100, + D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT = 0x200, + D3D12_BARRIER_ACCESS_PREDICATION = 0x200, + D3D12_BARRIER_ACCESS_COPY_DEST = 0x400, + D3D12_BARRIER_ACCESS_COPY_SOURCE = 0x800, + D3D12_BARRIER_ACCESS_RESOLVE_DEST = 0x1000, + D3D12_BARRIER_ACCESS_RESOLVE_SOURCE = 0x2000, + D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ = 0x4000, + D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE = 0x8000, + D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE = 0x10000, + D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ = 0x20000, + D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE = 0x40000, + D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ = 0x80000, + D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE = 0x100000, + D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ = 0x200000, + D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE = 0x400000, + D3D12_BARRIER_ACCESS_NO_ACCESS = 0x80000000, +} D3D12_BARRIER_ACCESS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_ACCESS);") + +typedef enum D3D12_BARRIER_TYPE +{ + D3D12_BARRIER_TYPE_GLOBAL = 0x0, + D3D12_BARRIER_TYPE_TEXTURE = 0x1, + D3D12_BARRIER_TYPE_BUFFER = 0x2, +} D3D12_BARRIER_TYPE; + +typedef enum D3D12_TEXTURE_BARRIER_FLAGS +{ + D3D12_TEXTURE_BARRIER_FLAG_NONE = 0x0, + D3D12_TEXTURE_BARRIER_FLAG_DISCARD = 0x1, +} D3D12_TEXTURE_BARRIER_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TEXTURE_BARRIER_FLAGS);") + +typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE +{ + UINT IndexOrFirstMipLevel; + UINT NumMipLevels; + UINT FirstArraySlice; + UINT NumArraySlices; + UINT FirstPlane; + UINT NumPlanes; +} D3D12_BARRIER_SUBRESOURCE_RANGE; + +typedef struct D3D12_GLOBAL_BARRIER +{ + D3D12_BARRIER_SYNC SyncBefore; + D3D12_BARRIER_SYNC SyncAfter; + D3D12_BARRIER_ACCESS AccessBefore; + D3D12_BARRIER_ACCESS AccessAfter; +} D3D12_GLOBAL_BARRIER; + +typedef struct D3D12_TEXTURE_BARRIER +{ + D3D12_BARRIER_SYNC SyncBefore; + D3D12_BARRIER_SYNC SyncAfter; + D3D12_BARRIER_ACCESS AccessBefore; + D3D12_BARRIER_ACCESS AccessAfter; + D3D12_BARRIER_LAYOUT LayoutBefore; + D3D12_BARRIER_LAYOUT LayoutAfter; + ID3D12Resource *pResource; + D3D12_BARRIER_SUBRESOURCE_RANGE Subresources; + D3D12_TEXTURE_BARRIER_FLAGS Flags; +} D3D12_TEXTURE_BARRIER; + +typedef struct D3D12_BUFFER_BARRIER +{ + D3D12_BARRIER_SYNC SyncBefore; + D3D12_BARRIER_SYNC SyncAfter; + D3D12_BARRIER_ACCESS AccessBefore; + D3D12_BARRIER_ACCESS AccessAfter; + ID3D12Resource *pResource; + UINT64 Offset; + UINT64 Size; +} D3D12_BUFFER_BARRIER; + +typedef struct D3D12_BARRIER_GROUP +{ + D3D12_BARRIER_TYPE Type; + UINT32 NumBarriers; + union + { + const D3D12_GLOBAL_BARRIER *pGlobalBarriers; + const D3D12_TEXTURE_BARRIER *pTextureBarriers; + const D3D12_BUFFER_BARRIER *pBufferBarriers; + }; +} D3D12_BARRIER_GROUP; + +[ + uuid(28e2495d-0f64-4ae4-a6ec-129255dc49a8), + object, + local, + pointer_default(unique) +] +interface ID3D12ShaderCacheSession : ID3D12DeviceChild +{ + HRESULT FindValue( + const void *key, + UINT key_size, + void *value, + UINT *value_size); + HRESULT StoreValue( + const void *key, + UINT key_size, + const void *value, + UINT value_size); + + void SetDeleteOnDestroy(); + D3D12_SHADER_CACHE_SESSION_DESC GetDesc(); +} + +typedef enum D3D12_SHADER_CACHE_KIND_FLAGS +{ + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1, + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2, + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4, + D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8, +} D3D12_SHADER_CACHE_KIND_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_KIND_FLAGS);") + +typedef enum D3D12_SHADER_CACHE_CONTROL_FLAGS +{ + D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1, + D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2, + D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4, +} D3D12_SHADER_CACHE_CONTROL_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_CONTROL_FLAGS);") + +[ + uuid(4c80e962-f032-4f60-bc9e-ebc2cfa1d83c), + object, + local, + pointer_default(unique) +] +interface ID3D12Device9 : ID3D12Device8 +{ + HRESULT CreateShaderCacheSession( + const D3D12_SHADER_CACHE_SESSION_DESC *desc, + REFIID riid, void **session); + + HRESULT ShaderCacheControl( + D3D12_SHADER_CACHE_KIND_FLAGS kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS control); + + HRESULT CreateCommandQueue1( + const D3D12_COMMAND_QUEUE_DESC *desc, + REFIID creator_id, + REFIID riid, + void **command_queue); +} + +[ + uuid(517f8718-aa66-49f9-b02b-a7ab89c06031), + object, + local, + pointer_default(unique) +] +interface ID3D12Device10 : ID3D12Device9 +{ + HRESULT CreateCommittedResource3( + const D3D12_HEAP_PROPERTIES *heap_properties, + D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC1 *desc, + D3D12_BARRIER_LAYOUT initial_layout, + const D3D12_CLEAR_VALUE *optimized_clear_value, + ID3D12ProtectedResourceSession *protected_session, + UINT32 castable_formats_count, + DXGI_FORMAT *castable_formats, + REFIID riid_resource, + void **resource); + + HRESULT CreatePlacedResource2( + ID3D12Heap *heap, + UINT64 heap_offset, + const D3D12_RESOURCE_DESC1 *desc, + D3D12_BARRIER_LAYOUT initial_layout, + const D3D12_CLEAR_VALUE *optimized_clear_value, + UINT32 castable_formats_count, + DXGI_FORMAT *castable_formats, + REFIID riid, + void **resource); + + HRESULT CreateReservedResource2( + const D3D12_RESOURCE_DESC *desc, + D3D12_BARRIER_LAYOUT initial_layout, + const D3D12_CLEAR_VALUE *optimized_clear_value, + ID3D12ProtectedResourceSession *protected_session, + UINT32 castable_formats_count, + DXGI_FORMAT *castable_formats, + REFIID riid, + void **resource); +} + +[ + uuid(bc66d368-7373-4943-8757-fc87dc79e476), + object, + local, + pointer_default(unique) +] +interface ID3D12VirtualizationGuestDevice : IUnknown +{ + HRESULT ShareWithHost( + ID3D12DeviceChild *object, + HANDLE *handle); + + HRESULT CreateFenceFd( + ID3D12Fence *fence, + UINT64 fence_value, + int *fence_fd); +} + +[ + uuid(7071e1f0-e84b-4b33-974f-12fa49de65c5), + object, + local, + pointer_default(unique) +] +interface ID3D12Tools : IUnknown +{ + void EnableShaderInstrumentation(BOOL enable); + BOOL ShaderInstrumentationEnabled(); +} + +cpp_quote("DEFINE_GUID(CLSID_D3D12Debug, 0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f);") +cpp_quote("DEFINE_GUID(CLSID_D3D12Tools, 0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8);") +cpp_quote("DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2);") +cpp_quote("DEFINE_GUID(CLSID_D3D12SDKConfiguration, 0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce);") + +[ + uuid(e9eb5314-33aa-42b2-a718-d77f58b1f1c7), + object, + local, + pointer_default(unique) +] +interface ID3D12SDKConfiguration : IUnknown +{ + HRESULT SetSDKVersion(UINT version, const char *path); +} + +typedef enum D3D12_AXIS_SHADING_RATE +{ + D3D12_AXIS_SHADING_RATE_1X = 0x0, + D3D12_AXIS_SHADING_RATE_2X = 0x1, + D3D12_AXIS_SHADING_RATE_4X = 0x2, +} D3D12_AXIS_SHADING_RATE; + +typedef enum D3D12_SHADING_RATE +{ + D3D12_SHADING_RATE_1X1 = 0x0, + D3D12_SHADING_RATE_1X2 = 0x1, + D3D12_SHADING_RATE_2X1 = 0x4, + D3D12_SHADING_RATE_2X2 = 0x5, + D3D12_SHADING_RATE_2X4 = 0x6, + D3D12_SHADING_RATE_4X2 = 0x9, + D3D12_SHADING_RATE_4X4 = 0xa, +} D3D12_SHADING_RATE; + +typedef enum D3D12_SHADING_RATE_COMBINER +{ + D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0x0, + D3D12_SHADING_RATE_COMBINER_OVERRIDE = 0x1, + D3D12_SHADING_RATE_COMBINER_MIN = 0x2, + D3D12_SHADING_RATE_COMBINER_MAX = 0x3, + D3D12_SHADING_RATE_COMBINER_SUM = 0x4, +} D3D12_SHADING_RATE_COMBINER; + +[ + uuid(55050859-4024-474c-87f5-6472eaee44ea), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandList4 +{ + void RSSetShadingRate( + D3D12_SHADING_RATE base_shading_rate, + const D3D12_SHADING_RATE_COMBINER *combiners); + + void RSSetShadingRateImage( + ID3D12Resource *shading_rate_image); +} + +const UINT D3D12_SHADING_RATE_X_AXIS_SHIFT = 2; +const UINT D3D12_SHADING_RATE_VALID_MASK = 3; + +cpp_quote("#define D3D12_MAKE_COARSE_SHADING_RATE(x, y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y))") +cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(val) (((val) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK)") +cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(val) ((val) & D3D12_SHADING_RATE_VALID_MASK)") + +typedef struct D3D12_DISPATCH_MESH_ARGUMENTS +{ + UINT ThreadGroupCountX; + UINT ThreadGroupCountY; + UINT ThreadGroupCountZ; +} D3D12_DISPATCH_MESH_ARGUMENTS; + +[ + uuid(c3827890-e548-4cfa-96cf-5689a9370f80), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandList5 +{ + void DispatchMesh( + UINT thread_group_count_x, + UINT thread_group_count_y, + UINT thread_group_count_z); +} + +[ + uuid(dd171223-8b61-4769-90e3-160ccde4e2c1), + object, + local, + pointer_default(unique) +] +interface ID3D12GraphicsCommandList7 : ID3D12GraphicsCommandList6 +{ + void Barrier( + UINT32 barrier_groups_count, + const D3D12_BARRIER_GROUP *barrier_groups); +}; + +cpp_quote("#ifndef D3D12_IGNORE_SDK_LAYERS") +cpp_quote("#include \"d3d12sdklayers.h\"") +cpp_quote("#endif") + +typedef HRESULT (__stdcall *PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)( + const void *data, SIZE_T data_size, REFIID iid, void **deserializer); + +[local] HRESULT __stdcall D3D12CreateRootSignatureDeserializer( + const void *data, SIZE_T data_size, REFIID iid, void **deserializer); + +typedef HRESULT (__stdcall *PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)( + const void *data, SIZE_T data_size, REFIID iid, void **deserializer); + +[local] HRESULT __stdcall D3D12CreateVersionedRootSignatureDeserializer( + const void *data, SIZE_T data_size, REFIID iid, void **deserializer); + +typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)( + const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc, + D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob); + +[local] HRESULT __stdcall D3D12SerializeRootSignature( + const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc, + D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob); + +typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)( + const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob); + +[local] HRESULT __stdcall D3D12SerializeVersionedRootSignature( + const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *root_signature_desc, + ID3DBlob **blob, ID3DBlob **error_blob); + +typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter, + D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device); + +[local] HRESULT __stdcall D3D12CreateDevice(IUnknown *adapter, + D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device); + +typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug); + +[local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug); + +[local] HRESULT __stdcall D3D12EnableExperimentalFeatures(UINT feature_count, + const IID *iids, void *configurations, UINT *configurations_sizes); + +cpp_quote("static const UUID D3D12ExperimentalShaderModels = { 0x76f5573e, 0xf13a, 0x40f5, { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } };") +cpp_quote("static const UUID D3D12TiledResourceTier4 = { 0xc9c4725f, 0xa81a, 0x4f56, { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } };") +cpp_quote("static const UUID D3D12MetaCommand = { 0xc734c97e, 0x8077, 0x48c8, { 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77 } };") + +typedef HRESULT (__stdcall *PFN_D3D12_GET_INTERFACE)(REFCLSID clsid, REFIID iid, void **debug); + +[local] HRESULT __stdcall D3D12GetInterface(REFCLSID clsid, REFIID iid, void **debug); diff --git a/WineFix/lib/d2d1/include/windows/d3d12sdklayers.idl b/WineFix/lib/d2d1/include/windows/d3d12sdklayers.idl new file mode 100644 index 0000000..abfd25c --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d12sdklayers.idl @@ -0,0 +1,1175 @@ +/* + * Copyright 2016-2019 Józef Kucia for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "d3d12.idl"; + +cpp_quote("#ifdef WINE_NO_UNICODE_MACROS") +cpp_quote("#undef GetMessage") +cpp_quote("#endif") + +typedef enum D3D12_MESSAGE_CATEGORY +{ + D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED = 0x0, + D3D12_MESSAGE_CATEGORY_MISCELLANEOUS = 0x1, + D3D12_MESSAGE_CATEGORY_INITIALIZATION = 0x2, + D3D12_MESSAGE_CATEGORY_CLEANUP = 0x3, + D3D12_MESSAGE_CATEGORY_COMPILATION = 0x4, + D3D12_MESSAGE_CATEGORY_STATE_CREATION = 0x5, + D3D12_MESSAGE_CATEGORY_STATE_SETTING = 0x6, + D3D12_MESSAGE_CATEGORY_STATE_GETTING = 0x7, + D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION = 0x8, + D3D12_MESSAGE_CATEGORY_EXECUTION = 0x9, + D3D12_MESSAGE_CATEGORY_SHADER = 0xa, +} D3D12_MESSAGE_CATEGORY; + +typedef enum D3D12_MESSAGE_SEVERITY +{ + D3D12_MESSAGE_SEVERITY_CORRUPTION = 0x0, + D3D12_MESSAGE_SEVERITY_ERROR = 0x1, + D3D12_MESSAGE_SEVERITY_WARNING = 0x2, + D3D12_MESSAGE_SEVERITY_INFO = 0x3, + D3D12_MESSAGE_SEVERITY_MESSAGE = 0x4, +} D3D12_MESSAGE_SEVERITY; + +typedef enum D3D12_MESSAGE_ID +{ + D3D12_MESSAGE_ID_UNKNOWN = 0x0000, + D3D12_MESSAGE_ID_STRING_FROM_APPLICATION = 0x0001, + D3D12_MESSAGE_ID_CORRUPTED_THIS = 0x0002, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 = 0x0003, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 = 0x0004, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 = 0x0005, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 = 0x0006, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 = 0x0007, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 = 0x0008, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 = 0x0009, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 = 0x000a, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 = 0x000b, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 = 0x000c, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 = 0x000d, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 = 0x000e, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 = 0x000f, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 = 0x0010, + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 = 0x0011, + D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING = 0x0012, + D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY = 0x0013, + D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA = 0x0014, + D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA = 0x0015, + D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS = 0x0018, + D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY = 0x0019, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT = 0x001a, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC = 0x001b, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT = 0x001c, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE = 0x001d, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE = 0x001e, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS = 0x001f, + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE = 0x0020, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT = 0x0023, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT = 0x0024, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC = 0x0025, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT = 0x0026, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE = 0x0027, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE = 0x0028, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS = 0x0029, + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE = 0x002a, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT = 0x002d, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC = 0x002e, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT = 0x002f, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS = 0x0030, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE = 0x0031, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY = 0x0034, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS = 0x0035, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT = 0x0036, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT = 0x0037, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT = 0x0038, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS = 0x0039, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH = 0x003a, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE = 0x003b, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE = 0x003c, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT = 0x003d, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC = 0x003e, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE = 0x003f, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC = 0x0040, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT = 0x0041, + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY = 0x0042, + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE = 0x0043, + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE = 0x0044, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY = 0x0045, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE = 0x0046, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE = 0x0047, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY = 0x0048, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE = 0x0049, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = 0x004a, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES = 0x004b, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED = 0x004c, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED = 0x004f, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT = 0x0050, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT = 0x0051, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT = 0x0052, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT = 0x0053, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION = 0x0054, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT = 0x0055, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE = 0x0056, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC = 0x0057, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH = 0x0058, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS = 0x0059, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX = 0x005a, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE = 0x005b, + D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY = 0x005c, + D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE = 0x005d, + D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE = 0x005e, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE = 0x005f, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE = 0x0060, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP = 0x0061, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS = 0x0062, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK = 0x0064, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC = 0x0065, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP = 0x0066, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP = 0x0067, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP = 0x0068, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC = 0x0069, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP = 0x006a, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP = 0x006b, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP = 0x006c, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC = 0x006d, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND = 0x006f, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND = 0x0070, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP = 0x0071, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA = 0x0072, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA = 0x0073, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA = 0x0074, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK = 0x0075, + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID = 0x0087, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET = 0x00c8, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH = 0x00c9, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET = 0x00ca, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL = 0x00d1, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL = 0x00d2, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET = 0x00d3, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID = 0x00d4, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL = 0x00d5, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY = 0x00db, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED = 0x00dd, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED = 0x00de, + D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT = 0x00e8, + D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT = 0x00e9, + D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT = 0x00ea, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC = 0x00ef, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC = 0x00f0, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH = 0x00f5, + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT = 0x00fd, + D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY = 0x00ff, + D3D12_MESSAGE_ID_LIVE_DEVICE = 0x0112, + D3D12_MESSAGE_ID_LIVE_SWAPCHAIN = 0x0113, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS = 0x0114, + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE = 0x0115, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE = 0x0116, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER = 0x0118, + D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE = 0x011b, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM = 0x011c, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES = 0x011d, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES = 0x011e, + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES = 0x011f, + D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY = 0x0121, + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE = 0x0122, + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE = 0x0123, + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE = 0x0124, + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY = 0x0126, + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE = 0x0127, + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE = 0x0128, + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE = 0x0129, + D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED = 0x0136, + D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE = 0x013e, + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY = 0x0141, + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE = 0x0142, + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE = 0x0143, + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 0x014b, + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 0x014c, + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 0x014d, + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 0x014e, + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED = 0x014f, + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 0x0150, + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED = 0x0151, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE = 0x0154, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC = 0x0155, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT = 0x0156, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE = 0x0157, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE = 0x0158, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS = 0x0159, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT = 0x015a, + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS = 0x0162, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT = 0x0191, + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS = 0x0193, + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 0x019a, + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 0x019c, + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 0x019e, + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 0x01a0, + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED = 0x01a2, + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 0x01a4, + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 0x01a6, + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED = 0x01a9, + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED = 0x01aa, + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED = 0x01ab, + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED = 0x01ac, + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED = 0x01ad, + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED = 0x01ae, + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED = 0x01af, + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT = 0x01bf, + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT = 0x01c0, + D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER = 0x01ed, + D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER = 0x01ee, + D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS = 0x01fa, + D3D12_MESSAGE_ID_CREATEDEVICE_WARNING = 0x01fb, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE = 0x0207, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER = 0x0208, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE = 0x0209, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS = 0x020a, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS = 0x020b, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS = 0x020c, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES = 0x020d, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION = 0x020e, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH = 0x020f, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE = 0x0210, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT = 0x0211, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS = 0x0212, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS = 0x0213, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT = 0x0214, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER = 0x0215, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END = 0x0216, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN = 0x0217, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG = 0x0218, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE = 0x0219, + D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE = 0x021a, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION = 0x021c, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET = 0x021d, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE = 0x021e, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET = 0x021f, + D3D12_MESSAGE_ID_COMMAND_LIST_OPEN = 0x0220, + D3D12_MESSAGE_ID_INVALID_BUNDLE_API = 0x0222, + D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED = 0x0223, + D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE = 0x0225, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC = 0x0228, + D3D12_MESSAGE_ID_COMMAND_LIST_SYNC = 0x0229, + D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID = 0x022a, + D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE = 0x022d, + D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR = 0x022e, + D3D12_MESSAGE_ID_CREATE_PIPELINESTATE = 0x022f, + D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 = 0x0230, + D3D12_MESSAGE_ID_CREATE_RESOURCE = 0x0232, + D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP = 0x0233, + D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE = 0x0234, + D3D12_MESSAGE_ID_CREATE_LIBRARY = 0x0235, + D3D12_MESSAGE_ID_CREATE_HEAP = 0x0236, + D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE = 0x0237, + D3D12_MESSAGE_ID_CREATE_QUERYHEAP = 0x0238, + D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE = 0x0239, + D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE = 0x023a, + D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR = 0x023b, + D3D12_MESSAGE_ID_LIVE_PIPELINESTATE = 0x023c, + D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 = 0x023d, + D3D12_MESSAGE_ID_LIVE_RESOURCE = 0x023f, + D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP = 0x0240, + D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE = 0x0241, + D3D12_MESSAGE_ID_LIVE_LIBRARY = 0x0242, + D3D12_MESSAGE_ID_LIVE_HEAP = 0x0243, + D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE = 0x0244, + D3D12_MESSAGE_ID_LIVE_QUERYHEAP = 0x0245, + D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE = 0x0246, + D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE = 0x0247, + D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR = 0x0248, + D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE = 0x0249, + D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 = 0x024a, + D3D12_MESSAGE_ID_DESTROY_RESOURCE = 0x024c, + D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP = 0x024d, + D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE = 0x024e, + D3D12_MESSAGE_ID_DESTROY_LIBRARY = 0x024f, + D3D12_MESSAGE_ID_DESTROY_HEAP = 0x0250, + D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE = 0x0251, + D3D12_MESSAGE_ID_DESTROY_QUERYHEAP = 0x0252, + D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE = 0x0253, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS = 0x0255, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS = 0x0257, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN = 0x025a, + D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN = 0x025b, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC = 0x025c, + D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE = 0x025f, + D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE = 0x0260, + D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE = 0x0261, + D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH = 0x0262, + D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE = 0x0263, + D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE = 0x0265, + D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = 0x0266, + D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE = 0x0267, + D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = 0x0268, + D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE = 0x026e, + D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC = 0x026f, + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE = 0x0270, + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE = 0x0271, + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = 0x0272, + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL = 0x0273, + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES = 0x0274, + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT = 0x0275, + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS = 0x0276, + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS = 0x0277, + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN = 0x0278, + D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN = 0x0279, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES = 0x027a, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE = 0x027b, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = 0x027c, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL = 0x027d, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES = 0x027e, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS = 0x027f, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS = 0x0280, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN = 0x0281, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN = 0x0282, + D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE = 0x0283, + D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE = 0x0284, + D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC = 0x0285, + D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE = 0x0286, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE = 0x0287, + D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE = 0x0289, + D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC = 0x028a, + D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE = 0x028c, + D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES = 0x028d, + D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR = 0x028e, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN = 0x028f, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT = 0x0290, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET = 0x0291, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET = 0x0292, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH = 0x0293, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX = 0x0294, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE = 0x0295, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK = 0x0296, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE = 0x0297, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = 0x0298, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION = 0x0299, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = 0x029a, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH = 0x029b, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = 0x029c, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH = 0x029d, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = 0x029e, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = 0x029f, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT = 0x02a0, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY = 0x02a1, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE = 0x02a2, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = 0x02a3, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = 0x02a4, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH = 0x02a5, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = 0x02a6, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET = 0x02a7, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET = 0x02a8, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH = 0x02a9, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT = 0x02aa, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS = 0x02ab, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES = 0x02ac, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC = 0x02ad, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH = 0x02ae, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH = 0x02af, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH = 0x02b0, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH = 0x02b1, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH = 0x02b2, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE = 0x02b3, + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE = 0x02b4, + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH = 0x02b5, + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE = 0x02b6, + D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE = 0x02b7, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND = 0x02b8, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED = 0x02b9, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION = 0x02ba, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE = 0x02bb, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES = 0x02bc, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP = 0x02bd, + D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS = 0x02be, + D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY = 0x02bf, + D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY = 0x02c1, + D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID = 0x02c4, + D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID = 0x02c5, + D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID = 0x02c6, + D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID = 0x02c7, + D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID = 0x02c8, + D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC = 0x02c9, + D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC = 0x02cb, + D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC = 0x02cd, + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY = 0x02ce, + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT = 0x02cf, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY = 0x02d0, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT = 0x02d1, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS = 0x02d2, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC = 0x02d3, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT = 0x02d4, + D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID = 0x02d5, + D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID = 0x02d6, + D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID = 0x02d7, + D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID = 0x02d8, + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS = 0x02d9, + D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS = 0x02db, + D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY = 0x02dc, + D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS = 0x02dd, + D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS = 0x02de, + D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED = 0x02df, + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT = 0x02e1, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT = 0x02e2, + D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE = 0x02e3, + D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET = 0x02e4, + D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE = 0x02e3, + D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET = 0x02e4, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP = 0x02e5, + D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID = 0x02e6, + D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID = 0x02e7, + D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS = 0x02e8, + D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION = 0x02e9, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE = 0x032f, + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT = 0x0330, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT = 0x0331, + D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH = 0x0332, + D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE = 0x0334, + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE = 0x0335, + D3D12_MESSAGE_ID_MAP_INVALIDHEAP = 0x0336, + D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP = 0x0337, + D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE = 0x0338, + D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE = 0x0339, + D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE = 0x033a, + D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE = 0x033b, + D3D12_MESSAGE_ID_MAP_INVALIDRANGE = 0x033c, + D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE = 0x033d, + D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER = 0x0340, + D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN = 0x0341, + D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN = 0x0342, + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED = 0x0343, + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH = 0x0344, + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST = 0x0345, + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST = 0x0346, + D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST = 0x0347, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION = 0x0348, + D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS = 0x0349, + D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC = 0x034a, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION = 0x034b, + D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS = 0x034c, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS = 0x034d, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST = 0x034e, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE = 0x034f, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION = 0x0350, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE = 0x0351, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE = 0x0352, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET = 0x0353, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT = 0x0354, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT = 0x0355, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS = 0x0356, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH = 0x0357, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT = 0x0358, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT = 0x0359, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS = 0x035a, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC = 0x035b, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE = 0x035c, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION = 0x035d, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE = 0x035e, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE = 0x035f, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET = 0x0360, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT = 0x0361, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT = 0x0362, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS = 0x0363, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH = 0x0364, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT = 0x0365, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT = 0x0366, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS = 0x0367, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES = 0x0368, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX = 0x0369, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH = 0x036a, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX = 0x036b, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS = 0x036c, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX = 0x036d, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT = 0x036e, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH = 0x036f, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT = 0x0370, + D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER = 0x0371, + D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH = 0x0372, + D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE = 0x0373, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB = 0x0374, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH = 0x0375, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH = 0x0376, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH = 0x0377, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED = 0x0378, + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP = 0x0379, + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE = 0x037a, + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX = 0x037b, + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE = 0x037c, + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX = 0x037d, + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP = 0x037e, + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE = 0x037f, + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX = 0x0380, + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE = 0x0381, + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX = 0x0382, + D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED = 0x0383, + D3D12_MESSAGE_ID_INVALID_NODE_INDEX = 0x0384, + D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE = 0x0385, + D3D12_MESSAGE_ID_NODE_MASK_MISMATCH = 0x0386, + D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY = 0x0387, + D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES = 0x0388, + D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES = 0x0389, + D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES = 0x038a, + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE = 0x038b, + D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS = 0x038c, + D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE = 0x038d, + D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS = 0x038e, + D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS = 0x038f, + D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT = 0x0390, + D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS = 0x0391, + D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES = 0x0392, + D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE = 0x0393, + D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT = 0x0394, + D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT = 0x0395, + D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY = 0x0396, + D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE = 0x0397, + D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY = 0x0398, + D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE = 0x0399, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS = 0x039a, + D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE = 0x039b, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED = 0x039c, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT = 0x039d, + D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS = 0x039e, + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED = 0x039f, + D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY = 0x03a1, + D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE = 0x03a2, + D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE = 0x03a3, + D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT = 0x03a4, + D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT = 0x03a5, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED = 0x03a6, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED = 0x03a7, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS = 0x03a8, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS = 0x03a9, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED = 0x03aa, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH = 0x03ab, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH = 0x03ac, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH = 0x03ad, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE = 0x03ae, + D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST = 0x03af, + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE = 0x03b0, + D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC = 0x03b1, + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE = 0x03b2, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST = 0x03b3, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE = 0x03b4, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC = 0x03b5, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE = 0x03b6, + D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH = 0x03b7, + D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET = 0x03b8, + D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH = 0x03b9, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS = 0x03ba, + D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH = 0x03bb, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH = 0x03bc, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END = 0x03bd, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE = 0x03be, + D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT = 0x03bf, + D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE = 0x03c0, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS = 0x03c1, + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB = 0x03c2, + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH = 0x03c3, + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH = 0x03c4, + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED = 0x03c5, + D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY = 0x03c6, + D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY = 0x03c7, + D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY = 0x03c8, + D3D12_MESSAGE_ID_STOREPIPELINE_NONAME = 0x03c9, + D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME = 0x03ca, + D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND = 0x03cb, + D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC = 0x03cc, + D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY = 0x03cd, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH = 0x03ce, + D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS = 0x03cf, + D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED = 0x03d0, + D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED = 0x03d1, + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED = 0x03d2, + D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST = 0x03d3, + D3D12_MESSAGE_ID_CREATE_VIDEODECODER = 0x03d4, + D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM = 0x03d5, + D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST = 0x03d6, + D3D12_MESSAGE_ID_LIVE_VIDEODECODER = 0x03d7, + D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM = 0x03d8, + D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST = 0x03d9, + D3D12_MESSAGE_ID_DESTROY_VIDEODECODER = 0x03da, + D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM = 0x03db, + D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS = 0x03dc, + D3D12_MESSAGE_ID_DEPRECATED_API = 0x03dd, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE = 0x03de, + D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET = 0x03df, + D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET = 0x03e0, + D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET = 0x03e1, + D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET = 0x03e2, + D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE = 0x03e3, + D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS = 0x03e4, + D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D = 0x03e5, + D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE = 0x03e6, + D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE = 0x03e7, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED = 0x03e8, + D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE = 0x03e9, + D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE = 0x03ea, + D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE = 0x03eb, + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET = 0x03ec, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS = 0x03ed, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH = 0x03ee, + D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS = 0x03ef, + D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS = 0x03f0, + D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY = 0x03f1, + D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS = 0x03f5, + D3D12_MESSAGE_ID_BEGIN_EVENT = 0x03f6, + D3D12_MESSAGE_ID_END_EVENT = 0x03f7, + D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS = 0x03f8, + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED = 0x03f9, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT = 0x03fa, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT = 0x03fb, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM = 0x03fc, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM = 0x03fd, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE = 0x03fe, + D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH = 0x03ff, + D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME = 0x0400, + D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME = 0x0401, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE = 0x0402, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST = 0x0403, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION = 0x0404, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS = 0x0405, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC = 0x0406, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION = 0x0407, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS = 0x0408, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT = 0x0409, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES = 0x040a, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES = 0x040b, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE = 0x040c, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE = 0x040d, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS = 0x040e, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS = 0x040f, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES = 0x0410, + D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG = 0x0411, + D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE = 0x0412, + D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS = 0x0413, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE = 0x0414, + D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET = 0x0415, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH = 0x0416, + D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE = 0x0417, + D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED = 0x0418, + D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS = 0x0419, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT = 0x041a, + D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE = 0x041b, + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST = 0x041c, + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE = 0x041d, + D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE = 0x041e, + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST = 0x041f, + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE = 0x0420, + D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE = 0x0421, + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST = 0x0422, + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE = 0x0423, + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR = 0x0424, + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM = 0x0425, + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR = 0x0426, + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM = 0x0427, + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR = 0x0428, + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM = 0x0429, + D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS = 0x042a, + D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT = 0x042b, + D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION = 0x042c, + D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY = 0x042d, + D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION = 0x042e, + D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION = 0x042f, + D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY = 0x0430, + D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION = 0x0431, + D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION = 0x0432, + D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY = 0x0433, + D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION = 0x0434, + D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED = 0x0435, + D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION = 0x0436, + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED = 0x0437, + D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED = 0x0438, + D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE = 0x0439, + D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR = 0x043a, + D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP = 0x043b, + D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP = 0x043c, + D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP = 0x043d, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN = 0x043e, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN = 0x043f, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS = 0x0440, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE = 0x0441, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST = 0x0442, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE = 0x0443, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT = 0x0444, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED = 0x0445, + D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS = 0x0446, + D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED = 0x0447, + D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS = 0x0448, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 0x0449, + D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 0x044a, + D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE = 0x044b, + D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED = 0x044c, + D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT = 0x044d, + D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED = 0x044e, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR = 0x044f, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED = 0x0450, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR = 0x0451, + D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT = 0x0452, + D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT = 0x0453, + D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE = 0x0454, + D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT = 0x0455, + D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT = 0x0456, + D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS = 0x0457, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED = 0x0458, + D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT = 0x0459, + D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED = 0x045a, + D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER = 0x045b, + D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER = 0x045c, + D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER = 0x045d, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED = 0x045e, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS = 0x045f, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS = 0x0460, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS = 0x0461, + D3D12_MESSAGE_ID_CREATE_COMMANDPOOL = 0x0462, + D3D12_MESSAGE_ID_LIVE_COMMANDPOOL = 0x0463, + D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL = 0x0464, + D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS = 0x0465, + D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED = 0x0466, + D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH = 0x0467, + D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION = 0x0468, + D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST = 0x0469, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST = 0x046a, + D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST = 0x046b, + D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS = 0x046c, + D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET = 0x046d, + D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING = 0x046e, + D3D12_MESSAGE_ID_COMMAND_POOL_SYNC = 0x046f, + D3D12_MESSAGE_ID_EVICT_UNDERFLOW = 0x0470, + D3D12_MESSAGE_ID_CREATE_META_COMMAND = 0x0471, + D3D12_MESSAGE_ID_LIVE_META_COMMAND = 0x0472, + D3D12_MESSAGE_ID_DESTROY_META_COMMAND = 0x0473, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE = 0x0474, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE = 0x0475, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE = 0x0476, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE = 0x0477, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER = 0x0478, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC = 0x0479, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED = 0x047a, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION = 0x047b, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS = 0x047c, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET = 0x047d, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION = 0x047e, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS = 0x047f, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN = 0x0480, + D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER = 0x0481, + D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES = 0x0482, + D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE = 0x0483, + D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS = 0x0484, + D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED = 0x0485, + D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 0x0486, + D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID = 0x0487, + D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 0x0488, + D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID = 0x0489, + D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID = 0x048a, + D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER = 0x048b, + D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER = 0x048c, + D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER = 0x048d, + D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED = 0x048e, + D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD = 0x048f, + D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD = 0x0490, + D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD = 0x0491, + D3D12_MESSAGE_ID_RENDER_PASS_ERROR = 0x0492, + D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID = 0x0493, + D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS = 0x0494, + D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION = 0x0495, + D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH = 0x0496, + D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND = 0x0497, + D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS = 0x0498, + D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST = 0x0499, + D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST = 0x049a, + D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST = 0x049b, + D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE = 0x049c, + D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE = 0x049d, + D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE = 0x049e, + D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR = 0x049f, + D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR = 0x04a0, + D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR = 0x04a1, + D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP = 0x04a2, + D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP = 0x04a3, + D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP = 0x04a4, + D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS = 0x04a5, + D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS = 0x04a6, + D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR = 0x04a7, + D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD = 0x04a8, + D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR = 0x04a9, + D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR = 0x04aa, + D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR = 0x04ab, + D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR = 0x04ac, + D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR = 0x04ad, + D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR = 0x04ae, + D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID = 0x04af, + D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID = 0x04b0, + D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE = 0x04b1, + D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER = 0x04b2, + D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED = 0x04b3, + D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES = 0x04b4, + D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN = 0x04b5, + D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST = 0x04b6, + D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED = 0x04b7, + D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME = 0x04b8, + D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS = 0x04b9, + D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS = 0x04ba, + D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH = 0x04bb, + D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED = 0x04bc, + D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS = 0x04bd, + D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE = 0x04be, + D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR = 0x04bf, + D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL = 0x04c0, + D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT = 0x04c1, + D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT = 0x04c2, + D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 0x04c3, + D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT = 0x04c4, + D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 0x04c5, + D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE = 0x04c6, + D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT = 0x04c7, + D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL = 0x04c8, + D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND = 0x04c9, + D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND = 0x04ca, + D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND = 0x04cb, + D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID = 0x04cc, + D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT = 0x04cd, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY = 0x04ce, + D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR = 0x04cf, + D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 0x04d0, + D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE = 0x04d1, + D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP = 0x04d2, + D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER = 0x04d3, + D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2 = 0x04d4, + D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1 = 0x04d5, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT = 0x04d6, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE = 0x04d7, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL = 0x04d8, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT = 0x04d9, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY = 0x04da, + D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE = 0x04db, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH = 0x04dc, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH = 0x04dd, + D3D12_MESSAGE_ID_ADD_TO_STATE_OBJECT_ERROR = 0x04de, + D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT = 0x04df, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH = 0x04e0, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE = 0x04e1, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH = 0x04e2, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH = 0x04e3, + D3D12_MESSAGE_ID_NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT = 0x04e4, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH = 0x04e5, + D3D12_MESSAGE_ID_EMPTY_DISPATCH = 0x04e6, + D3D12_MESSAGE_ID_RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY = 0x04e7, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION = 0x04e8, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION = 0x04e9, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT = 0x04ea, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY = 0x04eb, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT = 0x04ec, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG = 0x04ed, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS = 0x04ee, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY = 0x04ef, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT = 0x04f0, + D3D12_MESSAGE_ID_CREATEMESHSHADER_INVALIDSHADERBYTECODE = 0x04f1, + D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTOFMEMORY = 0x04f2, + D3D12_MESSAGE_ID_CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = 0x04f3, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT = 0x04f4, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT = 0x04f5, + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH = 0x04f6, + D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE = 0x04f7, + D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE = 0x04f8, + D3D12_MESSAGE_ID_CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE = 0x04f9, + D3D12_MESSAGE_ID_VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 0x04fa, + D3D12_MESSAGE_ID_MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 0x04fb, + D3D12_MESSAGE_ID_CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE = 0x04fc, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS = 0x04fd, + D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE = 0x04fe, + D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_OUTOFMEMORY = 0x04ff, + D3D12_MESSAGE_ID_D3D12_MESSAGES_END +} D3D12_MESSAGE_ID; + +typedef enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE +{ + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE = 0x0, + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY = 0x1, + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION = 0x2, + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION = 0x3, + NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = 0x4, +} D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE; + +typedef enum D3D12_GPU_BASED_VALIDATION_FLAGS +{ + D3D12_GPU_BASED_VALIDATION_FLAGS_NONE = 0x00, + D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING = 0x01, +} D3D12_GPU_BASED_VALIDATION_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS)") + +typedef enum D3D12_RLDO_FLAGS +{ + D3D12_RLDO_NONE = 0x0, + D3D12_RLDO_SUMMARY = 0x1, + D3D12_RLDO_DETAIL = 0x2, + D3D12_RLDO_IGNORE_INTERNAL = 0x4, +} D3D12_RLDO_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS)") + +typedef enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE +{ + D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS, + D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS, + D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR, +} D3D12_DEBUG_DEVICE_PARAMETER_TYPE; + +typedef enum D3D12_DEBUG_FEATURE +{ + D3D12_DEBUG_FEATURE_NONE = 0x00, + D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = 0x01, + D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING = 0x02, + D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = 0x04, + D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7 = 0x08, +} D3D12_DEBUG_FEATURE; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE)") + +typedef enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS +{ + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE = 0x00, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = 0x01, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 0x02, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = 0x04, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK = 0x07 +} D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS)") + +typedef enum D3D12_MESSAGE_CALLBACK_FLAGS +{ + D3D12_MESSAGE_CALLBACK_FLAG_NONE = 0x00, + D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS = 0x01, +} D3D12_MESSAGE_CALLBACK_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MESSAGE_CALLBACK_FLAGS)") + +typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS +{ + UINT MaxMessagesPerCommandList; + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode; + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags; +} D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS; + +typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR +{ + FLOAT SlowdownFactor; +} D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR; + +typedef struct D3D12_MESSAGE +{ + D3D12_MESSAGE_CATEGORY Category; + D3D12_MESSAGE_SEVERITY Severity; + D3D12_MESSAGE_ID ID; + const char *pDescription; + SIZE_T DescriptionByteLength; +} D3D12_MESSAGE; + +typedef struct D3D12_INFO_QUEUE_FILTER_DESC +{ + UINT NumCategories; + D3D12_MESSAGE_CATEGORY *pCategoryList; + UINT NumSeverities; + D3D12_MESSAGE_SEVERITY *pSeverityList; + UINT NumIDs; + D3D12_MESSAGE_ID *pIDList; +} D3D12_INFO_QUEUE_FILTER_DESC; + +typedef struct D3D12_INFO_QUEUE_FILTER +{ + D3D12_INFO_QUEUE_FILTER_DESC AllowList; + D3D12_INFO_QUEUE_FILTER_DESC DenyList; +} D3D12_INFO_QUEUE_FILTER; + +[ + uuid(344488b7-6846-474b-b989-f027448245e0), + object, + local, + pointer_default(unique) +] +interface ID3D12Debug : IUnknown +{ + void EnableDebugLayer(); +} + +[ + uuid(affaa4ca-63fe-4d8e-b8ad-159000af4304), + object, + local, + pointer_default(unique) +] +interface ID3D12Debug1 : IUnknown +{ + void EnableDebugLayer(); + void SetEnableGPUBasedValidation(BOOL enable); + void SetEnableSynchronizedCommandQueueValidation(BOOL enable); +} + +[ + uuid(93a665c4-a3b2-4e5d-b692-a26ae14e3374), + object, + local, + pointer_default(unique) +] +interface ID3D12Debug2 : IUnknown +{ + void SetGPUBasedValidationFlags(D3D12_GPU_BASED_VALIDATION_FLAGS flags); +} + +[ + uuid(5cf4e58f-f671-4ff1-a542-3686e3d153d1), + object, + local, + pointer_default(unique) +] +interface ID3D12Debug3 : ID3D12Debug +{ + void SetEnableGPUBasedValidation(BOOL enable); + void SetEnableSynchronizedCommandQueueValidation(BOOL enable); + void SetGPUBasedValidationFlags(D3D12_GPU_BASED_VALIDATION_FLAGS flags); +} + +[ + uuid(014b816e-9ec5-4a2f-a845-ffbe441ce13a), + object, + local, + pointer_default(unique) +] +interface ID3D12Debug4 : ID3D12Debug3 +{ + void DisableDebugLayer(); +} + +[ + uuid(548d6b12-09fa-40e0-9069-5dcd589a52c9), + object, + local, + pointer_default(unique) +] +interface ID3D12Debug5 : ID3D12Debug4 +{ + void SetEnableAutoName(BOOL enable); +} + +[ + uuid(3febd6dd-4973-4787-8194-e45f9e28923e), + object, + local, + pointer_default(unique) +] +interface ID3D12DebugDevice : IUnknown +{ + HRESULT SetFeatureMask(D3D12_DEBUG_FEATURE mask); + D3D12_DEBUG_FEATURE GetFeatureMask(); + HRESULT ReportLiveDeviceObjects(D3D12_RLDO_FLAGS flags); +} + +[ + uuid(a9b71770-d099-4a65-a698-3dee10020f88), + object, + local, + pointer_default(unique) +] +interface ID3D12DebugDevice1 : IUnknown +{ + HRESULT SetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, const void *data, UINT size); + HRESULT GetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, void *data, UINT size); + HRESULT ReportLiveDeviceObjects(D3D12_RLDO_FLAGS flags); +} + +[ + uuid(60eccbc1-378d-4df1-894c-f8ac5ce4d7dd), + object, + local, + pointer_default(unique) +] +interface ID3D12DebugDevice2 : ID3D12DebugDevice +{ + HRESULT SetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, const void *data, UINT size); + HRESULT GetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, void *data, UINT size); +} + +[ + uuid(0adf7d52-929c-4e61-addb-ffed30de66ef), + object, + local, + pointer_default(unique) +] +interface ID3D12SharingContract : IUnknown +{ + void Present(ID3D12Resource *resource, UINT sub_resource, HWND window); + void SharedFenceSignal(ID3D12Fence *fence, UINT64 fence_value); + void BeginCapturableWork(REFGUID guid); + void EndCapturableWork(REFGUID guid); +} + +[ + uuid(0742a90b-c387-483f-b946-30a7e4e61458), + object, + local, + pointer_default(unique) +] +interface ID3D12InfoQueue : IUnknown +{ + HRESULT SetMessageCountLimit([in] UINT64 limit); + void ClearStoredMessages(); + HRESULT GetMessage([in] UINT64 index, [out] D3D12_MESSAGE *message, [in, out] SIZE_T *length); + UINT64 GetNumMessagesAllowedByStorageFilter(); + UINT64 GetNumMessagesDeniedByStorageFilter(); + UINT64 GetNumStoredMessages(); + UINT64 GetNumStoredMessagesAllowedByRetrievalFilter(); + UINT64 GetNumMessagesDiscardedByMessageCountLimit(); + UINT64 GetMessageCountLimit(); + HRESULT AddStorageFilterEntries([in] D3D12_INFO_QUEUE_FILTER *filter); + HRESULT GetStorageFilter([out] D3D12_INFO_QUEUE_FILTER *filter, [in, out] SIZE_T *length); + void ClearStorageFilter(); + HRESULT PushEmptyStorageFilter(); + HRESULT PushCopyOfStorageFilter(); + HRESULT PushStorageFilter([in] D3D12_INFO_QUEUE_FILTER *filter); + void PopStorageFilter(); + UINT GetStorageFilterStackSize(); + HRESULT AddRetrievalFilterEntries([in] D3D12_INFO_QUEUE_FILTER *filter); + HRESULT GetRetrievalFilter([out] D3D12_INFO_QUEUE_FILTER *filter, [in, out] SIZE_T *length); + void ClearRetrievalFilter(); + HRESULT PushEmptyRetrievalFilter(); + HRESULT PushCopyOfRetrievalFilter(); + HRESULT PushRetrievalFilter([in] D3D12_INFO_QUEUE_FILTER *filter); + void PopRetrievalFilter(); + UINT GetRetrievalFilterStackSize(); + HRESULT AddMessage([in] D3D12_MESSAGE_CATEGORY category, [in] D3D12_MESSAGE_SEVERITY severity, + [in] D3D12_MESSAGE_ID id, [in] const char *description); + HRESULT AddApplicationMessage([in] D3D12_MESSAGE_SEVERITY severity, [in] const char *description); + HRESULT SetBreakOnCategory([in] D3D12_MESSAGE_CATEGORY category, [in] BOOL enable); + HRESULT SetBreakOnSeverity([in] D3D12_MESSAGE_SEVERITY severity, [in] BOOL enable); + HRESULT SetBreakOnID([in] D3D12_MESSAGE_ID id, [in] BOOL enable); + BOOL GetBreakOnCategory([in] D3D12_MESSAGE_CATEGORY category); + BOOL GetBreakOnSeverity([in] D3D12_MESSAGE_SEVERITY severity); + BOOL GetBreakOnID([in] D3D12_MESSAGE_ID id); + void SetMuteDebugOutput([in] BOOL mute); + BOOL GetMuteDebugOutput(); +} + +typedef void (__stdcall *D3D12MessageFunc)(D3D12_MESSAGE_CATEGORY category, + D3D12_MESSAGE_SEVERITY severity, D3D12_MESSAGE_ID id, const char *description, void *context); + +[ + uuid(2852dd88-b484-4c0c-b6b1-67168500e600), + object, + local, + pointer_default(unique) +] +interface ID3D12InfoQueue1 : ID3D12InfoQueue +{ + HRESULT RegisterMessageCallback([in] D3D12MessageFunc func, + [in] D3D12_MESSAGE_CALLBACK_FLAGS flags, [in] void *context, [in, out] DWORD *cookie); + HRESULT UnregisterMessageCallback([in] DWORD cookie); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d12shader.idl b/WineFix/lib/d2d1/include/windows/d3d12shader.idl new file mode 100644 index 0000000..d66080f --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d12shader.idl @@ -0,0 +1,311 @@ +/* + * Copyright 2020 Paul Gofman for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "d3dcommon.idl"; + +typedef enum D3D12_SHADER_VERSION_TYPE +{ + D3D12_SHVER_PIXEL_SHADER = 0x0, + D3D12_SHVER_VERTEX_SHADER = 0x1, + D3D12_SHVER_GEOMETRY_SHADER = 0x2, + D3D12_SHVER_HULL_SHADER = 0x3, + D3D12_SHVER_DOMAIN_SHADER = 0x4, + D3D12_SHVER_COMPUTE_SHADER = 0x5, + D3D12_SHVER_RESERVED0 = 0xfff0, +} D3D12_SHADER_VERSION_TYPE; + +cpp_quote("#define D3D12_SHVER_GET_TYPE(v) (((v) >> 16) & 0xffff)") +cpp_quote("#define D3D12_SHVER_GET_MAJOR(v) (((v) >> 4) & 0xf)") +cpp_quote("#define D3D12_SHVER_GET_MINOR(v) (((v) >> 0) & 0xf)") + +typedef struct _D3D12_SHADER_DESC +{ + UINT Version; + const char *Creator; + UINT Flags; + UINT ConstantBuffers; + UINT BoundResources; + UINT InputParameters; + UINT OutputParameters; + UINT InstructionCount; + UINT TempRegisterCount; + UINT TempArrayCount; + UINT DefCount; + UINT DclCount; + UINT TextureNormalInstructions; + UINT TextureLoadInstructions; + UINT TextureCompInstructions; + UINT TextureBiasInstructions; + UINT TextureGradientInstructions; + UINT FloatInstructionCount; + UINT IntInstructionCount; + UINT UintInstructionCount; + UINT StaticFlowControlCount; + UINT DynamicFlowControlCount; + UINT MacroInstructionCount; + UINT ArrayInstructionCount; + UINT CutInstructionCount; + UINT EmitInstructionCount; + D3D_PRIMITIVE_TOPOLOGY GSOutputTopology; + UINT GSMaxOutputVertexCount; + D3D_PRIMITIVE InputPrimitive; + UINT PatchConstantParameters; + UINT cGSInstanceCount; + UINT cControlPoints; + D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive; + D3D_TESSELLATOR_PARTITIONING HSPartitioning; + D3D_TESSELLATOR_DOMAIN TessellatorDomain; + UINT cBarrierInstructions; + UINT cInterlockedInstructions; + UINT cTextureStoreInstructions; +} D3D12_SHADER_DESC; + +typedef struct _D3D12_SHADER_VARIABLE_DESC +{ + const char *Name; + UINT StartOffset; + UINT Size; + UINT uFlags; + void *DefaultValue; + UINT StartTexture; + UINT TextureSize; + UINT StartSampler; + UINT SamplerSize; +} D3D12_SHADER_VARIABLE_DESC; + +typedef struct _D3D12_SHADER_TYPE_DESC +{ + D3D_SHADER_VARIABLE_CLASS Class; + D3D_SHADER_VARIABLE_TYPE Type; + UINT Rows; + UINT Columns; + UINT Elements; + UINT Members; + UINT Offset; + const char *Name; +} D3D12_SHADER_TYPE_DESC; + +typedef struct _D3D12_SHADER_BUFFER_DESC +{ + const char *Name; + D3D_CBUFFER_TYPE Type; + UINT Variables; + UINT Size; + UINT uFlags; +} D3D12_SHADER_BUFFER_DESC; + +typedef struct _D3D12_SHADER_INPUT_BIND_DESC +{ + const char *Name; + D3D_SHADER_INPUT_TYPE Type; + UINT BindPoint; + UINT BindCount; + UINT uFlags; + D3D_RESOURCE_RETURN_TYPE ReturnType; + D3D_SRV_DIMENSION Dimension; + UINT NumSamples; + UINT Space; + UINT uID; +} D3D12_SHADER_INPUT_BIND_DESC; + +typedef struct _D3D12_SIGNATURE_PARAMETER_DESC +{ + const char *SemanticName; + UINT SemanticIndex; + UINT Register; + D3D_NAME SystemValueType; + D3D_REGISTER_COMPONENT_TYPE ComponentType; + BYTE Mask; + BYTE ReadWriteMask; + UINT Stream; + D3D_MIN_PRECISION MinPrecision; +} D3D12_SIGNATURE_PARAMETER_DESC; + +typedef struct _D3D12_PARAMETER_DESC +{ + const char *Name; + const char *SemanticName; + D3D_SHADER_VARIABLE_TYPE Type; + D3D_SHADER_VARIABLE_CLASS Class; + UINT Rows; + UINT Columns; + D3D_INTERPOLATION_MODE InterpolationMode; + D3D_PARAMETER_FLAGS Flags; + UINT FirstInRegister; + UINT FirstInComponent; + UINT FirstOutRegister; + UINT FirstOutComponent; +} D3D12_PARAMETER_DESC; + +typedef struct _D3D12_FUNCTION_DESC +{ + UINT Version; + const char *Creator; + UINT Flags; + UINT ConstantBuffers; + UINT BoundResources; + UINT InstructionCount; + UINT TempRegisterCount; + UINT TempArrayCount; + UINT DefCount; + UINT DclCount; + UINT TextureNormalInstructions; + UINT TextureLoadInstructions; + UINT TextureCompInstructions; + UINT TextureBiasInstructions; + UINT TextureGradientInstructions; + UINT FloatInstructionCount; + UINT IntInstructionCount; + UINT UintInstructionCount; + UINT StaticFlowControlCount; + UINT DynamicFlowControlCount; + UINT MacroInstructionCount; + UINT ArrayInstructionCount; + UINT MovInstructionCount; + UINT MovcInstructionCount; + UINT ConversionInstructionCount; + UINT BitwiseInstructionCount; + D3D_FEATURE_LEVEL MinFeatureLevel; + UINT64 RequiredFeatureFlags; + const char *Name; + INT FunctionParameterCount; + BOOL HasReturn; + BOOL Has10Level9VertexShader; + BOOL Has10Level9PixelShader; +} D3D12_FUNCTION_DESC; + +typedef struct _D3D12_LIBRARY_DESC +{ + const char *Creator; + UINT Flags; + UINT FunctionCount; +} D3D12_LIBRARY_DESC; + +interface ID3D12ShaderReflectionConstantBuffer; + +[ + uuid(e913c351-783d-48ca-a1d1-4f306284ad56), + object, + local, +] +interface ID3D12ShaderReflectionType +{ + HRESULT GetDesc(D3D12_SHADER_TYPE_DESC *desc); + ID3D12ShaderReflectionType *GetMemberTypeByIndex(UINT index); + ID3D12ShaderReflectionType *GetMemberTypeByName(const char *name); + const char *GetMemberTypeName(UINT index); + HRESULT IsEqual(ID3D12ShaderReflectionType *type); + ID3D12ShaderReflectionType *GetSubType(); + ID3D12ShaderReflectionType *GetBaseClass(); + UINT GetNumInterfaces(); + ID3D12ShaderReflectionType *GetInterfaceByIndex(UINT index); + HRESULT IsOfType(ID3D12ShaderReflectionType *type); + HRESULT ImplementsInterface(ID3D12ShaderReflectionType *base); +} + +[ + uuid(8337a8a6-a216-444a-b2f4-314733a73aea), + object, + local, +] +interface ID3D12ShaderReflectionVariable +{ + HRESULT GetDesc(D3D12_SHADER_VARIABLE_DESC *desc); + ID3D12ShaderReflectionType *GetType(); + ID3D12ShaderReflectionConstantBuffer *GetBuffer(); + UINT GetInterfaceSlot(UINT index); +} + +[ + uuid(c59598b4-48b3-4869-b9b1-b1618b14a8b7), + object, + local, +] +interface ID3D12ShaderReflectionConstantBuffer +{ + HRESULT GetDesc(D3D12_SHADER_BUFFER_DESC *desc); + ID3D12ShaderReflectionVariable *GetVariableByIndex(UINT index); + ID3D12ShaderReflectionVariable *GetVariableByName(const char *name); +} + +[ + uuid(5a58797d-a72c-478d-8ba2-efc6b0efe88e), + object, + local, +] +interface ID3D12ShaderReflection : IUnknown +{ + HRESULT GetDesc(D3D12_SHADER_DESC *desc); + ID3D12ShaderReflectionConstantBuffer *GetConstantBufferByIndex(UINT index); + ID3D12ShaderReflectionConstantBuffer *GetConstantBufferByName(const char *name); + HRESULT GetResourceBindingDesc(UINT index, D3D12_SHADER_INPUT_BIND_DESC *desc); + HRESULT GetInputParameterDesc(UINT index, D3D12_SIGNATURE_PARAMETER_DESC *desc); + HRESULT GetOutputParameterDesc(UINT index, D3D12_SIGNATURE_PARAMETER_DESC *desc); + HRESULT GetPatchConstantParameterDesc(UINT index, D3D12_SIGNATURE_PARAMETER_DESC *desc); + ID3D12ShaderReflectionVariable *GetVariableByName(const char *name); + HRESULT GetResourceBindingDescByName(const char *name, D3D12_SHADER_INPUT_BIND_DESC *desc); + UINT GetMovInstructionCount(); + UINT GetMovcInstructionCount(); + UINT GetConversionInstructionCount(); + UINT GetBitwiseInstructionCount(); + D3D_PRIMITIVE GetGSInputPrimitive(); + BOOL IsSampleFrequencyShader(); + UINT GetNumInterfaceSlots(); + HRESULT GetMinFeatureLevel(D3D_FEATURE_LEVEL *level); + UINT GetThreadGroupSize(UINT *sizex, UINT *sizey, UINT *sizez); + UINT64 GetRequiresFlags(); +} + +[ + uuid(ec25f42d-7006-4f2b-b33e-02cc3375733f), + object, + local, +] +interface ID3D12FunctionParameterReflection +{ + HRESULT GetDesc(D3D12_PARAMETER_DESC *desc); +} + +[ + uuid(1108795c-2772-4ba9-b2a8-d464dc7e2799), + object, + local, +] +interface ID3D12FunctionReflection +{ + HRESULT GetDesc(D3D12_FUNCTION_DESC *desc); + ID3D12ShaderReflectionConstantBuffer *GetConstantBufferByIndex(UINT index); + ID3D12ShaderReflectionConstantBuffer *GetConstantBufferByName(const char *name); + HRESULT GetResourceBindingDesc(UINT index, D3D12_SHADER_INPUT_BIND_DESC *desc); + ID3D12ShaderReflectionVariable *GetVariableByName(const char *name); + HRESULT GetResourceBindingDescByName(const char *name, D3D12_SHADER_INPUT_BIND_DESC *desc); + ID3D12FunctionParameterReflection *GetFunctionParameter(INT index); +} + +[ + uuid(8e349d19-54db-4a56-9dc9-119d87bdb804), + object, + local, +] +interface ID3D12LibraryReflection : IUnknown +{ + HRESULT GetDesc(D3D12_LIBRARY_DESC *desc); + ID3D12FunctionReflection *GetFunctionByIndex(INT index); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d12video.idl b/WineFix/lib/d2d1/include/windows/d3d12video.idl new file mode 100644 index 0000000..f39b28d --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d12video.idl @@ -0,0 +1,1726 @@ +/* + * Copyright (C) 2023 Biswapriyo Nath + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgicommon.idl"; +import "d3d12.idl"; + +typedef enum D3D12_VIDEO_FIELD_TYPE +{ + D3D12_VIDEO_FIELD_TYPE_NONE = 0, + D3D12_VIDEO_FIELD_TYPE_INTERLACED_TOP_FIELD_FIRST = 1, + D3D12_VIDEO_FIELD_TYPE_INTERLACED_BOTTOM_FIELD_FIRST = 2, +} D3D12_VIDEO_FIELD_TYPE; + +typedef enum D3D12_VIDEO_FRAME_STEREO_FORMAT +{ + D3D12_VIDEO_FRAME_STEREO_FORMAT_NONE = 0, + D3D12_VIDEO_FRAME_STEREO_FORMAT_MONO = 1, + D3D12_VIDEO_FRAME_STEREO_FORMAT_HORIZONTAL = 2, + D3D12_VIDEO_FRAME_STEREO_FORMAT_VERTICAL = 3, + D3D12_VIDEO_FRAME_STEREO_FORMAT_SEPARATE = 4, +} D3D12_VIDEO_FRAME_STEREO_FORMAT; + +typedef enum D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE +{ + D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_NONE = 0, + D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_FIELD_BASED = 1, +} D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE; + +typedef enum D3D12_FEATURE_VIDEO +{ + D3D12_FEATURE_VIDEO_DECODE_SUPPORT = 0, + D3D12_FEATURE_VIDEO_DECODE_PROFILES = 1, + D3D12_FEATURE_VIDEO_DECODE_FORMATS = 2, + D3D12_FEATURE_VIDEO_DECODE_CONVERSION_SUPPORT = 3, + D3D12_FEATURE_VIDEO_PROCESS_SUPPORT = 5, + D3D12_FEATURE_VIDEO_PROCESS_MAX_INPUT_STREAMS = 6, + D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO = 7, + D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE = 8, + D3D12_FEATURE_VIDEO_PROCESSOR_SIZE = 9, + D3D12_FEATURE_VIDEO_DECODE_PROFILE_COUNT = 10, + D3D12_FEATURE_VIDEO_DECODE_FORMAT_COUNT = 11, + D3D12_FEATURE_VIDEO_ARCHITECTURE = 17, + D3D12_FEATURE_VIDEO_DECODE_HISTOGRAM = 18, + D3D12_FEATURE_VIDEO_FEATURE_AREA_SUPPORT = 19, + D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR = 20, + D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_SIZE = 21, + D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_COUNT = 22, + D3D12_FEATURE_VIDEO_EXTENSION_COMMANDS = 23, + D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT = 24, + D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETERS = 25, + D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SUPPORT = 26, + D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SIZE = 27, + D3D12_FEATURE_VIDEO_DECODE_PROTECTED_RESOURCES = 28, + D3D12_FEATURE_VIDEO_PROCESS_PROTECTED_RESOURCES = 29, + D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES = 30, + D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE1 = 31, + D3D12_FEATURE_VIDEO_PROCESSOR_SIZE1 = 32, + D3D12_FEATURE_VIDEO_ENCODER_CODEC = 33, + D3D12_FEATURE_VIDEO_ENCODER_PROFILE_LEVEL = 34, + D3D12_FEATURE_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT = 35, + D3D12_FEATURE_VIDEO_ENCODER_OUTPUT_RESOLUTION = 36, + D3D12_FEATURE_VIDEO_ENCODER_INPUT_FORMAT = 37, + D3D12_FEATURE_VIDEO_ENCODER_RATE_CONTROL_MODE = 38, + D3D12_FEATURE_VIDEO_ENCODER_INTRA_REFRESH_MODE = 39, + D3D12_FEATURE_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE = 40, + D3D12_FEATURE_VIDEO_ENCODER_HEAP_SIZE = 41, + D3D12_FEATURE_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT = 42, + D3D12_FEATURE_VIDEO_ENCODER_SUPPORT = 43, + D3D12_FEATURE_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT = 44, + D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS = 45, +} D3D12_FEATURE_VIDEO; + +typedef enum D3D12_BITSTREAM_ENCRYPTION_TYPE +{ + D3D12_BITSTREAM_ENCRYPTION_TYPE_NONE = 0, +} D3D12_BITSTREAM_ENCRYPTION_TYPE; + +typedef struct D3D12_VIDEO_DECODE_CONFIGURATION +{ + GUID DecodeProfile; + D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption; + D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE InterlaceType; +} D3D12_VIDEO_DECODE_CONFIGURATION; + +typedef struct D3D12_VIDEO_DECODER_DESC +{ + UINT NodeMask; + D3D12_VIDEO_DECODE_CONFIGURATION Configuration; +} D3D12_VIDEO_DECODER_DESC; + +typedef struct D3D12_VIDEO_DECODER_HEAP_DESC +{ + UINT NodeMask; + D3D12_VIDEO_DECODE_CONFIGURATION Configuration; + UINT DecodeWidth; + UINT DecodeHeight; + DXGI_FORMAT Format; + DXGI_RATIONAL FrameRate; + UINT BitRate; + UINT MaxDecodePictureBufferCount; +} D3D12_VIDEO_DECODER_HEAP_DESC; + +typedef struct D3D12_VIDEO_SIZE_RANGE +{ + UINT MaxWidth; + UINT MaxHeight; + UINT MinWidth; + UINT MinHeight; +} D3D12_VIDEO_SIZE_RANGE; + +typedef enum D3D12_VIDEO_PROCESS_FILTER +{ + D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS = 0, + D3D12_VIDEO_PROCESS_FILTER_CONTRAST = 1, + D3D12_VIDEO_PROCESS_FILTER_HUE = 2, + D3D12_VIDEO_PROCESS_FILTER_SATURATION = 3, + D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION = 4, + D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT = 5, + D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING = 6, + D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT = 7, +} D3D12_VIDEO_PROCESS_FILTER; + +typedef enum D3D12_VIDEO_PROCESS_FILTER_FLAGS +{ + D3D12_VIDEO_PROCESS_FILTER_FLAG_NONE = 0x0, + D3D12_VIDEO_PROCESS_FILTER_FLAG_BRIGHTNESS = (1 << D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS), + D3D12_VIDEO_PROCESS_FILTER_FLAG_CONTRAST = (1 << D3D12_VIDEO_PROCESS_FILTER_CONTRAST), + D3D12_VIDEO_PROCESS_FILTER_FLAG_HUE = (1 << D3D12_VIDEO_PROCESS_FILTER_HUE), + D3D12_VIDEO_PROCESS_FILTER_FLAG_SATURATION = (1 << D3D12_VIDEO_PROCESS_FILTER_SATURATION), + D3D12_VIDEO_PROCESS_FILTER_FLAG_NOISE_REDUCTION = (1 << D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION), + D3D12_VIDEO_PROCESS_FILTER_FLAG_EDGE_ENHANCEMENT = (1 << D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT), + D3D12_VIDEO_PROCESS_FILTER_FLAG_ANAMORPHIC_SCALING = (1 << D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING), + D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT = (1 << D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT), +} D3D12_VIDEO_PROCESS_FILTER_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS);") + +typedef enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS +{ + D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_NONE = 0x0, + D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_BOB = 0x1, + D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM = 0x80000000, +} D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS );") + +typedef struct D3D12_VIDEO_PROCESS_LUMA_KEY +{ + BOOL Enable; + FLOAT Lower; + FLOAT Upper; +} D3D12_VIDEO_PROCESS_LUMA_KEY; + +typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC +{ + DXGI_FORMAT Format; + DXGI_COLOR_SPACE_TYPE ColorSpace; + DXGI_RATIONAL SourceAspectRatio; + DXGI_RATIONAL DestinationAspectRatio; + DXGI_RATIONAL FrameRate; + D3D12_VIDEO_SIZE_RANGE SourceSizeRange; + D3D12_VIDEO_SIZE_RANGE DestinationSizeRange; + BOOL EnableOrientation; + D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterFlags; + D3D12_VIDEO_FRAME_STEREO_FORMAT StereoFormat; + D3D12_VIDEO_FIELD_TYPE FieldType; + D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode; + BOOL EnableAlphaBlending; + D3D12_VIDEO_PROCESS_LUMA_KEY LumaKey; + UINT NumPastFrames; + UINT NumFutureFrames; + BOOL EnableAutoProcessing; +} D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC; + +typedef enum D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE +{ + D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_OPAQUE = 0, + D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_BACKGROUND = 1, + D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_DESTINATION = 2, + D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_SOURCE_STREAM = 3, +} D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE; + +typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC +{ + DXGI_FORMAT Format; + DXGI_COLOR_SPACE_TYPE ColorSpace; + D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE AlphaFillMode; + UINT AlphaFillModeSourceStreamIndex; + FLOAT BackgroundColor[4]; + DXGI_RATIONAL FrameRate; + BOOL EnableStereo; +} D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC; + +[ + uuid(0946b7c9-ebf6-4047-bb73-8683e27dbb1f), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDecoderHeap : ID3D12Pageable +{ + D3D12_VIDEO_DECODER_HEAP_DESC GetDesc(); +} + +[ + uuid(1f052807-0b46-4acc-8a89-364f793718a4), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDevice : IUnknown +{ + HRESULT CheckFeatureSupport( + D3D12_FEATURE_VIDEO feature_video, + [in, out] void *feature_support_data, + UINT feature_support_data_size + ); + + HRESULT CreateVideoDecoder( + [in] const D3D12_VIDEO_DECODER_DESC *desc, + [in] REFIID riid, + [out, iid_is(riid)] void **video_decoder + ); + + HRESULT CreateVideoDecoderHeap( + [in] const D3D12_VIDEO_DECODER_HEAP_DESC *video_decoder_heap_desc, + [in] REFIID riid, + [out, iid_is(riid)] void **video_decoder_heap + ); + + HRESULT CreateVideoProcessor( + UINT node_mask, + [in] const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *output_stream_desc, + [in] UINT input_stream_descs_count, + [in] const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *input_stream_descs, + [in] REFIID riid, + [out, iid_is(riid)] void **video_processor + ); +} + +[ + uuid(c59b6bdc-7720-4074-a136-17a156037470), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDecoder : ID3D12Pageable +{ + D3D12_VIDEO_DECODER_DESC GetDesc(); +} + +typedef enum D3D12_VIDEO_DECODE_TIER +{ + D3D12_VIDEO_DECODE_TIER_NOT_SUPPORTED = 0, + D3D12_VIDEO_DECODE_TIER_1 = 1, + D3D12_VIDEO_DECODE_TIER_2 = 2, + D3D12_VIDEO_DECODE_TIER_3 = 3, +} D3D12_VIDEO_DECODE_TIER; + +typedef enum D3D12_VIDEO_DECODE_SUPPORT_FLAGS +{ + D3D12_VIDEO_DECODE_SUPPORT_FLAG_NONE = 0x0, + D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED = 0x1, +} D3D12_VIDEO_DECODE_SUPPORT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS);") + +typedef enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS +{ + D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_NONE = 0x0, + D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_HEIGHT_ALIGNMENT_MULTIPLE_32_REQUIRED = 0x1, + D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_POST_PROCESSING_SUPPORTED = 0x2, + D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED = 0x4, + D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME = 0x8, +} D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS);") + +typedef enum D3D12_VIDEO_DECODE_ARGUMENT_TYPE +{ + D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS = 0, + D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX = 1, + D3D12_VIDEO_DECODE_ARGUMENT_TYPE_SLICE_CONTROL = 2, + D3D12_VIDEO_DECODE_ARGUMENT_TYPE_MAX_VALID = 3, +} D3D12_VIDEO_DECODE_ARGUMENT_TYPE; + +typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT +{ + UINT NodeIndex; + D3D12_VIDEO_DECODE_CONFIGURATION Configuration; + UINT Width; + UINT Height; + DXGI_FORMAT DecodeFormat; + DXGI_RATIONAL FrameRate; + UINT BitRate; + D3D12_VIDEO_DECODE_SUPPORT_FLAGS SupportFlags; + D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS ConfigurationFlags; + D3D12_VIDEO_DECODE_TIER DecodeTier; +} D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT; + +typedef struct D3D12_VIDEO_DECODE_FRAME_ARGUMENT +{ + D3D12_VIDEO_DECODE_ARGUMENT_TYPE Type; + UINT Size; + void *pData; +} D3D12_VIDEO_DECODE_FRAME_ARGUMENT; + +typedef struct D3D12_VIDEO_DECODE_REFERENCE_FRAMES +{ + UINT NumTexture2Ds; + ID3D12Resource **ppTexture2Ds; + UINT *pSubresources; + ID3D12VideoDecoderHeap **ppHeaps; +} D3D12_VIDEO_DECODE_REFERENCE_FRAMES; + +typedef struct D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM +{ + ID3D12Resource *pBuffer; + UINT64 Offset; + UINT64 Size; +} D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM; + +typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS +{ + BOOL Enable; + ID3D12Resource *pReferenceTexture2D; + UINT ReferenceSubresource; + DXGI_COLOR_SPACE_TYPE OutputColorSpace; + DXGI_COLOR_SPACE_TYPE DecodeColorSpace; +} D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS; + +typedef struct D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS +{ + UINT NumFrameArguments; + D3D12_VIDEO_DECODE_FRAME_ARGUMENT FrameArguments[D3D12_VIDEO_DECODE_MAX_ARGUMENTS]; + D3D12_VIDEO_DECODE_REFERENCE_FRAMES ReferenceFrames; + D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM CompressedBitstream; + ID3D12VideoDecoderHeap *pHeap; +} D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS; + +typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS +{ + ID3D12Resource *pOutputTexture2D; + UINT OutputSubresource; + D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS ConversionArguments; +} D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS; + +[ + uuid(3b60536e-ad29-4e64-a269-f853837e5e53), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDecodeCommandList : ID3D12CommandList +{ + HRESULT Close(); + + HRESULT Reset( + [in] ID3D12CommandAllocator *allocator + ); + + void ClearState(); + + void ResourceBarrier( + [in] UINT barriers_count, + [in] const D3D12_RESOURCE_BARRIER *barriers + ); + + void DiscardResource( + [in] ID3D12Resource *resource, + [in, optional] const D3D12_DISCARD_REGION *region + ); + + void BeginQuery( + [in] ID3D12QueryHeap *query_heap, + [in] D3D12_QUERY_TYPE type, + [in] UINT index + ); + + void EndQuery( + [in] ID3D12QueryHeap *query_heap, + [in] D3D12_QUERY_TYPE type, + [in] UINT index + ); + + void ResolveQueryData( + [in] ID3D12QueryHeap *query_heap, + [in] D3D12_QUERY_TYPE type, + [in] UINT start_index, + [in] UINT queries_count, + [in] ID3D12Resource *destination_buffer, + [in] UINT64 aligned_destination_buffer_offset + ); + + void SetPredication( + [in, optional] ID3D12Resource *buffer, + [in] UINT64 aligned_buffer_offset, + [in] D3D12_PREDICATION_OP operation + ); + + void SetMarker( + [in] UINT metadata, + [in] const void *data, + [in] UINT size + ); + + void BeginEvent( + [in] UINT metadata, + [in] const void *data, + [in] UINT size + ); + + void EndEvent(); + + void DecodeFrame( + [in] ID3D12VideoDecoder *decoder, + [in] const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *output_arguments, + [in] const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *input_arguments + ); + + void WriteBufferImmediate( + [in] UINT count, + [in] const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *params, + [in, optional] const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes + ); +} + +typedef struct D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM +{ + UINT64 Offset; + ID3D12Resource *pBuffer; +} D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM; + +typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 +{ + BOOL Enable; + ID3D12Resource *pReferenceTexture2D; + UINT ReferenceSubresource; + DXGI_COLOR_SPACE_TYPE OutputColorSpace; + DXGI_COLOR_SPACE_TYPE DecodeColorSpace; + UINT OutputWidth; + UINT OutputHeight; +} D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1; + +typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 +{ + ID3D12Resource *pOutputTexture2D; + UINT OutputSubresource; + D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 ConversionArguments; + D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM Histograms[D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS]; +} D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1; + +[ + uuid(d52f011b-b56e-453c-a05a-a7f311c8f472), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDecodeCommandList1 : ID3D12VideoDecodeCommandList +{ + void DecodeFrame1( + [in] ID3D12VideoDecoder *decoder, + [in] const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *output_arguments, + [in] const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *input_arguments + ); +} + +typedef enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE +{ + D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8 = 0, + D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16 = 1, +} D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE; + +typedef enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION +{ + D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL = 0, +} D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION; + +typedef struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT +{ + UINT NodeIndex; + BOOL VideoDecodeSupport; + BOOL VideoProcessSupport; + BOOL VideoEncodeSupport; +} D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT; + +typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_DESC +{ + UINT NodeMask; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize; + D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision; + D3D12_VIDEO_SIZE_RANGE SizeRange; +} D3D12_VIDEO_MOTION_ESTIMATOR_DESC; + +[ + uuid(33fdae0e-098b-428f-87bb-34b695de08f8), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoMotionEstimator : ID3D12Pageable +{ + D3D12_VIDEO_MOTION_ESTIMATOR_DESC GetDesc(); + + HRESULT GetProtectedResourceSession( + [in] REFIID riid, + [out, iid_is(riid)] void **protected_session + ); +} + +typedef struct D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC +{ + UINT NodeMask; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize; + D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision; + D3D12_VIDEO_SIZE_RANGE SizeRange; +} D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC; + +[ + uuid(5be17987-743a-4061-834b-23d22daea505), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoMotionVectorHeap : ID3D12Pageable +{ + D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC GetDesc(); + + HRESULT GetProtectedResourceSession( + [in] REFIID riid, + [out, iid_is(riid)] void **protected_session + ); +} + +[ + uuid(981611ad-a144-4c83-9890-f30e26d658ab), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDevice1 : ID3D12VideoDevice +{ + HRESULT CreateVideoMotionEstimator( + [in] const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *desc, + [in, optional] ID3D12ProtectedResourceSession *protected_resource_session, + [in] REFIID riid, + [out, iid_is(riid)] void **video_motion_estimator + ); + + HRESULT CreateVideoMotionVectorHeap( + [in] const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *desc, + [in, optional] ID3D12ProtectedResourceSession *protected_resource_session, + [in] REFIID riid, + [out, iid_is(riid)] void **video_motion_vector_heap + ); +} + +typedef struct D3D12_RESOURCE_COORDINATE +{ + UINT64 X; + UINT Y; + UINT Z; + UINT SubresourceIndex; +} D3D12_RESOURCE_COORDINATE; + +typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT +{ + ID3D12VideoMotionVectorHeap *pMotionVectorHeap; +} D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT; + +typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_INPUT +{ + ID3D12Resource *pInputTexture2D; + UINT InputSubresourceIndex; + ID3D12Resource *pReferenceTexture2D; + UINT ReferenceSubresourceIndex; + ID3D12VideoMotionVectorHeap *pHintMotionVectorHeap; +} D3D12_VIDEO_MOTION_ESTIMATOR_INPUT; + +typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT +{ + ID3D12Resource *pMotionVectorTexture2D; + D3D12_RESOURCE_COORDINATE MotionVectorCoordinate; +} D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT; + +typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT +{ + ID3D12VideoMotionVectorHeap *pMotionVectorHeap; + UINT PixelWidth; + UINT PixelHeight; +} D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT; + +[ + uuid(8455293a-0cbd-4831-9b39-fbdbab724723), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoEncodeCommandList : ID3D12CommandList +{ + HRESULT Close(); + + HRESULT Reset( + [in] ID3D12CommandAllocator *allocator + ); + + void ClearState(); + + void ResourceBarrier( + [in] UINT barriers_count, + [in] const D3D12_RESOURCE_BARRIER *barriers + ); + + void DiscardResource( + [in] ID3D12Resource *resource, + [in, optional] const D3D12_DISCARD_REGION *region + ); + + void BeginQuery( + [in] ID3D12QueryHeap *query_heap, + [in] D3D12_QUERY_TYPE type, + [in] UINT index + ); + + void EndQuery( + [in] ID3D12QueryHeap *query_heap, + [in] D3D12_QUERY_TYPE type, + [in] UINT index + ); + + void ResolveQueryData( + [in] ID3D12QueryHeap *query_heap, + [in] D3D12_QUERY_TYPE type, + [in] UINT start_index, + [in] UINT queries_count, + [in] ID3D12Resource *destination_buffer, + [in] UINT64 aligned_destination_buffer_offset + ); + + void SetPredication( + [in, optional] ID3D12Resource *buffer, + [in] UINT64 aligned_buffer_offset, + [in] D3D12_PREDICATION_OP operation + ); + + void SetMarker( + [in] UINT metadata, + [in] const void *data, + [in] UINT size + ); + + void BeginEvent( + [in] UINT metadata, + [in] const void *data, + [in] UINT size + ); + + void EndEvent(); + + void EstimateMotion( + [in] ID3D12VideoMotionEstimator *motion_estimator, + [in] const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *output_arguments, + [in] const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *input_arguments + ); + + void ResolveMotionVectorHeap( + [in] const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *output_arguments, + [in] const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *input_arguments + ); + + void WriteBufferImmediate( + [in] UINT count, + [in] const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *params, + [in] const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes + ); + + void SetProtectedResourceSession( + [in, optional]ID3D12ProtectedResourceSession *protected_resource_session + ); +} + +typedef struct D3D12_VIDEO_EXTENSION_COMMAND_DESC +{ + UINT NodeMask; + GUID CommandId; +} D3D12_VIDEO_EXTENSION_COMMAND_DESC; + +[ + uuid(554e41e8-ae8e-4a8c-b7d2-5b4f274a30e4), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoExtensionCommand : ID3D12Pageable +{ + D3D12_VIDEO_EXTENSION_COMMAND_DESC GetDesc(); + + HRESULT GetProtectedResourceSession( + [in] REFIID riid, + [out, iid_is(riid)] void **protected_session + ); +} + +[ + uuid(f019ac49-f838-4a95-9b17-579437c8f513), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDevice2 : ID3D12VideoDevice1 +{ + HRESULT CreateVideoDecoder1( + [in] const D3D12_VIDEO_DECODER_DESC *desc, + [in, optional] ID3D12ProtectedResourceSession *protected_resource_session, + [in] REFIID riid, + [out, iid_is(riid)] void **video_decoder + ); + + HRESULT CreateVideoDecoderHeap1( + [in] const D3D12_VIDEO_DECODER_HEAP_DESC *video_decoder_heap_desc, + [in, optional] ID3D12ProtectedResourceSession *protected_resource_session, + [in] REFIID riid, + [out, iid_is(riid)] void **video_decoder_heap + ); + + HRESULT CreateVideoProcessor1( + [in] UINT node_mask, + [in] const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *output_stream_desc, + [in] UINT input_stream_descs_count, + [in] const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *input_stream_descs, + [in, optional] ID3D12ProtectedResourceSession *protected_resource_session, + [in] REFIID riid, + [out, iid_is(riid)] void **video_processor + ); + + HRESULT CreateVideoExtensionCommand( + [in] const D3D12_VIDEO_EXTENSION_COMMAND_DESC *desc, + [in] const void *creation_parameters, + [in] SIZE_T creation_parameters_data_size_in_bytes, + [in, optional] ID3D12ProtectedResourceSession *protected_resource_session, + [in] REFIID riid, + [out] void **video_extension_command + ); + + HRESULT ExecuteExtensionCommand( + [in] ID3D12VideoExtensionCommand *extension_command, + [in] const void *execution_parameters, + [in] SIZE_T execution_parameters_size_in_bytes, + [out] void *output_data, + [in] SIZE_T output_data_size_in_bytes + ); +} + +[ + uuid(94971eca-2bdb-4769-88cf-3675ea757ebc), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoEncodeCommandList1 : ID3D12VideoEncodeCommandList +{ + void InitializeExtensionCommand( + [in] ID3D12VideoExtensionCommand *extension_command, + [in] const void *initialization_parameters, + [in] SIZE_T initialization_parameters_size_in_bytes + ); + + void ExecuteExtensionCommand( + [in] ID3D12VideoExtensionCommand *extension_command, + [in] const void *execution_parameters, + [in] SIZE_T execution_parameters_size_in_bytes + ); +} + +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG2, 0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG1_AND_MPEG2, 0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264, 0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO_PROGRESSIVE, 0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO, 0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_MULTIVIEW, 0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1, 0x1b81beA3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1_D2010, 0x1b81beA4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_SIMPLE, 0xefd64d74, 0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_ADVSIMPLE_NOGMC, 0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN, 0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10, 0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9, 0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9_10BIT_PROFILE2, 0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP8, 0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE0, 0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE1, 0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE2, 0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2, 0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0);") +cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2_420, 0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8);") + +typedef enum D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE +{ + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_ABSOLUTE_QP_MAP = 0, + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP = 1, + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CBR = 2, + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_VBR = 3, + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_QVBR = 4, +} D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE; + +typedef enum D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS +{ + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_DELTA_QP = 0x1, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_FRAME_ANALYSIS = 0x2, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE = 0x4, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_INITIAL_QP = 0x8, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_MAX_FRAME_SIZE = 0x10, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES = 0x20, +} D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP +{ + UINT ConstantQP_FullIntracodedFrame; + UINT ConstantQP_InterPredictedFrame_PrevRefOnly; + UINT ConstantQP_InterPredictedFrame_BiDirectionalRef; +} D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP; + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR +{ + UINT InitialQP; + UINT MinQP; + UINT MaxQP; + UINT64 MaxFrameBitSize; + UINT64 TargetBitRate; + UINT64 VBVCapacity; + UINT64 InitialVBVFullness; +} D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR; + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR +{ + UINT InitialQP; + UINT MinQP; + UINT MaxQP; + UINT64 MaxFrameBitSize; + UINT64 TargetAvgBitRate; + UINT64 PeakBitRate; + UINT64 VBVCapacity; + UINT64 InitialVBVFullness; +} D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR; + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR +{ + UINT InitialQP; + UINT MinQP; + UINT MaxQP; + UINT64 MaxFrameBitSize; + UINT64 TargetAvgBitRate; + UINT64 PeakBitRate; + UINT ConstantQualityTarget; +} D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR; + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS +{ + UINT DataSize; + union + { + const D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP *pConfiguration_CQP; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR *pConfiguration_CBR; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR *pConfiguration_VBR; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR *pConfiguration_QVBR; + }; +} D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS; + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL +{ + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE Mode; + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS Flags; + D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS ConfigParams; + DXGI_RATIONAL TargetFrameRate; +} D3D12_VIDEO_ENCODER_RATE_CONTROL; + +typedef enum D3D12_VIDEO_ENCODER_CODEC +{ + D3D12_VIDEO_ENCODER_CODEC_H264 = 0, + D3D12_VIDEO_ENCODER_CODEC_HEVC = 1, +} D3D12_VIDEO_ENCODER_CODEC; + +typedef enum D3D12_VIDEO_ENCODER_PROFILE_H264 +{ + D3D12_VIDEO_ENCODER_PROFILE_H264_MAIN = 0, + D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH = 1, + D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH_10 = 2, +} D3D12_VIDEO_ENCODER_PROFILE_H264; + +typedef enum D3D12_VIDEO_ENCODER_PROFILE_HEVC +{ + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN = 0, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10 = 1, +} D3D12_VIDEO_ENCODER_PROFILE_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_PROFILE_DESC +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_PROFILE_H264 *pH264Profile; + D3D12_VIDEO_ENCODER_PROFILE_HEVC *pHEVCProfile; + }; +} D3D12_VIDEO_ENCODER_PROFILE_DESC; + +typedef enum D3D12_VIDEO_ENCODER_LEVELS_H264 +{ + D3D12_VIDEO_ENCODER_LEVELS_H264_1 = 0, + D3D12_VIDEO_ENCODER_LEVELS_H264_1b = 1, + D3D12_VIDEO_ENCODER_LEVELS_H264_11 = 2, + D3D12_VIDEO_ENCODER_LEVELS_H264_12 = 3, + D3D12_VIDEO_ENCODER_LEVELS_H264_13 = 4, + D3D12_VIDEO_ENCODER_LEVELS_H264_2 = 5, + D3D12_VIDEO_ENCODER_LEVELS_H264_21 = 6, + D3D12_VIDEO_ENCODER_LEVELS_H264_22 = 7, + D3D12_VIDEO_ENCODER_LEVELS_H264_3 = 8, + D3D12_VIDEO_ENCODER_LEVELS_H264_31 = 9, + D3D12_VIDEO_ENCODER_LEVELS_H264_32 = 10, + D3D12_VIDEO_ENCODER_LEVELS_H264_4 = 11, + D3D12_VIDEO_ENCODER_LEVELS_H264_41 = 12, + D3D12_VIDEO_ENCODER_LEVELS_H264_42 = 13, + D3D12_VIDEO_ENCODER_LEVELS_H264_5 = 14, + D3D12_VIDEO_ENCODER_LEVELS_H264_51 = 15, + D3D12_VIDEO_ENCODER_LEVELS_H264_52 = 16, + D3D12_VIDEO_ENCODER_LEVELS_H264_6 = 17, + D3D12_VIDEO_ENCODER_LEVELS_H264_61 = 18, + D3D12_VIDEO_ENCODER_LEVELS_H264_62 = 19, +} D3D12_VIDEO_ENCODER_LEVELS_H264; + +typedef enum D3D12_VIDEO_ENCODER_TIER_HEVC +{ + D3D12_VIDEO_ENCODER_TIER_HEVC_MAIN = 0, + D3D12_VIDEO_ENCODER_TIER_HEVC_HIGH = 1, +} D3D12_VIDEO_ENCODER_TIER_HEVC; + +typedef enum D3D12_VIDEO_ENCODER_LEVELS_HEVC +{ + D3D12_VIDEO_ENCODER_LEVELS_HEVC_1 = 0, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_2 = 1, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_21 = 2, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_3 = 3, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_31 = 4, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_4 = 5, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_41 = 6, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_5 = 7, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_51 = 8, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_52 = 9, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_6 = 10, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_61 = 11, + D3D12_VIDEO_ENCODER_LEVELS_HEVC_62 = 12, +} D3D12_VIDEO_ENCODER_LEVELS_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC +{ + D3D12_VIDEO_ENCODER_LEVELS_HEVC Level; + D3D12_VIDEO_ENCODER_TIER_HEVC Tier; +} D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_LEVEL_SETTING +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_LEVELS_H264 *pH264LevelSetting; + D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC *pHEVCLevelSetting; + }; +} D3D12_VIDEO_ENCODER_LEVEL_SETTING; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC +{ + UINT Width; + UINT Height; +} D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE +{ + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE RateControlMode; + BOOL IsSupported; +} D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE; + +typedef enum D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE +{ + D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_NONE = 0, + D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_ROW_BASED = 1, +} D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE; + +typedef enum D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE +{ + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_FULL_FRAME = 0, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_BYTES_PER_SUBREGION = 1, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_SQUARE_UNITS_PER_SUBREGION_ROW_UNALIGNED = 2, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_ROWS_PER_SUBREGION = 3, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_SUBREGIONS_PER_FRAME = 4, +} D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE; + +typedef enum D3D12_VIDEO_ENCODER_HEAP_FLAGS +{ + D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE = 0x0, +} D3D12_VIDEO_ENCODER_HEAP_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_HEAP_DESC +{ + UINT NodeMask; + D3D12_VIDEO_ENCODER_HEAP_FLAGS Flags; + D3D12_VIDEO_ENCODER_CODEC EncodeCodec; + D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING EncodeLevel; + UINT ResolutionsListCount; + const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList; +} D3D12_VIDEO_ENCODER_HEAP_DESC; + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CABAC_ENCODING_SUPPORT = 0x1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT = 0x2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_BFRAME_LTR_COMBINED_SUPPORT = 0x4, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_ADAPTIVE_8x8_TRANSFORM_ENCODING_SUPPORT = 0x8, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_SPATIAL_ENCODING_SUPPORT = 0x10, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_TEMPORAL_ENCODING_SUPPORT = 0x20, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT = 0x40, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS);") + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED = 0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES = 1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS = 2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING = 3, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES = 4, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES = 5, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING = 6, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES; + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED), + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_1_DISABLE_ALL_SLICE_BLOCK_EDGES = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES), + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_2_DISABLE_SLICE_BOUNDARIES_BLOCKS = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS), + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_3_USE_TWO_STAGE_DEBLOCKING = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING), + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_4_DISABLE_CHROMA_BLOCK_EDGES = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES), + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES), + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING = (1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING), +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS SupportFlags; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS DisableDeblockingFilterSupportedModes; +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264; + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_BFRAME_LTR_COMBINED_SUPPORT = 0x1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT = 0x2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT = 0x4, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_SAO_FILTER_SUPPORT = 0x8, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_SUPPORT = 0x10, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_REQUIRED = 0x20, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_SUPPORT = 0x40, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_DISABLING_LOOP_FILTER_ACROSS_SLICES_SUPPORT = 0x80, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_P_FRAMES_IMPLEMENTED_AS_LOW_DELAY_B_FRAMES = 0x100, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS);") + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_8x8 = 0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_16x16 = 1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_32x32 = 2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_64x64 = 3, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE; + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_4x4 = 0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_8x8 = 1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_16x16 = 2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_32x32 = 3, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS SupportFlags; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize; + UCHAR max_transform_hierarchy_depth_inter; + UCHAR max_transform_hierarchy_depth_intra; +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 *pH264Support; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC *pHEVCSupport; + }; +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT +{ + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + BOOL IsSupported; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT CodecSupportLimits; +} D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 +{ + UINT MaxL0ReferencesForP; + UINT MaxL0ReferencesForB; + UINT MaxL1ReferencesForB; + UINT MaxLongTermReferences; + UINT MaxDPBCapacity; +} D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC +{ + UINT MaxL0ReferencesForP; + UINT MaxL0ReferencesForB; + UINT MaxL1ReferencesForB; + UINT MaxLongTermReferences; + UINT MaxDPBCapacity; +} D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 *pH264Support; + D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC *pHEVCSupport; + }; +} D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT +{ + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + BOOL IsSupported; + D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT PictureSupport; +} D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT; + +typedef enum D3D12_VIDEO_ENCODER_SUPPORT_FLAGS +{ + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_GENERAL_SUPPORT_OK = 0x1, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_RECONFIGURATION_AVAILABLE = 0x2, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RESOLUTION_RECONFIGURATION_AVAILABLE = 0x4, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_VBV_SIZE_CONFIG_AVAILABLE = 0x8, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_FRAME_ANALYSIS_AVAILABLE = 0x10, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RECONSTRUCTED_FRAMES_REQUIRE_TEXTURE_ARRAYS = 0x20, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_DELTA_QP_AVAILABLE = 0x40, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGION_LAYOUT_RECONFIGURATION_AVAILABLE = 0x80, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_ADJUSTABLE_QP_RANGE_AVAILABLE = 0x100, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_INITIAL_QP_AVAILABLE = 0x200, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_MAX_FRAME_SIZE_AVAILABLE = 0x400, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SEQUENCE_GOP_RECONFIGURATION_AVAILABLE = 0x800, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE = 0x1000, +} D3D12_VIDEO_ENCODER_SUPPORT_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS);") + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_CONSTRAINED_INTRAPREDICTION = 0x1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_ADAPTIVE_8x8_TRANSFORM = 0x2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ENABLE_CABAC_ENCODING = 0x4, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES = 0x8, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS);") + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_DISABLED = 0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_TEMPORAL = 1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_SPATIAL = 2, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS ConfigurationFlags; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES DirectModeConfig; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES DisableDeblockingFilterConfig; +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264; + +typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS +{ + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_DISABLE_LOOP_FILTER_ACROSS_SLICES = 0x1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES = 0x2, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_SAO_FILTER = 0x4, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_LONG_TERM_REFERENCES = 0x8, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_ASYMETRIC_MOTION_PARTITION = 0x10, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_TRANSFORM_SKIPPING = 0x20, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION = 0x40, +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS ConfigurationFlags; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize; + UCHAR max_transform_hierarchy_depth_inter; + UCHAR max_transform_hierarchy_depth_intra; +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 *pH264Config; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC *pHEVCConfig; + }; +} D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION; + +typedef struct D3D12_VIDEO_ENCODER_INTRA_REFRESH +{ + D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE Mode; + UINT IntraRefreshDuration; +} D3D12_VIDEO_ENCODER_INTRA_REFRESH; + +typedef enum D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE +{ + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM = 0, + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_FULL_PIXEL = 1, + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_HALF_PIXEL = 2, + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_QUARTER_PIXEL = 3, +} D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS +{ + UINT MaxSubregionsNumber; + UINT MaxIntraRefreshFrameDuration; + UINT SubregionBlockPixelsSize; + UINT QPMapRegionPixelsSize; +} D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS; + +typedef enum D3D12_VIDEO_ENCODER_VALIDATION_FLAGS +{ + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_NOT_SUPPORTED = 0x1, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INPUT_FORMAT_NOT_SUPPORTED = 0x8, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_CONFIGURATION_NOT_SUPPORTED = 0x10, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_MODE_NOT_SUPPORTED = 0x20, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_CONFIGURATION_NOT_SUPPORTED = 0x40, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INTRA_REFRESH_MODE_NOT_SUPPORTED = 0x80, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_MODE_NOT_SUPPORTED = 0x100, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RESOLUTION_NOT_SUPPORTED_IN_LIST = 0x200, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_GOP_STRUCTURE_NOT_SUPPORTED = 0x800, +} D3D12_VIDEO_ENCODER_VALIDATION_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 +{ + UINT GOPLength; + UINT PPicturePeriod; + UCHAR pic_order_cnt_type; + UCHAR log2_max_frame_num_minus4; + UCHAR log2_max_pic_order_cnt_lsb_minus4; +} D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264; + +typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC +{ + UINT GOPLength; + UINT PPicturePeriod; + UCHAR log2_max_pic_order_cnt_lsb_minus4; +} D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 *pH264GroupOfPictures; + D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC *pHEVCGroupOfPictures; + }; +} D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT +{ + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence; + D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl; + D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefresh; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding; + UINT ResolutionsListCount; + const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList; + UINT MaxReferenceFramesInDPB; + D3D12_VIDEO_ENCODER_VALIDATION_FLAGS ValidationFlags; + D3D12_VIDEO_ENCODER_SUPPORT_FLAGS SupportFlags; + D3D12_VIDEO_ENCODER_PROFILE_DESC SuggestedProfile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING SuggestedLevel; + D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS *pResolutionDependentSupport; +} D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS +{ + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution; + BOOL IsSupported; + UINT CompressedBitstreamBufferAccessAlignment; + UINT EncoderMetadataBufferAccessAlignment; + UINT MaxEncoderOutputMetadataBufferSize; +} D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS; + +typedef enum D3D12_VIDEO_ENCODER_FLAGS +{ + D3D12_VIDEO_ENCODER_FLAG_NONE = 0x0, +} D3D12_VIDEO_ENCODER_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_DESC +{ + UINT NodeMask; + D3D12_VIDEO_ENCODER_FLAGS Flags; + D3D12_VIDEO_ENCODER_CODEC EncodeCodec; + D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE MaxMotionEstimationPrecision; +} D3D12_VIDEO_ENCODER_DESC; + +[ + uuid(2e0d212d-8df9-44a6-a770-bb289b182737), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoEncoder : ID3D12Pageable +{ + UINT GetNodeMask(); + + D3D12_VIDEO_ENCODER_FLAGS GetEncoderFlags(); + + D3D12_VIDEO_ENCODER_CODEC GetCodec(); + + HRESULT GetCodecProfile( + [in, out] D3D12_VIDEO_ENCODER_PROFILE_DESC dst_profile + ); + + HRESULT GetCodecConfiguration( + [in, out] D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION dst_codec_config + ); + + DXGI_FORMAT GetInputFormat(); + + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE GetMaxMotionEstimationPrecision(); +} + +[ + uuid(22b35d96-876a-44c0-b25e-fb8c9c7f1c4a), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoEncoderHeap : ID3D12Pageable +{ + UINT GetNodeMask(); + + D3D12_VIDEO_ENCODER_HEAP_FLAGS GetEncoderHeapFlags(); + + D3D12_VIDEO_ENCODER_CODEC GetCodec(); + + HRESULT GetCodecProfile( + [in, out] D3D12_VIDEO_ENCODER_PROFILE_DESC dst_profile + ); + + HRESULT GetCodecLevel( + [in, out] D3D12_VIDEO_ENCODER_LEVEL_SETTING dst_level + ); + + UINT GetResolutionListCount(); + + HRESULT GetResolutionList( + [in] const UINT resolutions_list_count, + [out] D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *resolution_list + ); +} + +[ + uuid(4243adb4-3a32-4666-973c-0ccc5625dc44), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoDevice3 : ID3D12VideoDevice2 +{ + HRESULT CreateVideoEncoder( + [in] const D3D12_VIDEO_ENCODER_DESC *desc, + [in] REFIID riid, + [out] void **video_encoder + ); + + HRESULT CreateVideoEncoderHeap( + [in] const D3D12_VIDEO_ENCODER_HEAP_DESC *desc, + [in] REFIID riid, + [out] void **video_encoder_heap + ); +} + +typedef enum D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 +{ + D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_I_FRAME = 0, + D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_P_FRAME = 1, + D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_B_FRAME = 2, + D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_IDR_FRAME = 3, +} D3D12_VIDEO_ENCODER_FRAME_TYPE_H264; + +typedef struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 +{ + UINT ReconstructedPictureResourceIndex; + BOOL IsLongTermReference; + UINT LongTermPictureIdx; + UINT PictureOrderCountNumber; + UINT FrameDecodingOrderNumber; + UINT TemporalLayerIndex; +} D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264; + +typedef enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS +{ + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES = 0x1, +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION +{ + UCHAR memory_management_control_operation; + UINT difference_of_pic_nums_minus1; + UINT long_term_pic_num; + UINT long_term_frame_idx; + UINT max_long_term_frame_idx_plus1; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION +{ + UCHAR modification_of_pic_nums_idc; + UINT abs_diff_pic_num_minus1; + UINT long_term_pic_num; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 +{ + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS Flags; + D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 FrameType; + UINT pic_parameter_set_id; + UINT idr_pic_id; + UINT PictureOrderCountNumber; + UINT FrameDecodingOrderNumber; + UINT TemporalLayerIndex; + UINT List0ReferenceFramesCount; + UINT *pList0ReferenceFrames; + UINT List1ReferenceFramesCount; + UINT *pList1ReferenceFrames; + UINT ReferenceFramesReconPictureDescriptorsCount; + D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 *pReferenceFramesReconPictureDescriptors; + UCHAR adaptive_ref_pic_marking_mode_flag; + UINT RefPicMarkingOperationsCommandsCount; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION *pRefPicMarkingOperationsCommands; + UINT List0RefPicModificationsCount; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION *pList0RefPicModifications; + UINT List1RefPicModificationsCount; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION *pList1RefPicModifications; + UINT QPMapValuesCount; + INT8 *pRateControlQPMap; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264; + +typedef enum D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC +{ + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_I_FRAME = 0, + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_P_FRAME = 1, + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_B_FRAME = 2, + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_IDR_FRAME = 3, +} D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC +{ + UINT ReconstructedPictureResourceIndex; + BOOL IsRefUsedByCurrentPic; + BOOL IsLongTermReference; + UINT PictureOrderCountNumber; + UINT TemporalLayerIndex; +} D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC; + +typedef enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS +{ + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES = 0x1, +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC +{ + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags; + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC FrameType; + UINT slice_pic_parameter_set_id; + UINT PictureOrderCountNumber; + UINT TemporalLayerIndex; + UINT List0ReferenceFramesCount; + UINT *pList0ReferenceFrames; + UINT List1ReferenceFramesCount; + UINT *pList1ReferenceFrames; + UINT ReferenceFramesReconPictureDescriptorsCount; + D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pReferenceFramesReconPictureDescriptors; + UINT List0RefPicModificationsCount; + UINT *pList0RefPicModifications; + UINT List1RefPicModificationsCount; + UINT *pList1RefPicModifications; + UINT QPMapValuesCount; + INT8 *pRateControlQPMap; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA +{ + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 *pH264PicData; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC *pHEVCPicData; + }; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA; + +typedef struct D3D12_VIDEO_ENCODE_REFERENCE_FRAMES +{ + UINT NumTexture2Ds; + ID3D12Resource **ppTexture2Ds; + UINT *pSubresources; +} D3D12_VIDEO_ENCODE_REFERENCE_FRAMES; + +typedef enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS +{ + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE = 0x1, +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC +{ + UINT IntraRefreshFrameIndex; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS Flags; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA PictureControlCodecData; + D3D12_VIDEO_ENCODE_REFERENCE_FRAMES ReferenceFrames; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC; + +typedef enum D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS +{ + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_NONE = 0x0, + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RESOLUTION_CHANGE = 0x1, + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RATE_CONTROL_CHANGE = 0x2, + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_SUBREGION_LAYOUT_CHANGE = 0x4, + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_REQUEST_INTRA_REFRESH = 0x8, + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_GOP_SEQUENCE_CHANGE = 0x10, +} D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES +{ + union + { + UINT MaxBytesPerSlice; + UINT NumberOfCodingUnitsPerSlice; + UINT NumberOfRowsPerSlice; + UINT NumberOfSlicesPerFrame; + }; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA +{ + UINT DataSize; + union + { + const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_H264; + const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_HEVC; + }; +} D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA; + +typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC +{ + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS Flags; + D3D12_VIDEO_ENCODER_INTRA_REFRESH IntraRefreshConfig; + D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SelectedLayoutMode; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA FrameSubregionsLayoutData; + D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence; +} D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC; + +typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS +{ + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC SequenceControlDesc; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC PictureControlDesc; + ID3D12Resource *pInputFrame; + UINT InputFrameSubresource; + UINT CurrentFrameBitstreamMetadataSize; +} D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS; + +typedef struct D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM +{ + ID3D12Resource *pBuffer; + UINT64 FrameStartOffset; +} D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM; + +typedef struct D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE +{ + ID3D12Resource *pReconstructedPicture; + UINT ReconstructedPictureSubresource; +} D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE; + +typedef struct D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA +{ + UINT64 bSize; + UINT64 bStartOffset; + UINT64 bHeaderSize; +} D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA; + +typedef enum D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS +{ + D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_NO_ERROR = 0x0, + D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_CODEC_PICTURE_CONTROL_NOT_SUPPORTED = 0x1, + D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_SUBREGION_LAYOUT_CONFIGURATION_NOT_SUPPORTED = 0x2, + D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_REFERENCE_PICTURES = 0x4, + D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_RECONFIGURATION_REQUEST_NOT_SUPPORTED = 0x8, + D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_METADATA_BUFFER_SOURCE = 0x10, +} D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS);") + +typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS +{ + UINT64 AverageQP; + UINT64 IntraCodingUnitsCount; + UINT64 InterCodingUnitsCount; + UINT64 SkipCodingUnitsCount; + UINT64 AverageMotionEstimationXDirection; + UINT64 AverageMotionEstimationYDirection; +} D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS; + +typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA +{ + UINT64 EncodeErrorFlags; + D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS EncodeStats; + UINT64 EncodedBitstreamWrittenBytesCount; + UINT64 WrittenSubregionsCount; +} D3D12_VIDEO_ENCODER_OUTPUT_METADATA; + +typedef struct D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER +{ + ID3D12Resource *pBuffer; + UINT64 Offset; +} D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS +{ + D3D12_VIDEO_ENCODER_CODEC EncoderCodec; + D3D12_VIDEO_ENCODER_PROFILE_DESC EncoderProfile; + DXGI_FORMAT EncoderInputFormat; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncodedPictureEffectiveResolution; + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER HWLayoutMetadata; +} D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS +{ + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER ResolvedLayoutMetadata; +} D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS; + +typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS +{ + D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM Bitstream; + D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE ReconstructedPicture; + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER EncoderOutputMetadata; +} D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS; + +[ + uuid(895491e2-e701-46a9-9a1f-8d3480ed867a), + object, + local, + pointer_default(unique) +] +interface ID3D12VideoEncodeCommandList2 : ID3D12VideoEncodeCommandList1 +{ + void EncodeFrame( + [in] ID3D12VideoEncoder *encoder, + [in] ID3D12VideoEncoderHeap *heap, + [in] const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *input_arguments, + [in] const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *output_arguments + ); + + void ResolveEncoderOutputMetadata( + [in] const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *input_arguments, + [in] const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *output_arguments + ); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d8.h b/WineFix/lib/d2d1/include/windows/d3d8.h new file mode 100644 index 0000000..048269c --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d8.h @@ -0,0 +1,1153 @@ +/* + * Copyright (C) 2002 Jason Edmeades + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D8_H +#define __WINE_D3D8_H + +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0800 +#endif + +#include + +#define COM_NO_WINDOWS_H +#include +#include +#include +#include + +/***************************************************************************** + * Behavior Flags for IDirect3D8::CreateDevice + */ +#define D3DCREATE_FPU_PRESERVE __MSABI_LONG(0x00000002) +#define D3DCREATE_MULTITHREADED __MSABI_LONG(0x00000004) +#define D3DCREATE_PUREDEVICE __MSABI_LONG(0x00000010) +#define D3DCREATE_SOFTWARE_VERTEXPROCESSING __MSABI_LONG(0x00000020) +#define D3DCREATE_HARDWARE_VERTEXPROCESSING __MSABI_LONG(0x00000040) +#define D3DCREATE_MIXED_VERTEXPROCESSING __MSABI_LONG(0x00000080) + +/***************************************************************************** + * Flags for SetPrivateData + */ +#define D3DSPD_IUNKNOWN __MSABI_LONG(0x00000001) + +/***************************************************************************** + * #defines and error codes + */ +#define D3D_SDK_VERSION 220 +#define D3DADAPTER_DEFAULT 0 +#define D3DENUM_NO_WHQL_LEVEL 2 + +#define _FACD3D 0x876 +#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code ) + +/* + * Direct3D Errors + */ +#define D3D_OK S_OK +#define D3DERR_WRONGTEXTUREFORMAT MAKE_D3DHRESULT(2072) +#define D3DERR_UNSUPPORTEDCOLOROPERATION MAKE_D3DHRESULT(2073) +#define D3DERR_UNSUPPORTEDCOLORARG MAKE_D3DHRESULT(2074) +#define D3DERR_UNSUPPORTEDALPHAOPERATION MAKE_D3DHRESULT(2075) +#define D3DERR_UNSUPPORTEDALPHAARG MAKE_D3DHRESULT(2076) +#define D3DERR_TOOMANYOPERATIONS MAKE_D3DHRESULT(2077) +#define D3DERR_CONFLICTINGTEXTUREFILTER MAKE_D3DHRESULT(2078) +#define D3DERR_UNSUPPORTEDFACTORVALUE MAKE_D3DHRESULT(2079) +#define D3DERR_CONFLICTINGRENDERSTATE MAKE_D3DHRESULT(2081) +#define D3DERR_UNSUPPORTEDTEXTUREFILTER MAKE_D3DHRESULT(2082) +#define D3DERR_CONFLICTINGTEXTUREPALETTE MAKE_D3DHRESULT(2086) +#define D3DERR_DRIVERINTERNALERROR MAKE_D3DHRESULT(2087) + +#define D3DERR_NOTFOUND MAKE_D3DHRESULT(2150) +#define D3DERR_MOREDATA MAKE_D3DHRESULT(2151) +#define D3DERR_DEVICELOST MAKE_D3DHRESULT(2152) +#define D3DERR_DEVICENOTRESET MAKE_D3DHRESULT(2153) +#define D3DERR_NOTAVAILABLE MAKE_D3DHRESULT(2154) +#define D3DERR_OUTOFVIDEOMEMORY MAKE_D3DHRESULT(380) +#define D3DERR_INVALIDDEVICE MAKE_D3DHRESULT(2155) +#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156) +#define D3DERR_DRIVERINVALIDCALL MAKE_D3DHRESULT(2157) + +/***************************************************************************** + * Predeclare the interfaces + */ +DEFINE_GUID(IID_IDirect3D8, 0x1DD9E8DA,0x1C77,0x4D40,0xB0,0xCF,0x98,0xFE,0xFD,0xFF,0x95,0x12); +typedef struct IDirect3D8 *LPDIRECT3D8; + +DEFINE_GUID(IID_IDirect3DDevice8, 0x7385E5DF,0x8FE8,0x41D5,0x86,0xB6,0xD7,0xB4,0x85,0x47,0xB6,0xCF); +typedef struct IDirect3DDevice8 *LPDIRECT3DDEVICE8; + +DEFINE_GUID(IID_IDirect3DResource8, 0x1B36BB7B,0x09B7,0x410A,0xB4,0x45,0x7D,0x14,0x30,0xD7,0xB3,0x3F); +typedef struct IDirect3DResource8 *LPDIRECT3DRESOURCE8, *PDIRECT3DRESOURCE8; + +DEFINE_GUID(IID_IDirect3DVertexBuffer8, 0x8AEEEAC7,0x05F9,0x44D4,0xB5,0x91,0x00,0x0B,0x0D,0xF1,0xCB,0x95); +typedef struct IDirect3DVertexBuffer8 *LPDIRECT3DVERTEXBUFFER8, *PDIRECT3DVERTEXBUFFER8; + +DEFINE_GUID(IID_IDirect3DVolume8, 0xBD7349F5,0x14F1,0x42E4,0x9C,0x79,0x97,0x23,0x80,0xDB,0x40,0xC0); +typedef struct IDirect3DVolume8 *LPDIRECT3DVOLUME8, *PDIRECT3DVOLUME8; + +DEFINE_GUID(IID_IDirect3DSwapChain8, 0x928C088B,0x76B9,0x4C6B,0xA5,0x36,0xA5,0x90,0x85,0x38,0x76,0xCD); +typedef struct IDirect3DSwapChain8 *LPDIRECT3DSWAPCHAIN8, *PDIRECT3DSWAPCHAIN8; + +DEFINE_GUID(IID_IDirect3DSurface8, 0xB96EEBCA,0xB326,0x4EA5,0x88,0x2F,0x2F,0xF5,0xBA,0xE0,0x21,0xDD); +typedef struct IDirect3DSurface8 *LPDIRECT3DSURFACE8, *PDIRECT3DSURFACE8; + +DEFINE_GUID(IID_IDirect3DIndexBuffer8, 0x0E689C9A,0x053D,0x44A0,0x9D,0x92,0xDB,0x0E,0x3D,0x75,0x0F,0x86); +typedef struct IDirect3DIndexBuffer8 *LPDIRECT3DINDEXBUFFER8, *PDIRECT3DINDEXBUFFER8; + +DEFINE_GUID(IID_IDirect3DBaseTexture8, 0xB4211CFA,0x51B9,0x4A9F,0xAB,0x78,0xDB,0x99,0xB2,0xBB,0x67,0x8E); +typedef struct IDirect3DBaseTexture8 *LPDIRECT3DBASETEXTURE8, *PDIRECT3DBASETEXTURE8; + +DEFINE_GUID(IID_IDirect3DTexture8, 0xE4CDD575,0x2866,0x4F01,0xB1,0x2E,0x7E,0xEC,0xE1,0xEC,0x93,0x58); +typedef struct IDirect3DTexture8 *LPDIRECT3DTEXTURE8, *PDIRECT3DTEXTURE8; + +DEFINE_GUID(IID_IDirect3DCubeTexture8, 0x3EE5B968,0x2ACA,0x4C34,0x8B,0xB5,0x7E,0x0C,0x3D,0x19,0xB7,0x50); +typedef struct IDirect3DCubeTexture8 *LPDIRECT3DCUBETEXTURE8, *PDIRECT3DCUBETEXTURE8; + +DEFINE_GUID(IID_IDirect3DVolumeTexture8, 0x4B8AAAFA,0x140F,0x42BA,0x91,0x31,0x59,0x7E,0xAF,0xAA,0x2E,0xAD); +typedef struct IDirect3DVolumeTexture8 *LPDIRECT3DVOLUMETEXTURE8, *PDIRECT3DVOLUMETEXTURE8; + +/***************************************************************************** + * IDirect3D8 interface + */ +#undef INTERFACE +#define INTERFACE IDirect3D8 +DECLARE_INTERFACE_IID_(IDirect3D8,IUnknown,"1dd9e8da-1c77-4d40-b0cf-98fefdff9512") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3D8 methods ***/ + STDMETHOD(RegisterSoftwareDevice)(THIS_ void * pInitializeFunction) PURE; + STDMETHOD_(UINT,GetAdapterCount )(THIS) PURE; + STDMETHOD(GetAdapterIdentifier)(THIS_ UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8 * pIdentifier) PURE; + STDMETHOD_(UINT,GetAdapterModeCount)(THIS_ UINT Adapter) PURE; + STDMETHOD(EnumAdapterModes)(THIS_ UINT Adapter, UINT Mode, D3DDISPLAYMODE * pMode) PURE; + STDMETHOD(GetAdapterDisplayMode)(THIS_ UINT Adapter, D3DDISPLAYMODE * pMode) PURE; + STDMETHOD(CheckDeviceType)(THIS_ UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed) PURE; + STDMETHOD(CheckDeviceFormat)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) PURE; + STDMETHOD(CheckDeviceMultiSampleType)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) PURE; + STDMETHOD(CheckDepthStencilMatch)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) PURE; + STDMETHOD(GetDeviceCaps)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8 * pCaps) PURE; + STDMETHOD_(HMONITOR,GetAdapterMonitor)(THIS_ UINT Adapter) PURE; + STDMETHOD(CreateDevice)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType,HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS * pPresentationParameters, struct IDirect3DDevice8 ** ppReturnedDeviceInterface) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3D8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3D8 methods ***/ +#define IDirect3D8_RegisterSoftwareDevice(p,a) (p)->lpVtbl->RegisterSoftwareDevice(p,a) +#define IDirect3D8_GetAdapterCount(p) (p)->lpVtbl->GetAdapterCount(p) +#define IDirect3D8_GetAdapterIdentifier(p,a,b,c) (p)->lpVtbl->GetAdapterIdentifier(p,a,b,c) +#define IDirect3D8_GetAdapterModeCount(p,a) (p)->lpVtbl->GetAdapterModeCount(p,a) +#define IDirect3D8_EnumAdapterModes(p,a,b,c) (p)->lpVtbl->EnumAdapterModes(p,a,b,c) +#define IDirect3D8_GetAdapterDisplayMode(p,a,b) (p)->lpVtbl->GetAdapterDisplayMode(p,a,b) +#define IDirect3D8_CheckDeviceType(p,a,b,c,d,e) (p)->lpVtbl->CheckDeviceType(p,a,b,c,d,e) +#define IDirect3D8_CheckDeviceFormat(p,a,b,c,d,e,f) (p)->lpVtbl->CheckDeviceFormat(p,a,b,c,d,e,f) +#define IDirect3D8_CheckDeviceMultiSampleType(p,a,b,c,d,e) (p)->lpVtbl->CheckDeviceMultiSampleType(p,a,b,c,d,e) +#define IDirect3D8_CheckDepthStencilMatch(p,a,b,c,d,e) (p)->lpVtbl->CheckDepthStencilMatch(p,a,b,c,d,e) +#define IDirect3D8_GetDeviceCaps(p,a,b,c) (p)->lpVtbl->GetDeviceCaps(p,a,b,c) +#define IDirect3D8_GetAdapterMonitor(p,a) (p)->lpVtbl->GetAdapterMonitor(p,a) +#define IDirect3D8_CreateDevice(p,a,b,c,d,e,f) (p)->lpVtbl->CreateDevice(p,a,b,c,d,e,f) +#else +/*** IUnknown methods ***/ +#define IDirect3D8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D8_AddRef(p) (p)->AddRef() +#define IDirect3D8_Release(p) (p)->Release() +/*** IDirect3D8 methods ***/ +#define IDirect3D8_RegisterSoftwareDevice(p,a) (p)->RegisterSoftwareDevice(a) +#define IDirect3D8_GetAdapterCount(p) (p)->GetAdapterCount() +#define IDirect3D8_GetAdapterIdentifier(p,a,b,c) (p)->GetAdapterIdentifier(a,b,c) +#define IDirect3D8_GetAdapterModeCount(p,a) (p)->GetAdapterModeCount(a) +#define IDirect3D8_EnumAdapterModes(p,a,b,c) (p)->EnumAdapterModes(a,b,c) +#define IDirect3D8_GetAdapterDisplayMode(p,a,b) (p)->GetAdapterDisplayMode(a,b) +#define IDirect3D8_CheckDeviceType(p,a,b,c,d,e) (p)->CheckDeviceType(a,b,c,d,e) +#define IDirect3D8_CheckDeviceFormat(p,a,b,c,d,e,f) (p)->CheckDeviceFormat(a,b,c,d,e,f) +#define IDirect3D8_CheckDeviceMultiSampleType(p,a,b,c,d,e) (p)->CheckDeviceMultiSampleType(a,b,c,d,e) +#define IDirect3D8_CheckDepthStencilMatch(p,a,b,c,d,e) (p)->CheckDepthStencilMatch(a,b,c,d,e) +#define IDirect3D8_GetDeviceCaps(p,a,b,c) (p)->GetDeviceCaps(a,b,c) +#define IDirect3D8_GetAdapterMonitor(p,a) (p)->GetAdapterMonitor(a) +#define IDirect3D8_CreateDevice(p,a,b,c,d,e,f) (p)->CreateDevice(a,b,c,d,e,f) +#endif + +/***************************************************************************** + * IDirect3DVolume8 interface + */ +#define INTERFACE IDirect3DVolume8 +DECLARE_INTERFACE_IID_(IDirect3DVolume8,IUnknown,"bd7349f5-14f1-42e4-9c79-972380db40c0") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DVolume8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid,void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD(GetContainer)(THIS_ REFIID riid, void ** ppContainer) PURE; + STDMETHOD(GetDesc)(THIS_ D3DVOLUME_DESC * pDesc) PURE; + STDMETHOD(LockBox)(THIS_ D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) PURE; + STDMETHOD(UnlockBox)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVolume8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVolume8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVolume8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVolume8 methods ***/ +#define IDirect3DVolume8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVolume8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DVolume8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DVolume8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DVolume8_GetContainer(p,a,b) (p)->lpVtbl->GetContainer(p,a,b) +#define IDirect3DVolume8_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define IDirect3DVolume8_LockBox(p,a,b,c) (p)->lpVtbl->LockBox(p,a,b,c) +#define IDirect3DVolume8_UnlockBox(p) (p)->lpVtbl->UnlockBox(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DVolume8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVolume8_AddRef(p) (p)->AddRef() +#define IDirect3DVolume8_Release(p) (p)->Release() +/*** IDirect3DVolume8 methods ***/ +#define IDirect3DVolume8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVolume8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DVolume8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DVolume8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DVolume8_GetContainer(p,a,b) (p)->GetContainer(a,b) +#define IDirect3DVolume8_GetDesc(p,a) (p)->GetDesc(a) +#define IDirect3DVolume8_LockBox(p,a,b,c) (p)->LockBox(a,b,c) +#define IDirect3DVolume8_UnlockBox(p) (p)->UnlockBox() +#endif + +/***************************************************************************** + * IDirect3DSwapChain8 interface + */ +#define INTERFACE IDirect3DSwapChain8 +DECLARE_INTERFACE_IID_(IDirect3DSwapChain8,IUnknown,"928c088b-76b9-4c6b-a536-a590853876cd") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DSwapChain8 methods ***/ + STDMETHOD(Present)(THIS_ const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region) PURE; + STDMETHOD(GetBackBuffer)(THIS_ UINT BackBuffer, D3DBACKBUFFER_TYPE Type, struct IDirect3DSurface8 ** ppBackBuffer) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DSwapChain8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DSwapChain8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DSwapChain8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DSwapChain8 methods ***/ +#define IDirect3DSwapChain8_Present(p,a,b,c,d) (p)->lpVtbl->Present(p,a,b,c,d) +#define IDirect3DSwapChain8_GetBackBuffer(p,a,b,c) (p)->lpVtbl->GetBackBuffer(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DSwapChain8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DSwapChain8_AddRef(p) (p)->AddRef() +#define IDirect3DSwapChain8_Release(p) (p)->Release() +/*** IDirect3DSwapChain8 methods ***/ +#define IDirect3DSwapChain8_Present(p,a,b,c,d) (p)->Present(a,b,c,d) +#define IDirect3DSwapChain8_GetBackBuffer(p,a,b,c) (p)->GetBackBuffer(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DSurface8 interface + */ +#define INTERFACE IDirect3DSurface8 +DECLARE_INTERFACE_IID_(IDirect3DSurface8,IUnknown,"b96eebca-b326-4ea5-882f-2ff5bae021dd") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DSurface8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid,void * pData,DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD(GetContainer)(THIS_ REFIID riid, void ** ppContainer) PURE; + STDMETHOD(GetDesc)(THIS_ D3DSURFACE_DESC * pDesc) PURE; + STDMETHOD(LockRect)(THIS_ D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) PURE; + STDMETHOD(UnlockRect)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DSurface8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DSurface8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DSurface8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DSurface8 methods ***/ +#define IDirect3DSurface8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DSurface8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DSurface8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DSurface8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DSurface8_GetContainer(p,a,b) (p)->lpVtbl->GetContainer(p,a,b) +#define IDirect3DSurface8_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define IDirect3DSurface8_LockRect(p,a,b,c) (p)->lpVtbl->LockRect(p,a,b,c) +#define IDirect3DSurface8_UnlockRect(p) (p)->lpVtbl->UnlockRect(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DSurface8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DSurface8_AddRef(p) (p)->AddRef() +#define IDirect3DSurface8_Release(p) (p)->Release() +/*** IDirect3DSurface8 methods ***/ +#define IDirect3DSurface8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DSurface8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DSurface8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DSurface8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DSurface8_GetContainer(p,a,b) (p)->GetContainer(a,b) +#define IDirect3DSurface8_GetDesc(p,a) (p)->GetDesc(a) +#define IDirect3DSurface8_LockRect(p,a,b,c) (p)->LockRect(a,b,c) +#define IDirect3DSurface8_UnlockRect(p) (p)->UnlockRect() +#endif + +/***************************************************************************** + * IDirect3DResource8 interface + */ +#define INTERFACE IDirect3DResource8 +DECLARE_INTERFACE_IID_(IDirect3DResource8,IUnknown,"1b36bb7b-09b7-410a-b445-7d1430d7b33f") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DResource8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DResource8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DResource8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DResource8 methods ***/ +#define IDirect3DResource8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DResource8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DResource8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DResource8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DResource8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DResource8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DResource8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DResource8_GetType(p) (p)->lpVtbl->GetType(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DResource8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DResource8_AddRef(p) (p)->AddRef() +#define IDirect3DResource8_Release(p) (p)->Release() +/*** IDirect3DResource8 methods ***/ +#define IDirect3DResource8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DResource8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DResource8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DResource8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DResource8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DResource8_GetPriority(p) (p)->GetPriority() +#define IDirect3DResource8_PreLoad(p) (p)->PreLoad() +#define IDirect3DResource8_GetType(p) (p)->GetType() +#endif + +/***************************************************************************** + * IDirect3DVertexBuffer8 interface + */ +#define INTERFACE IDirect3DVertexBuffer8 +DECLARE_INTERFACE_IID_(IDirect3DVertexBuffer8,IDirect3DResource8,"8aeeeac7-05f9-44d4-b591-000b0df1cb95") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; + /*** IDirect3DVertexBuffer8 methods ***/ + STDMETHOD(Lock)(THIS_ UINT OffsetToLock, UINT SizeToLock, BYTE ** ppbData, DWORD Flags) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(GetDesc)(THIS_ D3DVERTEXBUFFER_DESC * pDesc) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexBuffer8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexBuffer8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVertexBuffer8 methods: IDirect3DResource8 ***/ +#define IDirect3DVertexBuffer8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVertexBuffer8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DVertexBuffer8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DVertexBuffer8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DVertexBuffer8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DVertexBuffer8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DVertexBuffer8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DVertexBuffer8_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DVertexBuffer8 methods ***/ +#define IDirect3DVertexBuffer8_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirect3DVertexBuffer8_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DVertexBuffer8_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexBuffer8_AddRef(p) (p)->AddRef() +#define IDirect3DVertexBuffer8_Release(p) (p)->Release() +/*** IDirect3DVertexBuffer8 methods: IDirect3DResource8 ***/ +#define IDirect3DVertexBuffer8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVertexBuffer8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DVertexBuffer8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DVertexBuffer8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DVertexBuffer8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DVertexBuffer8_GetPriority(p) (p)->GetPriority() +#define IDirect3DVertexBuffer8_PreLoad(p) (p)->PreLoad() +#define IDirect3DVertexBuffer8_GetType(p) (p)->GetType() +/*** IDirect3DVertexBuffer8 methods ***/ +#define IDirect3DVertexBuffer8_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirect3DVertexBuffer8_Unlock(p) (p)->Unlock() +#define IDirect3DVertexBuffer8_GetDesc(p,a) (p)->GetDesc(a) +#endif + +/***************************************************************************** + * IDirect3DIndexBuffer8 interface + */ +#define INTERFACE IDirect3DIndexBuffer8 +DECLARE_INTERFACE_IID_(IDirect3DIndexBuffer8,IDirect3DResource8,"0e689c9a-053d-44a0-9d92-db0e3d750f86") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; + /*** IDirect3DIndexBuffer8 methods ***/ + STDMETHOD(Lock)(THIS_ UINT OffsetToLock, UINT SizeToLock, BYTE ** ppbData, DWORD Flags) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(GetDesc)(THIS_ D3DINDEXBUFFER_DESC * pDesc) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DIndexBuffer8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DIndexBuffer8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DIndexBuffer8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DIndexBuffer8 methods: IDirect3DResource8 ***/ +#define IDirect3DIndexBuffer8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DIndexBuffer8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DIndexBuffer8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DIndexBuffer8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DIndexBuffer8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DIndexBuffer8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DIndexBuffer8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DIndexBuffer8_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DIndexBuffer8 methods ***/ +#define IDirect3DIndexBuffer8_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirect3DIndexBuffer8_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DIndexBuffer8_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DIndexBuffer8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DIndexBuffer8_AddRef(p) (p)->AddRef() +#define IDirect3DIndexBuffer8_Release(p) (p)->Release() +/*** IDirect3DIndexBuffer8 methods: IDirect3DResource8 ***/ +#define IDirect3DIndexBuffer8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DIndexBuffer8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DIndexBuffer8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DIndexBuffer8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DIndexBuffer8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DIndexBuffer8_GetPriority(p) (p)->GetPriority() +#define IDirect3DIndexBuffer8_PreLoad(p) (p)->PreLoad() +#define IDirect3DIndexBuffer8_GetType(p) (p)->GetType() +/*** IDirect3DIndexBuffer8 methods ***/ +#define IDirect3DIndexBuffer8_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirect3DIndexBuffer8_Unlock(p) (p)->Unlock() +#define IDirect3DIndexBuffer8_GetDesc(p,a) (p)->GetDesc(a) +#endif + +/***************************************************************************** + * IDirect3DBaseTexture8 interface + */ +#define INTERFACE IDirect3DBaseTexture8 +DECLARE_INTERFACE_IID_(IDirect3DBaseTexture8,IDirect3DResource8,"b4211cfa-51b9-4a9f-ab78-db99b2bb678e") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; + /*** IDirect3DBaseTexture8 methods ***/ + STDMETHOD_(DWORD,SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD,GetLOD)(THIS) PURE; + STDMETHOD_(DWORD,GetLevelCount)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DBaseTexture8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DBaseTexture8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DBaseTexture8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DBaseTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DBaseTexture8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DBaseTexture8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DBaseTexture8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DBaseTexture8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DBaseTexture8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DBaseTexture8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DBaseTexture8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DBaseTexture8_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DBaseTexture8 methods ***/ +#define IDirect3DBaseTexture8_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DBaseTexture8_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DBaseTexture8_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DBaseTexture8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DBaseTexture8_AddRef(p) (p)->AddRef() +#define IDirect3DBaseTexture8_Release(p) (p)->Release() +/*** IDirect3DBaseTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DBaseTexture8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DBaseTexture8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DBaseTexture8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DBaseTexture8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DBaseTexture8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DBaseTexture8_GetPriority(p) (p)->GetPriority() +#define IDirect3DBaseTexture8_PreLoad(p) (p)->PreLoad() +#define IDirect3DBaseTexture8_GetType(p) (p)->GetType() +/*** IDirect3DBaseTexture8 methods ***/ +#define IDirect3DBaseTexture8_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DBaseTexture8_GetLOD(p) (p)->GetLOD() +#define IDirect3DBaseTexture8_GetLevelCount(p) (p)->GetLevelCount() +#endif + +/***************************************************************************** + * IDirect3DCubeTexture8 interface + */ +#define INTERFACE IDirect3DCubeTexture8 +DECLARE_INTERFACE_IID_(IDirect3DCubeTexture8,IDirect3DBaseTexture8,"3ee5b968-2aca-4c34-8bb5-7e0c3d19b750") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; + /*** IDirect3DBaseTexture8 methods ***/ + STDMETHOD_(DWORD,SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD,GetLOD)(THIS) PURE; + STDMETHOD_(DWORD,GetLevelCount)(THIS) PURE; + /*** IDirect3DCubeTexture8 methods ***/ + STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DSURFACE_DESC * pDesc) PURE; + STDMETHOD(GetCubeMapSurface)(THIS_ D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface8 ** ppCubeMapSurface) PURE; + STDMETHOD(LockRect)(THIS_ D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, + const RECT *rect, DWORD flags) PURE; + STDMETHOD(UnlockRect)(THIS_ D3DCUBEMAP_FACES FaceType,UINT Level) PURE; + STDMETHOD(AddDirtyRect)(THIS_ D3DCUBEMAP_FACES face, const RECT *dirty_rect) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DCubeTexture8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DCubeTexture8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DCubeTexture8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DCubeTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DCubeTexture8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DCubeTexture8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DCubeTexture8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DCubeTexture8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DCubeTexture8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DCubeTexture8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DCubeTexture8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DCubeTexture8_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DCubeTexture8 methods: IDirect3DBaseTexture8 ***/ +#define IDirect3DCubeTexture8_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DCubeTexture8_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DCubeTexture8_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +/*** IDirect3DCubeTexture8 methods ***/ +#define IDirect3DCubeTexture8_GetLevelDesc(p,a,b) (p)->lpVtbl->GetLevelDesc(p,a,b) +#define IDirect3DCubeTexture8_GetCubeMapSurface(p,a,b,c) (p)->lpVtbl->GetCubeMapSurface(p,a,b,c) +#define IDirect3DCubeTexture8_LockRect(p,a,b,c,d,e) (p)->lpVtbl->LockRect(p,a,b,c,d,e) +#define IDirect3DCubeTexture8_UnlockRect(p,a,b) (p)->lpVtbl->UnlockRect(p,a,b) +#define IDirect3DCubeTexture8_AddDirtyRect(p,a,b) (p)->lpVtbl->AddDirtyRect(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DCubeTexture8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DCubeTexture8_AddRef(p) (p)->AddRef() +#define IDirect3DCubeTexture8_Release(p) (p)->Release() +/*** IDirect3DCubeTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DCubeTexture8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DCubeTexture8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DCubeTexture8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DCubeTexture8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DCubeTexture8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DCubeTexture8_GetPriority(p) (p)->GetPriority() +#define IDirect3DCubeTexture8_PreLoad(p) (p)->PreLoad() +#define IDirect3DCubeTexture8_GetType(p) (p)->GetType() +/*** IDirect3DCubeTexture8 methods: IDirect3DBaseTexture8 ***/ +#define IDirect3DCubeTexture8_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DCubeTexture8_GetLOD(p) (p)->GetLOD() +#define IDirect3DCubeTexture8_GetLevelCount(p) (p)->GetLevelCount() +/*** IDirect3DCubeTexture8 methods ***/ +#define IDirect3DCubeTexture8_GetLevelDesc(p,a,b) (p)->GetLevelDesc(a,b) +#define IDirect3DCubeTexture8_GetCubeMapSurface(p,a,b,c) (p)->GetCubeMapSurface(a,b,c) +#define IDirect3DCubeTexture8_LockRect(p,a,b,c,d,e) (p)->LockRect(a,b,c,d,e) +#define IDirect3DCubeTexture8_UnlockRect(p,a,b) (p)->UnlockRect(a,b) +#define IDirect3DCubeTexture8_AddDirtyRect(p,a,b) (p)->AddDirtyRect(a,b) +#endif + +/***************************************************************************** + * IDirect3DTexture8 interface + */ +#define INTERFACE IDirect3DTexture8 +DECLARE_INTERFACE_IID_(IDirect3DTexture8,IDirect3DBaseTexture8,"e4cdd575-2866-4f01-b12e-7eece1ec9358") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; + /*** IDirect3DBaseTexture8 methods ***/ + STDMETHOD_(DWORD,SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD,GetLOD)(THIS) PURE; + STDMETHOD_(DWORD,GetLevelCount)(THIS) PURE; + /*** IDirect3DTexture8 methods ***/ + STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DSURFACE_DESC * pDesc) PURE; + STDMETHOD(GetSurfaceLevel)(THIS_ UINT Level,IDirect3DSurface8 ** ppSurfaceLevel) PURE; + STDMETHOD(LockRect)(THIS_ UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) PURE; + STDMETHOD(UnlockRect)(THIS_ UINT Level) PURE; + STDMETHOD(AddDirtyRect)(THIS_ const RECT *dirty_rect) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DTexture8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DTexture8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DTexture8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DTexture8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DTexture8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DTexture8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DTexture8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DTexture8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DTexture8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DTexture8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DTexture8_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DTexture8 methods: IDirect3DBaseTexture8 ***/ +#define IDirect3DTexture8_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DTexture8_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DTexture8_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +/*** IDirect3DTexture8 methods ***/ +#define IDirect3DTexture8_GetLevelDesc(p,a,b) (p)->lpVtbl->GetLevelDesc(p,a,b) +#define IDirect3DTexture8_GetSurfaceLevel(p,a,b) (p)->lpVtbl->GetSurfaceLevel(p,a,b) +#define IDirect3DTexture8_LockRect(p,a,b,c,d) (p)->lpVtbl->LockRect(p,a,b,c,d) +#define IDirect3DTexture8_UnlockRect(p,a) (p)->lpVtbl->UnlockRect(p,a) +#define IDirect3DTexture8_AddDirtyRect(p,a) (p)->lpVtbl->AddDirtyRect(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DTexture8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DTexture8_AddRef(p) (p)->AddRef() +#define IDirect3DTexture8_Release(p) (p)->Release() +/*** IDirect3DTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DTexture8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DTexture8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DTexture8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DTexture8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DTexture8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DTexture8_GetPriority(p) (p)->GetPriority() +#define IDirect3DTexture8_PreLoad(p) (p)->PreLoad() +#define IDirect3DTexture8_GetType(p) (p)->GetType() +/*** IDirect3DTexture8 methods: IDirect3DBaseTexture8 ***/ +#define IDirect3DTexture8_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DTexture8_GetLOD(p) (p)->GetLOD() +#define IDirect3DTexture8_GetLevelCount(p) (p)->GetLevelCount() +/*** IDirect3DTexture8 methods ***/ +#define IDirect3DTexture8_GetLevelDesc(p,a,b) (p)->GetLevelDesc(a,b) +#define IDirect3DTexture8_GetSurfaceLevel(p,a,b) (p)->GetSurfaceLevel(a,b) +#define IDirect3DTexture8_LockRect(p,a,b,c,d) (p)->LockRect(a,b,c,d) +#define IDirect3DTexture8_UnlockRect(p,a) (p)->UnlockRect(a) +#define IDirect3DTexture8_AddDirtyRect(p,a) (p)->AddDirtyRect(a) +#endif + +/***************************************************************************** + * IDirect3DVolumeTexture8 interface + */ +#define INTERFACE IDirect3DVolumeTexture8 +DECLARE_INTERFACE_IID_(IDirect3DVolumeTexture8,IDirect3DBaseTexture8,"4b8aaafa-140f-42ba-9131-597eafaa2ead") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource8 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice8 ** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void * pData, DWORD * pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD,GetPriority)(THIS) PURE; + STDMETHOD_(void,PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE; + /*** IDirect3DBaseTexture8 methods ***/ + STDMETHOD_(DWORD,SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD,GetLOD)(THIS) PURE; + STDMETHOD_(DWORD,GetLevelCount)(THIS) PURE; + /*** IDirect3DVolumeTexture8 methods ***/ + STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DVOLUME_DESC * pDesc) PURE; + STDMETHOD(GetVolumeLevel)(THIS_ UINT Level,IDirect3DVolume8 ** ppVolumeLevel) PURE; + STDMETHOD(LockBox)(THIS_ UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) PURE; + STDMETHOD(UnlockBox)(THIS_ UINT Level) PURE; + STDMETHOD(AddDirtyBox)(THIS_ const D3DBOX *dirty_box) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVolumeTexture8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVolumeTexture8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVolumeTexture8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVolumeTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DVolumeTexture8_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVolumeTexture8_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DVolumeTexture8_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DVolumeTexture8_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DVolumeTexture8_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DVolumeTexture8_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DVolumeTexture8_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DVolumeTexture8_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DVolumeTexture8 methods: IDirect3DBaseTexture8 ***/ +#define IDirect3DVolumeTexture8_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DVolumeTexture8_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DVolumeTexture8_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +/*** IDirect3DVolumeTexture8 methods ***/ +#define IDirect3DVolumeTexture8_GetLevelDesc(p,a,b) (p)->lpVtbl->GetLevelDesc(p,a,b) +#define IDirect3DVolumeTexture8_GetVolumeLevel(p,a,b) (p)->lpVtbl->GetVolumeLevel(p,a,b) +#define IDirect3DVolumeTexture8_LockBox(p,a,b,c,d) (p)->lpVtbl->LockBox(p,a,b,c,d) +#define IDirect3DVolumeTexture8_UnlockBox(p,a) (p)->lpVtbl->UnlockBox(p,a) +#define IDirect3DVolumeTexture8_AddDirtyBox(p,a) (p)->lpVtbl->AddDirtyBox(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DVolumeTexture8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVolumeTexture8_AddRef(p) (p)->AddRef() +#define IDirect3DVolumeTexture8_Release(p) (p)->Release() +/*** IDirect3DVolumeTexture8 methods: IDirect3DResource8 ***/ +#define IDirect3DVolumeTexture8_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVolumeTexture8_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DVolumeTexture8_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DVolumeTexture8_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DVolumeTexture8_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DVolumeTexture8_GetPriority(p) (p)->GetPriority() +#define IDirect3DVolumeTexture8_PreLoad(p) (p)->PreLoad() +#define IDirect3DVolumeTexture8_GetType(p) (p)->GetType() +/*** IDirect3DVolumeTexture8 methods: IDirect3DBaseTexture8 ***/ +#define IDirect3DVolumeTexture8_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DVolumeTexture8_GetLOD(p) (p)->GetLOD() +#define IDirect3DVolumeTexture8_GetLevelCount(p) (p)->GetLevelCount() +/*** IDirect3DVolumeTexture8 methods ***/ +#define IDirect3DVolumeTexture8_GetLevelDesc(p,a,b) (p)->GetLevelDesc(a,b) +#define IDirect3DVolumeTexture8_GetVolumeLevel(p,a,b) (p)->GetVolumeLevel(a,b) +#define IDirect3DVolumeTexture8_LockBox(p,a,b,c,d) (p)->LockBox(a,b,c,d) +#define IDirect3DVolumeTexture8_UnlockBox(p,a) (p)->UnlockBox(a) +#define IDirect3DVolumeTexture8_AddDirtyBox(p,a) (p)->AddDirtyBox(a) +#endif + +/***************************************************************************** + * IDirect3DDevice8 interface + */ +#define INTERFACE IDirect3DDevice8 +DECLARE_INTERFACE_IID_(IDirect3DDevice8,IUnknown,"7385e5df-8fe8-41d5-86b6-d7b48547b6cf") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DDevice8 methods ***/ + STDMETHOD(TestCooperativeLevel)(THIS) PURE; + STDMETHOD_(UINT,GetAvailableTextureMem)(THIS) PURE; + STDMETHOD(ResourceManagerDiscardBytes)(THIS_ DWORD Bytes) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D8 ** ppD3D8) PURE; + STDMETHOD(GetDeviceCaps)(THIS_ D3DCAPS8 * pCaps) PURE; + STDMETHOD(GetDisplayMode)(THIS_ D3DDISPLAYMODE * pMode) PURE; + STDMETHOD(GetCreationParameters)(THIS_ D3DDEVICE_CREATION_PARAMETERS * pParameters) PURE; + STDMETHOD(SetCursorProperties)(THIS_ UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8 * pCursorBitmap) PURE; + STDMETHOD_(void,SetCursorPosition)(THIS_ UINT XScreenSpace, UINT YScreenSpace,DWORD Flags) PURE; + STDMETHOD_(BOOL,ShowCursor)(THIS_ BOOL bShow) PURE; + STDMETHOD(CreateAdditionalSwapChain)(THIS_ D3DPRESENT_PARAMETERS * pPresentationParameters, IDirect3DSwapChain8 ** pSwapChain) PURE; + STDMETHOD(Reset)(THIS_ D3DPRESENT_PARAMETERS * pPresentationParameters) PURE; + STDMETHOD(Present)(THIS_ const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region) PURE; + STDMETHOD(GetBackBuffer)(THIS_ UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8 ** ppBackBuffer) PURE; + STDMETHOD(GetRasterStatus)(THIS_ D3DRASTER_STATUS * pRasterStatus) PURE; + STDMETHOD_(void, SetGammaRamp)(THIS_ DWORD flags, const D3DGAMMARAMP *ramp) PURE; + STDMETHOD_(void,GetGammaRamp)(THIS_ D3DGAMMARAMP * pRamp) PURE; + STDMETHOD(CreateTexture)(THIS_ UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8 ** ppTexture) PURE; + STDMETHOD(CreateVolumeTexture)(THIS_ UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8 ** ppVolumeTexture) PURE; + STDMETHOD(CreateCubeTexture)(THIS_ UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8 ** ppCubeTexture) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8 ** ppVertexBuffer) PURE; + STDMETHOD(CreateIndexBuffer)(THIS_ UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8 ** ppIndexBuffer) PURE; + STDMETHOD(CreateRenderTarget)(THIS_ UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8 ** ppSurface) PURE; + STDMETHOD(CreateDepthStencilSurface)(THIS_ UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8 ** ppSurface) PURE; + STDMETHOD(CreateImageSurface)(THIS_ UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8 ** ppSurface) PURE; + STDMETHOD(CopyRects)(THIS_ IDirect3DSurface8 *src_surface, const RECT *src_rects, + UINT rect_count, IDirect3DSurface8 *dst_surface, const POINT *dst_points) PURE; + STDMETHOD(UpdateTexture)(THIS_ IDirect3DBaseTexture8 * pSourceTexture,IDirect3DBaseTexture8 * pDestinationTexture) PURE; + STDMETHOD(GetFrontBuffer)(THIS_ IDirect3DSurface8 * pDestSurface) PURE; + STDMETHOD(SetRenderTarget)(THIS_ IDirect3DSurface8 * pRenderTarget,IDirect3DSurface8 * pNewZStencil) PURE; + STDMETHOD(GetRenderTarget)(THIS_ IDirect3DSurface8 ** ppRenderTarget) PURE; + STDMETHOD(GetDepthStencilSurface)(THIS_ IDirect3DSurface8 ** ppZStencilSurface) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(Clear)(THIS_ DWORD rect_count, const D3DRECT *rects, DWORD flags, D3DCOLOR color, + float z, DWORD stencil) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE State,D3DMATRIX * pMatrix) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(SetViewport)(THIS_ const D3DVIEWPORT8 *viewport) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT8 * pViewport) PURE; + STDMETHOD(SetMaterial)(THIS_ const D3DMATERIAL8 *material) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL8 *pMaterial) PURE; + STDMETHOD(SetLight)(THIS_ DWORD index, const D3DLIGHT8 *light) PURE; + STDMETHOD(GetLight)(THIS_ DWORD Index,D3DLIGHT8 * pLight) PURE; + STDMETHOD(LightEnable)(THIS_ DWORD Index,BOOL Enable) PURE; + STDMETHOD(GetLightEnable)(THIS_ DWORD Index,BOOL * pEnable) PURE; + STDMETHOD(SetClipPlane)(THIS_ DWORD index, const float *plane) PURE; + STDMETHOD(GetClipPlane)(THIS_ DWORD Index,float * pPlane) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE State,DWORD Value) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE State,DWORD * pValue) PURE; + STDMETHOD(BeginStateBlock)(THIS) PURE; + STDMETHOD(EndStateBlock)(THIS_ DWORD * pToken) PURE; + STDMETHOD(ApplyStateBlock)(THIS_ DWORD Token) PURE; + STDMETHOD(CaptureStateBlock)(THIS_ DWORD Token) PURE; + STDMETHOD(DeleteStateBlock)(THIS_ DWORD Token) PURE; + STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE Type,DWORD * pToken) PURE; + STDMETHOD(SetClipStatus)(THIS_ const D3DCLIPSTATUS8 *clip_status) PURE; + STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS8 * pClipStatus) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD Stage,IDirect3DBaseTexture8 ** ppTexture) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD Stage,IDirect3DBaseTexture8 * pTexture) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD * pValue) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value) PURE; + STDMETHOD(ValidateDevice)(THIS_ DWORD * pNumPasses) PURE; + STDMETHOD(GetInfo)(THIS_ DWORD DevInfoID,void * pDevInfoStruct,DWORD DevInfoStructSize) PURE; + STDMETHOD(SetPaletteEntries)(THIS_ UINT palette_idx, const PALETTEENTRY *entries) PURE; + STDMETHOD(GetPaletteEntries)(THIS_ UINT PaletteNumber,PALETTEENTRY * pEntries) PURE; + STDMETHOD(SetCurrentTexturePalette)(THIS_ UINT PaletteNumber) PURE; + STDMETHOD(GetCurrentTexturePalette)(THIS_ UINT * PaletteNumber) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount) PURE; + STDMETHOD(DrawPrimitiveUP)(THIS_ D3DPRIMITIVETYPE primitive_type, UINT primitive_count, + const void *data, UINT stride) PURE; + STDMETHOD(DrawIndexedPrimitiveUP)(THIS_ D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, + UINT vertex_count, UINT primitive_count, const void *index_data, D3DFORMAT index_format, + const void *data, UINT stride) PURE; + STDMETHOD(ProcessVertices)(THIS_ UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8 * pDestBuffer,DWORD Flags) PURE; + STDMETHOD(CreateVertexShader)(THIS_ const DWORD *declaration, const DWORD *byte_code, + DWORD *shader, DWORD usage) PURE; + STDMETHOD(SetVertexShader)(THIS_ DWORD Handle) PURE; + STDMETHOD(GetVertexShader)(THIS_ DWORD * pHandle) PURE; + STDMETHOD(DeleteVertexShader)(THIS_ DWORD Handle) PURE; + STDMETHOD(SetVertexShaderConstant)(THIS_ DWORD reg_idx, const void *data, DWORD count) PURE; + STDMETHOD(GetVertexShaderConstant)(THIS_ DWORD Register,void * pConstantData,DWORD ConstantCount) PURE; + STDMETHOD(GetVertexShaderDeclaration)(THIS_ DWORD Handle,void * pData,DWORD * pSizeOfData) PURE; + STDMETHOD(GetVertexShaderFunction)(THIS_ DWORD Handle,void * pData,DWORD * pSizeOfData) PURE; + STDMETHOD(SetStreamSource)(THIS_ UINT StreamNumber,IDirect3DVertexBuffer8 * pStreamData,UINT Stride) PURE; + STDMETHOD(GetStreamSource)(THIS_ UINT StreamNumber,IDirect3DVertexBuffer8 ** ppStreamData,UINT * pStride) PURE; + STDMETHOD(SetIndices)(THIS_ IDirect3DIndexBuffer8 * pIndexData,UINT BaseVertexIndex) PURE; + STDMETHOD(GetIndices)(THIS_ IDirect3DIndexBuffer8 ** ppIndexData,UINT * pBaseVertexIndex) PURE; + STDMETHOD(CreatePixelShader)(THIS_ const DWORD *byte_code, DWORD *shader) PURE; + STDMETHOD(SetPixelShader)(THIS_ DWORD Handle) PURE; + STDMETHOD(GetPixelShader)(THIS_ DWORD * pHandle) PURE; + STDMETHOD(DeletePixelShader)(THIS_ DWORD Handle) PURE; + STDMETHOD(SetPixelShaderConstant)(THIS_ DWORD reg_idx, const void *data, DWORD count) PURE; + STDMETHOD(GetPixelShaderConstant)(THIS_ DWORD Register,void * pConstantData,DWORD ConstantCount) PURE; + STDMETHOD(GetPixelShaderFunction)(THIS_ DWORD Handle,void * pData,DWORD * pSizeOfData) PURE; + STDMETHOD(DrawRectPatch)(THIS_ UINT handle, const float *segment_count, + const D3DRECTPATCH_INFO *patch_info) PURE; + STDMETHOD(DrawTriPatch)(THIS_ UINT handle, const float *segment_count, + const D3DTRIPATCH_INFO *patch_info) PURE; + STDMETHOD(DeletePatch)(THIS_ UINT Handle) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DDevice8_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice8_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice8_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DDevice8 methods ***/ +#define IDirect3DDevice8_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p) +#define IDirect3DDevice8_GetAvailableTextureMem(p) (p)->lpVtbl->GetAvailableTextureMem(p) +#define IDirect3DDevice8_ResourceManagerDiscardBytes(p,a) (p)->lpVtbl->ResourceManagerDiscardBytes(p,a) +#define IDirect3DDevice8_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice8_GetDeviceCaps(p,a) (p)->lpVtbl->GetDeviceCaps(p,a) +#define IDirect3DDevice8_GetDisplayMode(p,a) (p)->lpVtbl->GetDisplayMode(p,a) +#define IDirect3DDevice8_GetCreationParameters(p,a) (p)->lpVtbl->GetCreationParameters(p,a) +#define IDirect3DDevice8_SetCursorProperties(p,a,b,c) (p)->lpVtbl->SetCursorProperties(p,a,b,c) +#define IDirect3DDevice8_SetCursorPosition(p,a,b,c) (p)->lpVtbl->SetCursorPosition(p,a,b,c) +#define IDirect3DDevice8_ShowCursor(p,a) (p)->lpVtbl->ShowCursor(p,a) +#define IDirect3DDevice8_CreateAdditionalSwapChain(p,a,b) (p)->lpVtbl->CreateAdditionalSwapChain(p,a,b) +#define IDirect3DDevice8_Reset(p,a) (p)->lpVtbl->Reset(p,a) +#define IDirect3DDevice8_Present(p,a,b,c,d) (p)->lpVtbl->Present(p,a,b,c,d) +#define IDirect3DDevice8_GetBackBuffer(p,a,b,c) (p)->lpVtbl->GetBackBuffer(p,a,b,c) +#define IDirect3DDevice8_GetRasterStatus(p,a) (p)->lpVtbl->GetRasterStatus(p,a) +#define IDirect3DDevice8_SetGammaRamp(p,a,b) (p)->lpVtbl->SetGammaRamp(p,a,b) +#define IDirect3DDevice8_GetGammaRamp(p,a) (p)->lpVtbl->GetGammaRamp(p,a) +#define IDirect3DDevice8_CreateTexture(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateTexture(p,a,b,c,d,e,f,g) +#define IDirect3DDevice8_CreateVolumeTexture(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateVolumeTexture(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice8_CreateCubeTexture(p,a,b,c,d,e,f) (p)->lpVtbl->CreateCubeTexture(p,a,b,c,d,e,f) +#define IDirect3DDevice8_CreateVertexBuffer(p,a,b,c,d,e) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c,d,e) +#define IDirect3DDevice8_CreateIndexBuffer(p,a,b,c,d,e) (p)->lpVtbl->CreateIndexBuffer(p,a,b,c,d,e) +#define IDirect3DDevice8_CreateRenderTarget(p,a,b,c,d,e,f) (p)->lpVtbl->CreateRenderTarget(p,a,b,c,d,e,f) +#define IDirect3DDevice8_CreateDepthStencilSurface(p,a,b,c,d,e) (p)->lpVtbl->CreateDepthStencilSurface(p,a,b,c,d,e) +#define IDirect3DDevice8_CreateImageSurface(p,a,b,c,d) (p)->lpVtbl->CreateImageSurface(p,a,b,c,d) +#define IDirect3DDevice8_CopyRects(p,a,b,c,d,e) (p)->lpVtbl->CopyRects(p,a,b,c,d,e) +#define IDirect3DDevice8_UpdateTexture(p,a,b) (p)->lpVtbl->UpdateTexture(p,a,b) +#define IDirect3DDevice8_GetFrontBuffer(p,a) (p)->lpVtbl->GetFrontBuffer(p,a) +#define IDirect3DDevice8_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice8_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice8_GetDepthStencilSurface(p,a) (p)->lpVtbl->GetDepthStencilSurface(p,a) +#define IDirect3DDevice8_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice8_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice8_Clear(p,a,b,c,d,e,f) (p)->lpVtbl->Clear(p,a,b,c,d,e,f) +#define IDirect3DDevice8_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice8_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice8_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice8_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DDevice8_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DDevice8_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DDevice8_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DDevice8_SetLight(p,a,b) (p)->lpVtbl->SetLight(p,a,b) +#define IDirect3DDevice8_GetLight(p,a,b) (p)->lpVtbl->GetLight(p,a,b) +#define IDirect3DDevice8_LightEnable(p,a,b) (p)->lpVtbl->LightEnable(p,a,b) +#define IDirect3DDevice8_GetLightEnable(p,a,b) (p)->lpVtbl->GetLightEnable(p,a,b) +#define IDirect3DDevice8_SetClipPlane(p,a,b) (p)->lpVtbl->SetClipPlane(p,a,b) +#define IDirect3DDevice8_GetClipPlane(p,a,b) (p)->lpVtbl->GetClipPlane(p,a,b) +#define IDirect3DDevice8_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice8_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice8_BeginStateBlock(p) (p)->lpVtbl->BeginStateBlock(p) +#define IDirect3DDevice8_EndStateBlock(p,a) (p)->lpVtbl->EndStateBlock(p,a) +#define IDirect3DDevice8_ApplyStateBlock(p,a) (p)->lpVtbl->ApplyStateBlock(p,a) +#define IDirect3DDevice8_CaptureStateBlock(p,a) (p)->lpVtbl->CaptureStateBlock(p,a) +#define IDirect3DDevice8_DeleteStateBlock(p,a) (p)->lpVtbl->DeleteStateBlock(p,a) +#define IDirect3DDevice8_CreateStateBlock(p,a,b) (p)->lpVtbl->CreateStateBlock(p,a,b) +#define IDirect3DDevice8_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice8_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice8_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice8_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice8_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice8_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice8_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#define IDirect3DDevice8_GetInfo(p,a,b,c) (p)->lpVtbl->GetInfo(p,a,b,c) +#define IDirect3DDevice8_SetPaletteEntries(p,a,b) (p)->lpVtbl->SetPaletteEntries(p,a,b) +#define IDirect3DDevice8_GetPaletteEntries(p,a,b) (p)->lpVtbl->GetPaletteEntries(p,a,b) +#define IDirect3DDevice8_SetCurrentTexturePalette(p,a) (p)->lpVtbl->SetCurrentTexturePalette(p,a) +#define IDirect3DDevice8_GetCurrentTexturePalette(p,a) (p)->lpVtbl->GetCurrentTexturePalette(p,a) +#define IDirect3DDevice8_DrawPrimitive(p,a,b,c) (p)->lpVtbl->DrawPrimitive(p,a,b,c) +#define IDirect3DDevice8_DrawIndexedPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice8_DrawPrimitiveUP(p,a,b,c,d) (p)->lpVtbl->DrawPrimitiveUP(p,a,b,c,d) +#define IDirect3DDevice8_DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice8_ProcessVertices(p,a,b,c,d,e) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e) +#define IDirect3DDevice8_CreateVertexShader(p,a,b,c,d) (p)->lpVtbl->CreateVertexShader(p,a,b,c,d) +#define IDirect3DDevice8_SetVertexShader(p,a) (p)->lpVtbl->SetVertexShader(p,a) +#define IDirect3DDevice8_GetVertexShader(p,a) (p)->lpVtbl->GetVertexShader(p,a) +#define IDirect3DDevice8_DeleteVertexShader(p,a) (p)->lpVtbl->DeleteVertexShader(p,a) +#define IDirect3DDevice8_SetVertexShaderConstant(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstant(p,a,b,c) +#define IDirect3DDevice8_GetVertexShaderConstant(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstant(p,a,b,c) +#define IDirect3DDevice8_GetVertexShaderDeclaration(p,a,b,c) (p)->lpVtbl->GetVertexShaderDeclaration(p,a,b,c) +#define IDirect3DDevice8_GetVertexShaderFunction(p,a,b,c) (p)->lpVtbl->GetVertexShaderFunction(p,a,b,c) +#define IDirect3DDevice8_SetStreamSource(p,a,b,c) (p)->lpVtbl->SetStreamSource(p,a,b,c) +#define IDirect3DDevice8_GetStreamSource(p,a,b,c) (p)->lpVtbl->GetStreamSource(p,a,b,c) +#define IDirect3DDevice8_SetIndices(p,a,b) (p)->lpVtbl->SetIndices(p,a,b) +#define IDirect3DDevice8_GetIndices(p,a,b) (p)->lpVtbl->GetIndices(p,a,b) +#define IDirect3DDevice8_CreatePixelShader(p,a,b) (p)->lpVtbl->CreatePixelShader(p,a,b) +#define IDirect3DDevice8_SetPixelShader(p,a) (p)->lpVtbl->SetPixelShader(p,a) +#define IDirect3DDevice8_GetPixelShader(p,a) (p)->lpVtbl->GetPixelShader(p,a) +#define IDirect3DDevice8_DeletePixelShader(p,a) (p)->lpVtbl->DeletePixelShader(p,a) +#define IDirect3DDevice8_SetPixelShaderConstant(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstant(p,a,b,c) +#define IDirect3DDevice8_GetPixelShaderConstant(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstant(p,a,b,c) +#define IDirect3DDevice8_GetPixelShaderFunction(p,a,b,c) (p)->lpVtbl->GetPixelShaderFunction(p,a,b,c) +#define IDirect3DDevice8_DrawRectPatch(p,a,b,c) (p)->lpVtbl->DrawRectPatch(p,a,b,c) +#define IDirect3DDevice8_DrawTriPatch(p,a,b,c) (p)->lpVtbl->DrawTriPatch(p,a,b,c) +#define IDirect3DDevice8_DeletePatch(p,a) (p)->lpVtbl->DeletePatch(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DDevice8_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice8_AddRef(p) (p)->AddRef() +#define IDirect3DDevice8_Release(p) (p)->Release() +/*** IDirect3DDevice8 methods ***/ +#define IDirect3DDevice8_TestCooperativeLevel(p) (p)->TestCooperativeLevel() +#define IDirect3DDevice8_GetAvailableTextureMem(p) (p)->GetAvailableTextureMem() +#define IDirect3DDevice8_ResourceManagerDiscardBytes(p,a) (p)->ResourceManagerDiscardBytes(a) +#define IDirect3DDevice8_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice8_GetDeviceCaps(p,a) (p)->GetDeviceCaps(a) +#define IDirect3DDevice8_GetDisplayMode(p,a) (p)->GetDisplayMode(a) +#define IDirect3DDevice8_GetCreationParameters(p,a) (p)->GetCreationParameters(a) +#define IDirect3DDevice8_SetCursorProperties(p,a,b,c) (p)->SetCursorProperties(a,b,c) +#define IDirect3DDevice8_SetCursorPosition(p,a,b,c) (p)->SetCursorPosition(a,b,c) +#define IDirect3DDevice8_ShowCursor(p,a) (p)->ShowCursor(a) +#define IDirect3DDevice8_CreateAdditionalSwapChain(p,a,b) (p)->CreateAdditionalSwapChain(a,b) +#define IDirect3DDevice8_Reset(p,a) (p)->Reset(a) +#define IDirect3DDevice8_Present(p,a,b,c,d) (p)->Present(a,b,c,d) +#define IDirect3DDevice8_GetBackBuffer(p,a,b,c) (p)->GetBackBuffer(a,b,c) +#define IDirect3DDevice8_GetRasterStatus(p,a) (p)->GetRasterStatus(a) +#define IDirect3DDevice8_SetGammaRamp(p,a,b) (p)->SetGammaRamp(a,b) +#define IDirect3DDevice8_GetGammaRamp(p,a) (p)->GetGammaRamp(a) +#define IDirect3DDevice8_CreateTexture(p,a,b,c,d,e,f,g) (p)->CreateTexture(a,b,c,d,e,f,g) +#define IDirect3DDevice8_CreateVolumeTexture(p,a,b,c,d,e,f,g,h) (p)->CreateVolumeTexture(a,b,c,d,e,f,g,h) +#define IDirect3DDevice8_CreateCubeTexture(p,a,b,c,d,e,f) (p)->CreateCubeTexture(a,b,c,d,e,f) +#define IDirect3DDevice8_CreateVertexBuffer(p,a,b,c,d,e) (p)->CreateVertexBuffer(a,b,c,d,e) +#define IDirect3DDevice8_CreateIndexBuffer(p,a,b,c,d,e) (p)->CreateIndexBuffer(a,b,c,d,e) +#define IDirect3DDevice8_CreateRenderTarget(p,a,b,c,d,e,f) (p)->CreateRenderTarget(a,b,c,d,e,f) +#define IDirect3DDevice8_CreateDepthStencilSurface(p,a,b,c,d,e) (p)->CreateDepthStencilSurface(a,b,c,d,e) +#define IDirect3DDevice8_CreateImageSurface(p,a,b,c,d) (p)->CreateImageSurface(a,b,c,d) +#define IDirect3DDevice8_CopyRects(p,a,b,c,d,e) (p)->CopyRects(a,b,c,d,e) +#define IDirect3DDevice8_UpdateTexture(p,a,b) (p)->UpdateTexture(a,b) +#define IDirect3DDevice8_GetFrontBuffer(p,a) (p)->GetFrontBuffer(a) +#define IDirect3DDevice8_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice8_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice8_GetDepthStencilSurface(p,a) (p)->GetDepthStencilSurface(a) +#define IDirect3DDevice8_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice8_EndScene(p) (p)->EndScene() +#define IDirect3DDevice8_Clear(p,a,b,c,d,e,f) (p)->Clear(a,b,c,d,e,f) +#define IDirect3DDevice8_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice8_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice8_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice8_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DDevice8_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DDevice8_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DDevice8_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DDevice8_SetLight(p,a,b) (p)->SetLight(a,b) +#define IDirect3DDevice8_GetLight(p,a,b) (p)->GetLight(a,b) +#define IDirect3DDevice8_LightEnable(p,a,b) (p)->LightEnable(a,b) +#define IDirect3DDevice8_GetLightEnable(p,a,b) (p)->GetLightEnable(a,b) +#define IDirect3DDevice8_SetClipPlane(p,a,b) (p)->SetClipPlane(a,b) +#define IDirect3DDevice8_GetClipPlane(p,a,b) (p)->GetClipPlane(a,b) +#define IDirect3DDevice8_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice8_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice8_BeginStateBlock(p) (p)->BeginStateBlock() +#define IDirect3DDevice8_EndStateBlock(p,a) (p)->EndStateBlock(a) +#define IDirect3DDevice8_ApplyStateBlock(p,a) (p)->ApplyStateBlock(a) +#define IDirect3DDevice8_CaptureStateBlock(p,a) (p)->CaptureStateBlock(a) +#define IDirect3DDevice8_DeleteStateBlock(p,a) (p)->DeleteStateBlock(a) +#define IDirect3DDevice8_CreateStateBlock(p,a,b) (p)->CreateStateBlock(a,b) +#define IDirect3DDevice8_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice8_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice8_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice8_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice8_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice8_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice8_ValidateDevice(p,a) (p)->ValidateDevice(a) +#define IDirect3DDevice8_GetInfo(p,a,b,c) (p)->GetInfo(a,b,c) +#define IDirect3DDevice8_SetPaletteEntries(p,a,b) (p)->SetPaletteEntries(a,b) +#define IDirect3DDevice8_GetPaletteEntries(p,a,b) (p)->GetPaletteEntries(a,b) +#define IDirect3DDevice8_SetCurrentTexturePalette(p,a) (p)->SetCurrentTexturePalette(a) +#define IDirect3DDevice8_GetCurrentTexturePalette(p,a) (p)->GetCurrentTexturePalette(a) +#define IDirect3DDevice8_DrawPrimitive(p,a,b,c) (p)->DrawPrimitive(a,b,c) +#define IDirect3DDevice8_DrawIndexedPrimitive(p,a,b,c,d,e) (p)->DrawIndexedPrimitive(a,b,c,d,e) +#define IDirect3DDevice8_DrawPrimitiveUP(p,a,b,c,d) (p)->DrawPrimitiveUP(a,b,c,d) +#define IDirect3DDevice8_DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) (p)->DrawIndexedPrimitiveUP(a,b,c,d,e,f,g,h) +#define IDirect3DDevice8_ProcessVertices(p,a,b,c,d,e) (p)->ProcessVertices(a,b,c,d,e) +#define IDirect3DDevice8_CreateVertexShader(p,a,b,c,d) (p)->CreateVertexShader(a,b,c,d) +#define IDirect3DDevice8_SetVertexShader(p,a) (p)->SetVertexShader(a) +#define IDirect3DDevice8_GetVertexShader(p,a) (p)->GetVertexShader(a) +#define IDirect3DDevice8_DeleteVertexShader(p,a) (p)->DeleteVertexShader(a) +#define IDirect3DDevice8_SetVertexShaderConstant(p,a,b,c) (p)->SetVertexShaderConstant(a,b,c) +#define IDirect3DDevice8_GetVertexShaderConstant(p,a,b,c) (p)->GetVertexShaderConstant(a,b,c) +#define IDirect3DDevice8_GetVertexShaderDeclaration(p,a,b,c) (p)->GetVertexShaderDeclaration(a,b,c) +#define IDirect3DDevice8_GetVertexShaderFunction(p,a,b,c) (p)->GetVertexShaderFunction(a,b,c) +#define IDirect3DDevice8_SetStreamSource(p,a,b,c) (p)->SetStreamSource(a,b,c) +#define IDirect3DDevice8_GetStreamSource(p,a,b,c) (p)->GetStreamSource(a,b,c) +#define IDirect3DDevice8_SetIndices(p,a,b) (p)->SetIndices(a,b) +#define IDirect3DDevice8_GetIndices(p,a,b) (p)->GetIndices(a,b) +#define IDirect3DDevice8_CreatePixelShader(p,a,b) (p)->CreatePixelShader(a,b) +#define IDirect3DDevice8_SetPixelShader(p,a) (p)->SetPixelShader(a) +#define IDirect3DDevice8_GetPixelShader(p,a) (p)->GetPixelShader(a) +#define IDirect3DDevice8_DeletePixelShader(p,a) (p)->DeletePixelShader(a) +#define IDirect3DDevice8_SetPixelShaderConstant(p,a,b,c) (p)->SetPixelShaderConstant(a,b,c) +#define IDirect3DDevice8_GetPixelShaderConstant(p,a,b,c) (p)->GetPixelShaderConstant(a,b,c) +#define IDirect3DDevice8_GetPixelShaderFunction(p,a,b,c) (p)->GetPixelShaderFunction(a,b,c) +#define IDirect3DDevice8_DrawRectPatch(p,a,b,c) (p)->DrawRectPatch(a,b,c) +#define IDirect3DDevice8_DrawTriPatch(p,a,b,c) (p)->DrawTriPatch(a,b,c) +#define IDirect3DDevice8_DeletePatch(p,a) (p)->DeletePatch(a) +#endif + +#ifdef __cplusplus +extern "C" { +#endif /* defined(__cplusplus) */ + +/* Define the main entrypoint as well */ +IDirect3D8* WINAPI Direct3DCreate8(UINT SDKVersion); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + +#endif /* __WINE_D3D8_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3d8caps.h b/WineFix/lib/d2d1/include/windows/d3d8caps.h new file mode 100644 index 0000000..345884f --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d8caps.h @@ -0,0 +1,296 @@ +/* + * Copyright (C) 2002 Jason Edmeades + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D8CAPS_H +#define __WINE_D3D8CAPS_H + +#ifdef __i386__ +#pragma pack(push,4) +#endif + +/* + * Definitions + */ + +#define D3DCAPS_READ_SCANLINE 0x20000 + +#define D3DCURSORCAPS_COLOR 1 +#define D3DCURSORCAPS_LOWRES 2 + +#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x0000010 +#define D3DDEVCAPS_EXECUTEVIDEOMEMORY 0x0000020 +#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x0000040 +#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x0000080 +#define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x0000100 +#define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x0000200 +#define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x0000400 +#define D3DDEVCAPS_CANRENDERAFTERFLIP 0x0000800 +#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x0001000 +#define D3DDEVCAPS_DRAWPRIMITIVES2 0x0002000 +#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x0004000 +#define D3DDEVCAPS_DRAWPRIMITIVES2EX 0x0008000 +#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x0010000 +#define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x0020000 +#define D3DDEVCAPS_HWRASTERIZATION 0x0080000 +#define D3DDEVCAPS_PUREDEVICE 0x0100000 +#define D3DDEVCAPS_QUINTICRTPATCHES 0x0200000 +#define D3DDEVCAPS_RTPATCHES 0x0400000 +#define D3DDEVCAPS_RTPATCHHANDLEZERO 0x0800000 +#define D3DDEVCAPS_NPATCHES 0x1000000 + +#define D3DFVFCAPS_TEXCOORDCOUNTMASK 0x00FFFF +#define D3DFVFCAPS_DONOTSTRIPELEMENTS 0x080000 +#define D3DFVFCAPS_PSIZE 0x100000 + +#define D3DLINECAPS_TEXTURE 0x01 +#define D3DLINECAPS_ZTEST 0x02 +#define D3DLINECAPS_BLEND 0x04 +#define D3DLINECAPS_ALPHACMP 0x08 +#define D3DLINECAPS_FOG 0x10 + +#define D3DPBLENDCAPS_ZERO 0x0001 +#define D3DPBLENDCAPS_ONE 0x0002 +#define D3DPBLENDCAPS_SRCCOLOR 0x0004 +#define D3DPBLENDCAPS_INVSRCCOLOR 0x0008 +#define D3DPBLENDCAPS_SRCALPHA 0x0010 +#define D3DPBLENDCAPS_INVSRCALPHA 0x0020 +#define D3DPBLENDCAPS_DESTALPHA 0x0040 +#define D3DPBLENDCAPS_INVDESTALPHA 0x0080 +#define D3DPBLENDCAPS_DESTCOLOR 0x0100 +#define D3DPBLENDCAPS_INVDESTCOLOR 0x0200 +#define D3DPBLENDCAPS_SRCALPHASAT 0x0400 +#define D3DPBLENDCAPS_BOTHSRCALPHA 0x0800 +#define D3DPBLENDCAPS_BOTHINVSRCALPHA 0x1000 + +#define D3DPCMPCAPS_NEVER 0x01 +#define D3DPCMPCAPS_LESS 0x02 +#define D3DPCMPCAPS_EQUAL 0x04 +#define D3DPCMPCAPS_LESSEQUAL 0x08 +#define D3DPCMPCAPS_GREATER 0x10 +#define D3DPCMPCAPS_NOTEQUAL 0x20 +#define D3DPCMPCAPS_GREATEREQUAL 0x40 +#define D3DPCMPCAPS_ALWAYS 0x80 + +#define D3DPMISCCAPS_MASKZ __MSABI_LONG(0x00000002) +#define D3DPMISCCAPS_LINEPATTERNREP __MSABI_LONG(0x00000004) +#define D3DPMISCCAPS_CULLNONE __MSABI_LONG(0x00000010) +#define D3DPMISCCAPS_CULLCW __MSABI_LONG(0x00000020) +#define D3DPMISCCAPS_CULLCCW __MSABI_LONG(0x00000040) +#define D3DPMISCCAPS_COLORWRITEENABLE __MSABI_LONG(0x00000080) +#define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS __MSABI_LONG(0x00000100) +#define D3DPMISCCAPS_CLIPTLVERTS __MSABI_LONG(0x00000200) +#define D3DPMISCCAPS_TSSARGTEMP __MSABI_LONG(0x00000400) +#define D3DPMISCCAPS_BLENDOP __MSABI_LONG(0x00000800) +#define D3DPMISCCAPS_NULLREFERENCE __MSABI_LONG(0x00001000) + +#define D3DPRASTERCAPS_DITHER 0x00000001 +#define D3DPRASTERCAPS_PAT 0x00000008 +#define D3DPRASTERCAPS_ZTEST 0x00000010 +#define D3DPRASTERCAPS_FOGVERTEX 0x00000080 +#define D3DPRASTERCAPS_FOGTABLE 0x00000100 +#define D3DPRASTERCAPS_ANTIALIASEDGES 0x00001000 +#define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000 +#define D3DPRASTERCAPS_ZBIAS 0x00004000 +#define D3DPRASTERCAPS_ZBUFFERLESSHSR 0x00008000 +#define D3DPRASTERCAPS_FOGRANGE 0x00010000 +#define D3DPRASTERCAPS_ANISOTROPY 0x00020000 +#define D3DPRASTERCAPS_WBUFFER 0x00040000 +#define D3DPRASTERCAPS_WFOG 0x00100000 +#define D3DPRASTERCAPS_ZFOG 0x00200000 +#define D3DPRASTERCAPS_COLORPERSPECTIVE 0x00400000 +#define D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE 0x00800000 + +#define D3DPRESENT_INTERVAL_DEFAULT 0x00000000 +#define D3DPRESENT_INTERVAL_ONE 0x00000001 +#define D3DPRESENT_INTERVAL_TWO 0x00000002 +#define D3DPRESENT_INTERVAL_THREE 0x00000004 +#define D3DPRESENT_INTERVAL_FOUR 0x00000008 +#define D3DPRESENT_INTERVAL_IMMEDIATE 0x80000000 + +#define D3DPSHADECAPS_COLORGOURAUDRGB 0x00008 +#define D3DPSHADECAPS_SPECULARGOURAUDRGB 0x00200 +#define D3DPSHADECAPS_ALPHAGOURAUDBLEND 0x04000 +#define D3DPSHADECAPS_FOGGOURAUD 0x80000 + +#define D3DPTADDRESSCAPS_WRAP 0x01 +#define D3DPTADDRESSCAPS_MIRROR 0x02 +#define D3DPTADDRESSCAPS_CLAMP 0x04 +#define D3DPTADDRESSCAPS_BORDER 0x08 +#define D3DPTADDRESSCAPS_INDEPENDENTUV 0x10 +#define D3DPTADDRESSCAPS_MIRRORONCE 0x20 + +#define D3DPTEXTURECAPS_PERSPECTIVE 0x00001 +#define D3DPTEXTURECAPS_POW2 0x00002 +#define D3DPTEXTURECAPS_ALPHA 0x00004 +#define D3DPTEXTURECAPS_SQUAREONLY 0x00020 +#define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE 0x00040 +#define D3DPTEXTURECAPS_ALPHAPALETTE 0x00080 +#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL 0x00100 +#define D3DPTEXTURECAPS_PROJECTED 0x00400 +#define D3DPTEXTURECAPS_CUBEMAP 0x00800 +#define D3DPTEXTURECAPS_VOLUMEMAP 0x02000 +#define D3DPTEXTURECAPS_MIPMAP 0x04000 +#define D3DPTEXTURECAPS_MIPVOLUMEMAP 0x08000 +#define D3DPTEXTURECAPS_MIPCUBEMAP 0x10000 +#define D3DPTEXTURECAPS_CUBEMAP_POW2 0x20000 +#define D3DPTEXTURECAPS_VOLUMEMAP_POW2 0x40000 + +#define D3DPTFILTERCAPS_MINFPOINT 0x00000100 +#define D3DPTFILTERCAPS_MINFLINEAR 0x00000200 +#define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400 +#define D3DPTFILTERCAPS_MIPFPOINT 0x00010000 +#define D3DPTFILTERCAPS_MIPFLINEAR 0x00020000 +#define D3DPTFILTERCAPS_MAGFPOINT 0x01000000 +#define D3DPTFILTERCAPS_MAGFLINEAR 0x02000000 +#define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000 +#define D3DPTFILTERCAPS_MAGFAFLATCUBIC 0x08000000 +#define D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC 0x10000000 + +#define D3DSTENCILCAPS_KEEP 0x01 +#define D3DSTENCILCAPS_ZERO 0x02 +#define D3DSTENCILCAPS_REPLACE 0x04 +#define D3DSTENCILCAPS_INCRSAT 0x08 +#define D3DSTENCILCAPS_DECRSAT 0x10 +#define D3DSTENCILCAPS_INVERT 0x20 +#define D3DSTENCILCAPS_INCR 0x40 +#define D3DSTENCILCAPS_DECR 0x80 + +#define D3DTEXOPCAPS_DISABLE 0x0000001 +#define D3DTEXOPCAPS_SELECTARG1 0x0000002 +#define D3DTEXOPCAPS_SELECTARG2 0x0000004 +#define D3DTEXOPCAPS_MODULATE 0x0000008 +#define D3DTEXOPCAPS_MODULATE2X 0x0000010 +#define D3DTEXOPCAPS_MODULATE4X 0x0000020 +#define D3DTEXOPCAPS_ADD 0x0000040 +#define D3DTEXOPCAPS_ADDSIGNED 0x0000080 +#define D3DTEXOPCAPS_ADDSIGNED2X 0x0000100 +#define D3DTEXOPCAPS_SUBTRACT 0x0000200 +#define D3DTEXOPCAPS_ADDSMOOTH 0x0000400 +#define D3DTEXOPCAPS_BLENDDIFFUSEALPHA 0x0000800 +#define D3DTEXOPCAPS_BLENDTEXTUREALPHA 0x0001000 +#define D3DTEXOPCAPS_BLENDFACTORALPHA 0x0002000 +#define D3DTEXOPCAPS_BLENDTEXTUREALPHAPM 0x0004000 +#define D3DTEXOPCAPS_BLENDCURRENTALPHA 0x0008000 +#define D3DTEXOPCAPS_PREMODULATE 0x0010000 +#define D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR 0x0020000 +#define D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA 0x0040000 +#define D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR 0x0080000 +#define D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA 0x0100000 +#define D3DTEXOPCAPS_BUMPENVMAP 0x0200000 +#define D3DTEXOPCAPS_BUMPENVMAPLUMINANCE 0x0400000 +#define D3DTEXOPCAPS_DOTPRODUCT3 0x0800000 +#define D3DTEXOPCAPS_MULTIPLYADD 0x1000000 +#define D3DTEXOPCAPS_LERP 0x2000000 + +#define D3DVTXPCAPS_TEXGEN __MSABI_LONG(0x00000001) +#define D3DVTXPCAPS_MATERIALSOURCE7 __MSABI_LONG(0x00000002) +#define D3DVTXPCAPS_DIRECTIONALLIGHTS __MSABI_LONG(0x00000008) +#define D3DVTXPCAPS_POSITIONALLIGHTS __MSABI_LONG(0x00000010) +#define D3DVTXPCAPS_LOCALVIEWER __MSABI_LONG(0x00000020) +#define D3DVTXPCAPS_TWEENING __MSABI_LONG(0x00000040) +#define D3DVTXPCAPS_NO_VSDT_UBYTE4 __MSABI_LONG(0x00000080) + +#define D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD 0x00000020 +#define D3DCAPS3_RESERVED 0x8000001f + +#define D3DCAPS2_CANCALIBRATEGAMMA 0x0100000 +#define D3DCAPS2_CANRENDERWINDOWED 0x0080000 +#define D3DCAPS2_CANMANAGERESOURCE 0x10000000 +#define D3DCAPS2_DYNAMICTEXTURES 0x20000000 +#define D3DCAPS2_FULLSCREENGAMMA 0x0020000 +#define D3DCAPS2_NO2DDURING3DSCENE 0x0000002 +#define D3DCAPS2_RESERVED 0x2000000 + +/* + * The d3dcaps8 structure + */ +typedef struct _D3DCAPS8 { + D3DDEVTYPE DeviceType; + UINT AdapterOrdinal; + + DWORD Caps; + DWORD Caps2; + DWORD Caps3; + DWORD PresentationIntervals; + + DWORD CursorCaps; + + DWORD DevCaps; + + DWORD PrimitiveMiscCaps; + DWORD RasterCaps; + DWORD ZCmpCaps; + DWORD SrcBlendCaps; + DWORD DestBlendCaps; + DWORD AlphaCmpCaps; + DWORD ShadeCaps; + DWORD TextureCaps; + DWORD TextureFilterCaps; + DWORD CubeTextureFilterCaps; + DWORD VolumeTextureFilterCaps; + DWORD TextureAddressCaps; + DWORD VolumeTextureAddressCaps; + + DWORD LineCaps; + + DWORD MaxTextureWidth, MaxTextureHeight; + DWORD MaxVolumeExtent; + + DWORD MaxTextureRepeat; + DWORD MaxTextureAspectRatio; + DWORD MaxAnisotropy; + float MaxVertexW; + + float GuardBandLeft; + float GuardBandTop; + float GuardBandRight; + float GuardBandBottom; + + float ExtentsAdjust; + DWORD StencilCaps; + + DWORD FVFCaps; + DWORD TextureOpCaps; + DWORD MaxTextureBlendStages; + DWORD MaxSimultaneousTextures; + + DWORD VertexProcessingCaps; + DWORD MaxActiveLights; + DWORD MaxUserClipPlanes; + DWORD MaxVertexBlendMatrices; + DWORD MaxVertexBlendMatrixIndex; + + float MaxPointSize; + + DWORD MaxPrimitiveCount; + DWORD MaxVertexIndex; + DWORD MaxStreams; + DWORD MaxStreamStride; + + DWORD VertexShaderVersion; + DWORD MaxVertexShaderConst; + + DWORD PixelShaderVersion; + float MaxPixelShaderValue; +} D3DCAPS8; + +#ifdef __i386__ +#pragma pack(pop) +#endif + +#endif /* __WINE_D3D8CAPS_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3d8types.h b/WineFix/lib/d2d1/include/windows/d3d8types.h new file mode 100644 index 0000000..06c3b57 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d8types.h @@ -0,0 +1,1226 @@ +/* + * Copyright (C) 2002 Jason Edmeades + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D8TYPES_H +#define __WINE_D3D8TYPES_H + +#ifdef __i386__ +#pragma pack(push,4) +#endif + +/***************************************************************************** + * Direct 3D v8 #defines + */ + +#define D3DCLEAR_TARGET 1 +#define D3DCLEAR_ZBUFFER 2 +#define D3DCLEAR_STENCIL 4 + +#define D3DCLIPPLANE0 (1 << 0) +#define D3DCLIPPLANE1 (1 << 1) +#define D3DCLIPPLANE2 (1 << 2) +#define D3DCLIPPLANE3 (1 << 3) +#define D3DCLIPPLANE4 (1 << 4) +#define D3DCLIPPLANE5 (1 << 5) + +#define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xffu)<<24)|(((r)&0xffu)<<16)|(((g)&0xffu)<<8)|((b)&0xffu))) +#define D3DCOLOR_COLORVALUE(r,g,b,a) D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f)) +#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b) +#define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b) + +#define D3DCS_LEFT 0x001 +#define D3DCS_RIGHT 0x002 +#define D3DCS_TOP 0x004 +#define D3DCS_BOTTOM 0x008 +#define D3DCS_FRONT 0x010 +#define D3DCS_BACK 0x020 +#define D3DCS_PLANE0 0x040 +#define D3DCS_PLANE1 0x080 +#define D3DCS_PLANE2 0x100 +#define D3DCS_PLANE3 0x200 +#define D3DCS_PLANE4 0x400 +#define D3DCS_PLANE5 0x800 +#define D3DCS_ALL 0xFFF + +#define D3DFVF_TEXTUREFORMAT1 3 +#define D3DFVF_TEXTUREFORMAT2 0 +#define D3DFVF_TEXTUREFORMAT3 1 +#define D3DFVF_TEXTUREFORMAT4 2 +#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) +#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) + +#define D3DLOCK_READONLY 0x0010 +#define D3DLOCK_NOSYSLOCK 0x0800 +#define D3DLOCK_NOOVERWRITE 0x1000 +#define D3DLOCK_DISCARD 0x2000 +#define D3DLOCK_NO_DIRTY_UPDATE 0x8000 + +#define D3DMAXUSERCLIPPLANES 32 + +#define D3DRENDERSTATE_WRAPBIAS 0x80 + +#define D3DTSS_TCI_PASSTHRU 0x00000 +#define D3DTSS_TCI_CAMERASPACENORMAL 0x10000 +#define D3DTSS_TCI_CAMERASPACEPOSITION 0x20000 +#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x30000 + + +#define D3DTS_WORLD D3DTS_WORLDMATRIX(0) +#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1) +#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2) +#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3) +#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256) + +#define D3DUSAGE_RENDERTARGET 0x01 +#define D3DUSAGE_DEPTHSTENCIL 0x02 +#define D3DUSAGE_WRITEONLY 0x08 +#define D3DUSAGE_SOFTWAREPROCESSING 0x10 +#define D3DUSAGE_DONOTCLIP 0x20 +#define D3DUSAGE_POINTS 0x40 +#define D3DUSAGE_RTPATCHES 0x80 +#define D3DUSAGE_NPATCHES 0x100 +#define D3DUSAGE_DYNAMIC 0x200 + +#define D3DWRAP_U 1 +#define D3DWRAP_V 2 +#define D3DWRAP_W 4 +#define D3DWRAPCOORD_0 1 +#define D3DWRAPCOORD_1 2 +#define D3DWRAPCOORD_2 4 +#define D3DWRAPCOORD_3 8 + +#define MAX_DEVICE_IDENTIFIER_STRING 512 + +#define D3DFVF_RESERVED0 0x0001 +#define D3DFVF_POSITION_MASK 0x000E +#define D3DFVF_XYZ 0x0002 +#define D3DFVF_XYZRHW 0x0004 +#define D3DFVF_XYZB1 0x0006 +#define D3DFVF_XYZB2 0x0008 +#define D3DFVF_XYZB3 0x000a +#define D3DFVF_XYZB4 0x000c +#define D3DFVF_XYZB5 0x000e +#define D3DFVF_NORMAL 0x0010 +#define D3DFVF_PSIZE 0x0020 +#define D3DFVF_DIFFUSE 0x0040 +#define D3DFVF_SPECULAR 0x0080 +#define D3DFVF_TEXCOUNT_MASK 0x0f00 +#define D3DFVF_TEXCOUNT_SHIFT 8 +#define D3DFVF_TEX0 0x0000 +#define D3DFVF_TEX1 0x0100 +#define D3DFVF_TEX2 0x0200 +#define D3DFVF_TEX3 0x0300 +#define D3DFVF_TEX4 0x0400 +#define D3DFVF_TEX5 0x0500 +#define D3DFVF_TEX6 0x0600 +#define D3DFVF_TEX7 0x0700 +#define D3DFVF_TEX8 0x0800 +#define D3DFVF_LASTBETA_UBYTE4 0x1000 +#define D3DFVF_RESERVED2 0xE000 + +#define D3DTA_SELECTMASK 0x0000000f +#define D3DTA_DIFFUSE 0x00000000 +#define D3DTA_CURRENT 0x00000001 +#define D3DTA_TEXTURE 0x00000002 +#define D3DTA_TFACTOR 0x00000003 +#define D3DTA_SPECULAR 0x00000004 +#define D3DTA_COMPLEMENT 0x00000010 +#define D3DTA_ALPHAREPLICATE 0x00000020 +#define D3DTA_TEMP 0x00000005 + +#define D3DCOLORWRITEENABLE_RED (__MSABI_LONG(1)<<0) +#define D3DCOLORWRITEENABLE_GREEN (__MSABI_LONG(1)<<1) +#define D3DCOLORWRITEENABLE_BLUE (__MSABI_LONG(1)<<2) +#define D3DCOLORWRITEENABLE_ALPHA (__MSABI_LONG(1)<<3) + +#define D3DDEVINFOID_RESOURCEMANAGER 5 +#define D3DDEVINFOID_VERTEXSTATS 6 + + +#ifndef MAKEFOURCC +#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ + ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) +#endif + +/**************************** + * Vertex Shaders Declaration + */ + +typedef enum _D3DVSD_TOKENTYPE { + D3DVSD_TOKEN_NOP = 0, + D3DVSD_TOKEN_STREAM = 1, + D3DVSD_TOKEN_STREAMDATA = 2, + D3DVSD_TOKEN_TESSELLATOR = 3, + D3DVSD_TOKEN_CONSTMEM = 4, + D3DVSD_TOKEN_EXT = 5, + /* RESERVED = 6 */ + D3DVSD_TOKEN_END = 7, + D3DVSD_FORCE_DWORD = 0x7FFFFFFF +} D3DVSD_TOKENTYPE; + +/** input registers for vertex shaders functions */ +/* +#define D3DVSDE_POSITION 0 +#define D3DVSDE_BLENDWEIGHT 1 +#define D3DVSDE_BLENDINDICES 2 +#define D3DVSDE_NORMAL 3 +#define D3DVSDE_PSIZE 4 +#define D3DVSDE_DIFFUSE 5 +#define D3DVSDE_SPECULAR 6 +#define D3DVSDE_TEXCOORD0 7 +#define D3DVSDE_TEXCOORD1 8 +#define D3DVSDE_TEXCOORD2 9 +#define D3DVSDE_TEXCOORD3 10 +#define D3DVSDE_TEXCOORD4 11 +#define D3DVSDE_TEXCOORD5 12 +#define D3DVSDE_TEXCOORD6 13 +#define D3DVSDE_TEXCOORD7 14 +#define D3DVSDE_POSITION2 15 +#define D3DVSDE_NORMAL2 16 +*/ +/** Address of the vertex register. 0 - 16 */ +typedef enum _D3DVSDE_REGISTER { + D3DVSDE_POSITION = 0, + D3DVSDE_BLENDWEIGHT = 1, + D3DVSDE_BLENDINDICES = 2, + D3DVSDE_NORMAL = 3, + D3DVSDE_PSIZE = 4, + D3DVSDE_DIFFUSE = 5, + D3DVSDE_SPECULAR = 6, + D3DVSDE_TEXCOORD0 = 7, + D3DVSDE_TEXCOORD1 = 8, + D3DVSDE_TEXCOORD2 = 9, + D3DVSDE_TEXCOORD3 = 10, + D3DVSDE_TEXCOORD4 = 11, + D3DVSDE_TEXCOORD5 = 12, + D3DVSDE_TEXCOORD6 = 13, + D3DVSDE_TEXCOORD7 = 14, + D3DVSDE_POSITION2 = 15, + D3DVSDE_NORMAL2 = 16 +} D3DVSDE_REGISTER; + +/** bit-field declaration for VertexRegister Type */ +/* +#define D3DVSDT_FLOAT1 0x00 +#define D3DVSDT_FLOAT2 0x01 +#define D3DVSDT_FLOAT3 0x02 +#define D3DVSDT_FLOAT4 0x03 +#define D3DVSDT_D3DCOLOR 0x04 +#define D3DVSDT_UBYTE4 0x05 +#define D3DVSDT_SHORT2 0x06 +#define D3DVSDT_SHORT4 0x07 +*/ +typedef enum _D3DVSDT_TYPE { + D3DVSDT_FLOAT1 = 0x00, + D3DVSDT_FLOAT2 = 0x01, + D3DVSDT_FLOAT3 = 0x02, + D3DVSDT_FLOAT4 = 0x03, + D3DVSDT_D3DCOLOR = 0x04, + D3DVSDT_UBYTE4 = 0x05, + D3DVSDT_SHORT2 = 0x06, + D3DVSDT_SHORT4 = 0x07 +} D3DVSDT_TYPE; + + +#define D3DVSD_CONSTADDRESSSHIFT 0 +#define D3DVSD_EXTINFOSHIFT 0 +#define D3DVSD_STREAMNUMBERSHIFT 0 +#define D3DVSD_VERTEXREGSHIFT 0 +#define D3DVSD_CONSTRSSHIFT 16 +#define D3DVSD_DATATYPESHIFT 16 +#define D3DVSD_SKIPCOUNTSHIFT 16 +#define D3DVSD_VERTEXREGINSHIFT 20 +#define D3DVSD_EXTCOUNTSHIFT 24 +#define D3DVSD_CONSTCOUNTSHIFT 25 +#define D3DVSD_DATALOADTYPESHIFT 28 +#define D3DVSD_STREAMTESSSHIFT 28 +#define D3DVSD_TOKENTYPESHIFT 29 + +#define D3DVSD_CONSTADDRESSMASK (0x7F << D3DVSD_CONSTADDRESSSHIFT) +#define D3DVSD_EXTINFOMASK (0xFFFFFF << D3DVSD_EXTINFOSHIFT) +#define D3DVSD_STREAMNUMBERMASK (0xF << D3DVSD_STREAMNUMBERSHIFT) +#define D3DVSD_VERTEXREGMASK (0x1F << D3DVSD_VERTEXREGSHIFT) +#define D3DVSD_CONSTRSMASK (0x1FFF << D3DVSD_CONSTRSSHIFT) +#define D3DVSD_DATATYPEMASK (0xF << D3DVSD_DATATYPESHIFT) +#define D3DVSD_SKIPCOUNTMASK (0xF << D3DVSD_SKIPCOUNTSHIFT) +#define D3DVSD_EXTCOUNTMASK (0x1F << D3DVSD_EXTCOUNTSHIFT) +#define D3DVSD_VERTEXREGINMASK (0xF << D3DVSD_VERTEXREGINSHIFT) +#define D3DVSD_CONSTCOUNTMASK (0xF << D3DVSD_CONSTCOUNTSHIFT) +#define D3DVSD_DATALOADTYPEMASK (0x1 << D3DVSD_DATALOADTYPESHIFT) +#define D3DVSD_STREAMTESSMASK (0x1 << D3DVSD_STREAMTESSSHIFT) +#define D3DVSD_TOKENTYPEMASK (0x7u << D3DVSD_TOKENTYPESHIFT) + + +#define D3DVSD_MAKETOKENTYPE(TokenType) \ + (((unsigned)TokenType << D3DVSD_TOKENTYPESHIFT) & D3DVSD_TOKENTYPEMASK) + +#define D3DVSD_CONST(ConstantAddress, Count) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_CONSTMEM) | ((Count) << D3DVSD_CONSTCOUNTSHIFT) | (ConstantAddress)) + +#define D3DVSD_END() 0xFFFFFFFF + +#define D3DVSD_NOP() 0x00000000 + +#define D3DVSD_REG(VertexRegister, Type) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | ((Type) << D3DVSD_DATATYPESHIFT) | (VertexRegister)) + +#define D3DVSD_SKIP(Count) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | 0x10000000 | ((Count) << D3DVSD_SKIPCOUNTSHIFT)) + +#define D3DVSD_STREAM(StreamNumber) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (StreamNumber)) + +#define D3DVSD_STREAM_TESS() \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (D3DVSD_STREAMTESSMASK)) + +#define D3DVSD_TESSNORMAL(RegisterIn, RegisterOut) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | ((RegisterIn) << D3DVSD_VERTEXREGINSHIFT) | ((0x02) << D3DVSD_DATATYPESHIFT) | (RegisterOut)) + +#define D3DVSD_TESSUV(Register) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | 0x10000000 | ((0x01) << D3DVSD_DATATYPESHIFT) | (Register)) + + +/******************************** + * Pixel/Vertex Shaders Functions + */ + +/** Maximum number of supported texture coordinates sets operation */ +#define D3DDP_MAXTEXCOORD 8 + +/** opcode token mask */ +#define D3DSI_OPCODE_MASK 0x0000FFFF + +/** opcodes types for PS and VS */ +typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE { + D3DSIO_NOP = 0, + D3DSIO_MOV = 1, + D3DSIO_ADD = 2, + D3DSIO_SUB = 3, + D3DSIO_MAD = 4, + D3DSIO_MUL = 5, + D3DSIO_RCP = 6, + D3DSIO_RSQ = 7, + D3DSIO_DP3 = 8, + D3DSIO_DP4 = 9, + D3DSIO_MIN = 10, + D3DSIO_MAX = 11, + D3DSIO_SLT = 12, + D3DSIO_SGE = 13, + D3DSIO_EXP = 14, + D3DSIO_LOG = 15, + D3DSIO_LIT = 16, + D3DSIO_DST = 17, + D3DSIO_LRP = 18, + D3DSIO_FRC = 19, + D3DSIO_M4x4 = 20, + D3DSIO_M4x3 = 21, + D3DSIO_M3x4 = 22, + D3DSIO_M3x3 = 23, + D3DSIO_M3x2 = 24, + + D3DSIO_TEXCOORD = 64, + D3DSIO_TEXKILL = 65, + D3DSIO_TEX = 66, + D3DSIO_TEXBEM = 67, + D3DSIO_TEXBEML = 68, + D3DSIO_TEXREG2AR = 69, + D3DSIO_TEXREG2GB = 70, + D3DSIO_TEXM3x2PAD = 71, + D3DSIO_TEXM3x2TEX = 72, + D3DSIO_TEXM3x3PAD = 73, + D3DSIO_TEXM3x3TEX = 74, + D3DSIO_TEXM3x3DIFF = 75, + D3DSIO_TEXM3x3SPEC = 76, + D3DSIO_TEXM3x3VSPEC = 77, + D3DSIO_EXPP = 78, + D3DSIO_LOGP = 79, + D3DSIO_CND = 80, + D3DSIO_DEF = 81, + D3DSIO_TEXREG2RGB = 82, + D3DSIO_TEXDP3TEX = 83, + D3DSIO_TEXM3x2DEPTH = 84, + D3DSIO_TEXDP3 = 85, + D3DSIO_TEXM3x3 = 86, + D3DSIO_TEXDEPTH = 87, + D3DSIO_CMP = 88, + D3DSIO_BEM = 89, + + D3DSIO_PHASE = 0xFFFD, + D3DSIO_COMMENT = 0xFFFE, + D3DSIO_END = 0XFFFF, + + D3DSIO_FORCE_DWORD = 0X7FFFFFFF /** for 32-bit alignment */ +} D3DSHADER_INSTRUCTION_OPCODE_TYPE; + +/** for parallelism */ +#define D3DSI_COISSUE 0x40000000 + +/** destination parameter modifiers (.xyzw) */ +#define D3DSP_WRITEMASK_0 0x00010000 /* .x r */ +#define D3DSP_WRITEMASK_1 0x00020000 /* .y g */ +#define D3DSP_WRITEMASK_2 0x00040000 /* .z b */ +#define D3DSP_WRITEMASK_3 0x00080000 /* .w a */ +#define D3DSP_WRITEMASK_ALL 0x000F0000 /* all */ + +#define D3DSP_DSTMOD_SHIFT 20 +#define D3DSP_DSTMOD_MASK (0xF << D3DSP_DSTMOD_SHIFT) + +typedef enum _D3DSHADER_PARAM_DSTMOD_TYPE { + D3DSPDM_NONE = 0 << D3DSP_DSTMOD_SHIFT, + D3DSPDM_SATURATE = 1 << D3DSP_DSTMOD_SHIFT, + D3DSPDM_FORCE_DWORD = 0X7FFFFFFF +} D3DSHADER_PARAM_DSTMOD_TYPE; + +/** destination param */ +#define D3DSP_DSTSHIFT_SHIFT 24 +#define D3DSP_DSTSHIFT_MASK (0xF << D3DSP_DSTSHIFT_SHIFT) + +/** destination/source reg type */ +#define D3DSP_REGTYPE_SHIFT 28 +#define D3DSP_REGTYPE_MASK (0x7 << D3DSP_REGTYPE_SHIFT) + +typedef enum _D3DSHADER_PARAM_REGISTER_TYPE { + D3DSPR_TEMP = 0 << D3DSP_REGTYPE_SHIFT, + D3DSPR_INPUT = 1 << D3DSP_REGTYPE_SHIFT, + D3DSPR_CONST = 2 << D3DSP_REGTYPE_SHIFT, + D3DSPR_ADDR = 3 << D3DSP_REGTYPE_SHIFT, + D3DSPR_TEXTURE = 3 << D3DSP_REGTYPE_SHIFT, + D3DSPR_RASTOUT = 4 << D3DSP_REGTYPE_SHIFT, + D3DSPR_ATTROUT = 5 << D3DSP_REGTYPE_SHIFT, + D3DSPR_TEXCRDOUT = 6 << D3DSP_REGTYPE_SHIFT, + D3DSPR_FORCE_DWORD = 0x7FFFFFFF +} D3DSHADER_PARAM_REGISTER_TYPE; + +typedef enum _D3DVS_RASTOUT_OFFSETS { + D3DSRO_POSITION = 0, + D3DSRO_FOG = 1, + D3DSRO_POINT_SIZE = 2, + D3DSRO_FORCE_DWORD = 0x7FFFFFFF +} D3DVS_RASTOUT_OFFSETS; + +#define D3DVS_ADDRESSMODE_SHIFT 13 +#define D3DVS_ADDRESSMODE_MASK (0x1 << D3DVS_ADDRESSMODE_SHIFT) + +typedef enum _D3DVS_ADDRESSMODE_TYPE { + D3DVS_ADDRMODE_ABSOLUTE = 0 << D3DVS_ADDRESSMODE_SHIFT, + D3DVS_ADDRMODE_RELATIVE = 1 << D3DVS_ADDRESSMODE_SHIFT, + D3DVS_ADDRMODE_FORCE_DWORD = 0x7FFFFFFF +} D3DVS_ADDRESSMODE_TYPE; + +#define D3DVS_SWIZZLE_SHIFT 16 +#define D3DVS_SWIZZLE_MASK (0xFF << D3DVS_SWIZZLE_SHIFT) + +#define D3DSP_SWIZZLE_SHIFT 16 +#define D3DSP_SWIZZLE_MASK (0xFF << D3DSP_SWIZZLE_SHIFT) + +#define D3DVS_X_X (0 << D3DVS_SWIZZLE_SHIFT) +#define D3DVS_X_Y (1 << D3DVS_SWIZZLE_SHIFT) +#define D3DVS_X_Z (2 << D3DVS_SWIZZLE_SHIFT) +#define D3DVS_X_W (3 << D3DVS_SWIZZLE_SHIFT) + +#define D3DVS_Y_X (0 << (D3DVS_SWIZZLE_SHIFT + 2)) +#define D3DVS_Y_Y (1 << (D3DVS_SWIZZLE_SHIFT + 2)) +#define D3DVS_Y_Z (2 << (D3DVS_SWIZZLE_SHIFT + 2)) +#define D3DVS_Y_W (3 << (D3DVS_SWIZZLE_SHIFT + 2)) + +#define D3DVS_Z_X (0 << (D3DVS_SWIZZLE_SHIFT + 4)) +#define D3DVS_Z_Y (1 << (D3DVS_SWIZZLE_SHIFT + 4)) +#define D3DVS_Z_Z (2 << (D3DVS_SWIZZLE_SHIFT + 4)) +#define D3DVS_Z_W (3 << (D3DVS_SWIZZLE_SHIFT + 4)) + +#define D3DVS_W_X (0 << (D3DVS_SWIZZLE_SHIFT + 6)) +#define D3DVS_W_Y (1 << (D3DVS_SWIZZLE_SHIFT + 6)) +#define D3DVS_W_Z (2 << (D3DVS_SWIZZLE_SHIFT + 6)) +#define D3DVS_W_W (3 << (D3DVS_SWIZZLE_SHIFT + 6)) + +#define D3DVS_NOSWIZZLE (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z | D3DVS_W_W) + +#define D3DSP_NOSWIZZLE \ + ((0 << (D3DSP_SWIZZLE_SHIFT + 0)) | (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | (3 << (D3DSP_SWIZZLE_SHIFT + 6))) + +#define D3DSP_SRCMOD_SHIFT 24 +#define D3DSP_SRCMOD_MASK (0xF << D3DSP_SRCMOD_SHIFT) + +typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE { + D3DSPSM_NONE = 0 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_NEG = 1 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_BIAS = 2 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_BIASNEG = 3 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_SIGN = 4 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_SIGNNEG = 5 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_COMP = 6 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_X2 = 7 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_X2NEG = 8 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_DZ = 9 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_DW = 10 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_FORCE_DWORD = 0x7FFFFFFF +} D3DSHADER_PARAM_SRCMOD_TYPE; + +#define D3DPS_VERSION(major, minor) (0xFFFF0000 | ((major) << 8) | (minor)) +#define D3DVS_VERSION(major, minor) (0xFFFE0000 | ((major) << 8) | (minor)) +#define D3DSHADER_VERSION_MAJOR(version) (((version) >> 8) & 0xFF) +#define D3DSHADER_VERSION_MINOR(version) (((version) >> 0) & 0xFF) + +#define D3DSI_COMMENTSIZE_SHIFT 16 +#define D3DSI_COMMENTSIZE_MASK (0x7FFF << D3DSI_COMMENTSIZE_SHIFT) + +#define D3DSHADER_COMMENT(commentSize) \ + ((((commentSize) << D3DSI_COMMENTSIZE_SHIFT) & D3DSI_COMMENTSIZE_MASK) | D3DSIO_COMMENT) + +#define D3DPS_END() 0x0000FFFF +#define D3DVS_END() 0x0000FFFF + + +/***************************************************************************** + * Direct 3D v8 enumerated types + */ +typedef enum _D3DBACKBUFFER_TYPE { + D3DBACKBUFFER_TYPE_MONO = 0, + D3DBACKBUFFER_TYPE_LEFT = 1, + D3DBACKBUFFER_TYPE_RIGHT = 2, + + D3DBACKBUFFER_TYPE_FORCE_DWORD = 0x7fffffff +} D3DBACKBUFFER_TYPE; + +typedef enum _D3DBASISTYPE{ + D3DBASIS_BEZIER = 0, + D3DBASIS_BSPLINE = 1, + D3DBASIS_INTERPOLATE = 2, + + D3DBASIS_FORCE_DWORD = 0x7fffffff +} D3DBASISTYPE; + +typedef enum _D3DBLEND { + D3DBLEND_ZERO = 1, + D3DBLEND_ONE = 2, + D3DBLEND_SRCCOLOR = 3, + D3DBLEND_INVSRCCOLOR = 4, + D3DBLEND_SRCALPHA = 5, + D3DBLEND_INVSRCALPHA = 6, + D3DBLEND_DESTALPHA = 7, + D3DBLEND_INVDESTALPHA = 8, + D3DBLEND_DESTCOLOR = 9, + D3DBLEND_INVDESTCOLOR = 10, + D3DBLEND_SRCALPHASAT = 11, + D3DBLEND_BOTHSRCALPHA = 12, + D3DBLEND_BOTHINVSRCALPHA = 13, + + D3DBLEND_FORCE_DWORD = 0x7fffffff +} D3DBLEND; + +typedef enum _D3DBLENDOP { + D3DBLENDOP_ADD = 1, + D3DBLENDOP_SUBTRACT = 2, + D3DBLENDOP_REVSUBTRACT = 3, + D3DBLENDOP_MIN = 4, + D3DBLENDOP_MAX = 5, + + D3DBLENDOP_FORCE_DWORD = 0x7fffffff +} D3DBLENDOP; + +typedef enum _D3DCMPFUNC { + D3DCMP_NEVER = 1, + D3DCMP_LESS = 2, + D3DCMP_EQUAL = 3, + D3DCMP_LESSEQUAL = 4, + D3DCMP_GREATER = 5, + D3DCMP_NOTEQUAL = 6, + D3DCMP_GREATEREQUAL = 7, + D3DCMP_ALWAYS = 8, + + D3DCMP_FORCE_DWORD = 0x7fffffff +} D3DCMPFUNC; + +typedef enum _D3DCUBEMAP_FACES { + D3DCUBEMAP_FACE_POSITIVE_X = 0, + D3DCUBEMAP_FACE_NEGATIVE_X = 1, + D3DCUBEMAP_FACE_POSITIVE_Y = 2, + D3DCUBEMAP_FACE_NEGATIVE_Y = 3, + D3DCUBEMAP_FACE_POSITIVE_Z = 4, + D3DCUBEMAP_FACE_NEGATIVE_Z = 5, + + D3DCUBEMAP_FACE_FORCE_DWORD = 0xffffffff +} D3DCUBEMAP_FACES; + +typedef enum _D3DCULL { + D3DCULL_NONE = 1, + D3DCULL_CW = 2, + D3DCULL_CCW = 3, + + D3DCULL_FORCE_DWORD = 0x7fffffff +} D3DCULL; + +typedef enum _D3DDEBUGMONITORTOKENS { + D3DDMT_ENABLE = 0, + D3DDMT_DISABLE = 1, + + D3DDMT_FORCE_DWORD = 0x7fffffff +} D3DDEBUGMONITORTOKENS; + +typedef enum _D3DDEVTYPE { + D3DDEVTYPE_HAL = 1, + D3DDEVTYPE_REF = 2, + D3DDEVTYPE_SW = 3, + + D3DDEVTYPE_FORCE_DWORD = 0xffffffff +} D3DDEVTYPE; + +typedef enum _D3DFILLMODE { + D3DFILL_POINT = 1, + D3DFILL_WIREFRAME = 2, + D3DFILL_SOLID = 3, + + D3DFILL_FORCE_DWORD = 0x7fffffff +} D3DFILLMODE; + +typedef enum _D3DFOGMODE { + D3DFOG_NONE = 0, + D3DFOG_EXP = 1, + D3DFOG_EXP2 = 2, + D3DFOG_LINEAR = 3, + + D3DFOG_FORCE_DWORD = 0x7fffffff +} D3DFOGMODE; + +typedef enum _D3DFORMAT { + D3DFMT_UNKNOWN = 0, + + D3DFMT_R8G8B8 = 20, + D3DFMT_A8R8G8B8 = 21, + D3DFMT_X8R8G8B8 = 22, + D3DFMT_R5G6B5 = 23, + D3DFMT_X1R5G5B5 = 24, + D3DFMT_A1R5G5B5 = 25, + D3DFMT_A4R4G4B4 = 26, + D3DFMT_R3G3B2 = 27, + D3DFMT_A8 = 28, + D3DFMT_A8R3G3B2 = 29, + D3DFMT_X4R4G4B4 = 30, + D3DFMT_A2B10G10R10 = 31, + D3DFMT_G16R16 = 34, + + D3DFMT_A8P8 = 40, + D3DFMT_P8 = 41, + + D3DFMT_L8 = 50, + D3DFMT_A8L8 = 51, + D3DFMT_A4L4 = 52, + + D3DFMT_V8U8 = 60, + D3DFMT_L6V5U5 = 61, + D3DFMT_X8L8V8U8 = 62, + D3DFMT_Q8W8V8U8 = 63, + D3DFMT_V16U16 = 64, + D3DFMT_W11V11U10 = 65, + D3DFMT_A2W10V10U10 = 67, + + D3DFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), + D3DFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'), + D3DFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'), + D3DFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'), + D3DFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'), + D3DFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'), + D3DFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'), + + D3DFMT_D16_LOCKABLE = 70, + D3DFMT_D32 = 71, + D3DFMT_D15S1 = 73, + D3DFMT_D24S8 = 75, + D3DFMT_D16 = 80, + D3DFMT_D24X8 = 77, + D3DFMT_D24X4S4 = 79, + + D3DFMT_VERTEXDATA = 100, + D3DFMT_INDEX16 = 101, + D3DFMT_INDEX32 = 102, + + D3DFMT_FORCE_DWORD = 0xFFFFFFFF +} D3DFORMAT; + +typedef enum _D3DLIGHTTYPE { + D3DLIGHT_POINT = 1, + D3DLIGHT_SPOT = 2, + D3DLIGHT_DIRECTIONAL = 3, + + D3DLIGHT_FORCE_DWORD = 0x7fffffff +} D3DLIGHTTYPE; + +typedef enum _D3DMATERIALCOLORSOURCE { + D3DMCS_MATERIAL = 0, + D3DMCS_COLOR1 = 1, + D3DMCS_COLOR2 = 2, + + D3DMCS_FORCE_DWORD = 0x7fffffff +} D3DMATERIALCOLORSOURCE; + +typedef enum _D3DMULTISAMPLE_TYPE { + D3DMULTISAMPLE_NONE = 0, + D3DMULTISAMPLE_2_SAMPLES = 2, + D3DMULTISAMPLE_3_SAMPLES = 3, + D3DMULTISAMPLE_4_SAMPLES = 4, + D3DMULTISAMPLE_5_SAMPLES = 5, + D3DMULTISAMPLE_6_SAMPLES = 6, + D3DMULTISAMPLE_7_SAMPLES = 7, + D3DMULTISAMPLE_8_SAMPLES = 8, + D3DMULTISAMPLE_9_SAMPLES = 9, + D3DMULTISAMPLE_10_SAMPLES = 10, + D3DMULTISAMPLE_11_SAMPLES = 11, + D3DMULTISAMPLE_12_SAMPLES = 12, + D3DMULTISAMPLE_13_SAMPLES = 13, + D3DMULTISAMPLE_14_SAMPLES = 14, + D3DMULTISAMPLE_15_SAMPLES = 15, + D3DMULTISAMPLE_16_SAMPLES = 16, + + D3DMULTISAMPLE_FORCE_DWORD = 0x7fffffff +} D3DMULTISAMPLE_TYPE; + +typedef enum _D3DORDERTYPE { + D3DORDER_LINEAR = 1, + D3DORDER_QUADRATIC = 2, + D3DORDER_CUBIC = 3, + D3DORDER_QUINTIC = 5, + + D3DORDER_FORCE_DWORD = 0x7fffffff +} D3DORDERTYPE; + +typedef enum _D3DPATCHEDGESTYLE { + D3DPATCHEDGE_DISCRETE = 0, + D3DPATCHEDGE_CONTINUOUS = 1, + + D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff, +} D3DPATCHEDGESTYLE; + +typedef enum _D3DPOOL { + D3DPOOL_DEFAULT = 0, + D3DPOOL_MANAGED = 1, + D3DPOOL_SYSTEMMEM = 2, + D3DPOOL_SCRATCH = 3, + + D3DPOOL_FORCE_DWORD = 0x7fffffff +} D3DPOOL; + +typedef enum _D3DPRIMITIVETYPE { + D3DPT_POINTLIST = 1, + D3DPT_LINELIST = 2, + D3DPT_LINESTRIP = 3, + D3DPT_TRIANGLELIST = 4, + D3DPT_TRIANGLESTRIP = 5, + D3DPT_TRIANGLEFAN = 6, + + D3DPT_FORCE_DWORD = 0x7fffffff +} D3DPRIMITIVETYPE; + +typedef enum _D3DRENDERSTATETYPE { + D3DRS_ZENABLE = 7, + D3DRS_FILLMODE = 8, + D3DRS_SHADEMODE = 9, + D3DRS_LINEPATTERN = 10, + D3DRS_ZWRITEENABLE = 14, + D3DRS_ALPHATESTENABLE = 15, + D3DRS_LASTPIXEL = 16, + D3DRS_SRCBLEND = 19, + D3DRS_DESTBLEND = 20, + D3DRS_CULLMODE = 22, + D3DRS_ZFUNC = 23, + D3DRS_ALPHAREF = 24, + D3DRS_ALPHAFUNC = 25, + D3DRS_DITHERENABLE = 26, + D3DRS_ALPHABLENDENABLE = 27, + D3DRS_FOGENABLE = 28, + D3DRS_SPECULARENABLE = 29, + D3DRS_ZVISIBLE = 30, + D3DRS_FOGCOLOR = 34, + D3DRS_FOGTABLEMODE = 35, + D3DRS_FOGSTART = 36, + D3DRS_FOGEND = 37, + D3DRS_FOGDENSITY = 38, + D3DRS_EDGEANTIALIAS = 40, + D3DRS_ZBIAS = 47, + D3DRS_RANGEFOGENABLE = 48, + D3DRS_STENCILENABLE = 52, + D3DRS_STENCILFAIL = 53, + D3DRS_STENCILZFAIL = 54, + D3DRS_STENCILPASS = 55, + D3DRS_STENCILFUNC = 56, + D3DRS_STENCILREF = 57, + D3DRS_STENCILMASK = 58, + D3DRS_STENCILWRITEMASK = 59, + D3DRS_TEXTUREFACTOR = 60, + D3DRS_WRAP0 = 128, + D3DRS_WRAP1 = 129, + D3DRS_WRAP2 = 130, + D3DRS_WRAP3 = 131, + D3DRS_WRAP4 = 132, + D3DRS_WRAP5 = 133, + D3DRS_WRAP6 = 134, + D3DRS_WRAP7 = 135, + D3DRS_CLIPPING = 136, + D3DRS_LIGHTING = 137, + D3DRS_AMBIENT = 139, + D3DRS_FOGVERTEXMODE = 140, + D3DRS_COLORVERTEX = 141, + D3DRS_LOCALVIEWER = 142, + D3DRS_NORMALIZENORMALS = 143, + D3DRS_DIFFUSEMATERIALSOURCE = 145, + D3DRS_SPECULARMATERIALSOURCE = 146, + D3DRS_AMBIENTMATERIALSOURCE = 147, + D3DRS_EMISSIVEMATERIALSOURCE = 148, + D3DRS_VERTEXBLEND = 151, + D3DRS_CLIPPLANEENABLE = 152, + D3DRS_SOFTWAREVERTEXPROCESSING = 153, + D3DRS_POINTSIZE = 154, + D3DRS_POINTSIZE_MIN = 155, + D3DRS_POINTSPRITEENABLE = 156, + D3DRS_POINTSCALEENABLE = 157, + D3DRS_POINTSCALE_A = 158, + D3DRS_POINTSCALE_B = 159, + D3DRS_POINTSCALE_C = 160, + D3DRS_MULTISAMPLEANTIALIAS = 161, + D3DRS_MULTISAMPLEMASK = 162, + D3DRS_PATCHEDGESTYLE = 163, + D3DRS_PATCHSEGMENTS = 164, + D3DRS_DEBUGMONITORTOKEN = 165, + D3DRS_POINTSIZE_MAX = 166, + D3DRS_INDEXEDVERTEXBLENDENABLE = 167, + D3DRS_COLORWRITEENABLE = 168, + D3DRS_TWEENFACTOR = 170, + D3DRS_BLENDOP = 171, + D3DRS_POSITIONORDER = 172, + D3DRS_NORMALORDER = 173, + + D3DRS_FORCE_DWORD = 0x7fffffff +} D3DRENDERSTATETYPE; + +typedef enum _D3DRESOURCETYPE { + D3DRTYPE_SURFACE = 1, + D3DRTYPE_VOLUME = 2, + D3DRTYPE_TEXTURE = 3, + D3DRTYPE_VOLUMETEXTURE = 4, + D3DRTYPE_CUBETEXTURE = 5, + D3DRTYPE_VERTEXBUFFER = 6, + D3DRTYPE_INDEXBUFFER = 7, + + D3DRTYPE_FORCE_DWORD = 0x7fffffff +} D3DRESOURCETYPE; + +typedef enum _D3DSHADEMODE { + D3DSHADE_FLAT = 1, + D3DSHADE_GOURAUD = 2, + D3DSHADE_PHONG = 3, + + D3DSHADE_FORCE_DWORD = 0x7fffffff +} D3DSHADEMODE; + +typedef enum _D3DSTATEBLOCKTYPE { + D3DSBT_ALL = 1, + D3DSBT_PIXELSTATE = 2, + D3DSBT_VERTEXSTATE = 3, + + D3DSBT_FORCE_DWORD = 0xffffffff +} D3DSTATEBLOCKTYPE; + +typedef enum _D3DSTENCILOP { + D3DSTENCILOP_KEEP = 1, + D3DSTENCILOP_ZERO = 2, + D3DSTENCILOP_REPLACE = 3, + D3DSTENCILOP_INCRSAT = 4, + D3DSTENCILOP_DECRSAT = 5, + D3DSTENCILOP_INVERT = 6, + D3DSTENCILOP_INCR = 7, + D3DSTENCILOP_DECR = 8, + + D3DSTENCILOP_FORCE_DWORD = 0x7fffffff +} D3DSTENCILOP; + +typedef enum _D3DSWAPEFFECT { + D3DSWAPEFFECT_DISCARD = 1, + D3DSWAPEFFECT_FLIP = 2, + D3DSWAPEFFECT_COPY = 3, + D3DSWAPEFFECT_COPY_VSYNC = 4, + + D3DSWAPEFFECT_FORCE_DWORD = 0xFFFFFFFF +} D3DSWAPEFFECT; + +typedef enum _D3DTEXTUREADDRESS { + D3DTADDRESS_WRAP = 1, + D3DTADDRESS_MIRROR = 2, + D3DTADDRESS_CLAMP = 3, + D3DTADDRESS_BORDER = 4, + D3DTADDRESS_MIRRORONCE = 5, + + D3DTADDRESS_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREADDRESS; + +typedef enum _D3DTEXTUREFILTERTYPE { + D3DTEXF_NONE = 0, + D3DTEXF_POINT = 1, + D3DTEXF_LINEAR = 2, + D3DTEXF_ANISOTROPIC = 3, + D3DTEXF_FLATCUBIC = 4, + D3DTEXF_GAUSSIANCUBIC = 5, + + D3DTEXF_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREFILTERTYPE; + +typedef enum _D3DTEXTUREOP { + D3DTOP_DISABLE = 1, + D3DTOP_SELECTARG1 = 2, + D3DTOP_SELECTARG2 = 3, + D3DTOP_MODULATE = 4, + D3DTOP_MODULATE2X = 5, + D3DTOP_MODULATE4X = 6, + D3DTOP_ADD = 7, + D3DTOP_ADDSIGNED = 8, + D3DTOP_ADDSIGNED2X = 9, + D3DTOP_SUBTRACT = 10, + D3DTOP_ADDSMOOTH = 11, + D3DTOP_BLENDDIFFUSEALPHA = 12, + D3DTOP_BLENDTEXTUREALPHA = 13, + D3DTOP_BLENDFACTORALPHA = 14, + D3DTOP_BLENDTEXTUREALPHAPM = 15, + D3DTOP_BLENDCURRENTALPHA = 16, + D3DTOP_PREMODULATE = 17, + D3DTOP_MODULATEALPHA_ADDCOLOR = 18, + D3DTOP_MODULATECOLOR_ADDALPHA = 19, + D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, + D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, + D3DTOP_BUMPENVMAP = 22, + D3DTOP_BUMPENVMAPLUMINANCE = 23, + D3DTOP_DOTPRODUCT3 = 24, + D3DTOP_MULTIPLYADD = 25, + D3DTOP_LERP = 26, + + D3DTOP_FORCE_DWORD = 0x7fffffff, +} D3DTEXTUREOP; + +typedef enum _D3DTEXTURESTAGESTATETYPE { + D3DTSS_COLOROP = 1, + D3DTSS_COLORARG1 = 2, + D3DTSS_COLORARG2 = 3, + D3DTSS_ALPHAOP = 4, + D3DTSS_ALPHAARG1 = 5, + D3DTSS_ALPHAARG2 = 6, + D3DTSS_BUMPENVMAT00 = 7, + D3DTSS_BUMPENVMAT01 = 8, + D3DTSS_BUMPENVMAT10 = 9, + D3DTSS_BUMPENVMAT11 = 10, + D3DTSS_TEXCOORDINDEX = 11, + D3DTSS_ADDRESSU = 13, + D3DTSS_ADDRESSV = 14, + D3DTSS_BORDERCOLOR = 15, + D3DTSS_MAGFILTER = 16, + D3DTSS_MINFILTER = 17, + D3DTSS_MIPFILTER = 18, + D3DTSS_MIPMAPLODBIAS = 19, + D3DTSS_MAXMIPLEVEL = 20, + D3DTSS_MAXANISOTROPY = 21, + D3DTSS_BUMPENVLSCALE = 22, + D3DTSS_BUMPENVLOFFSET = 23, + D3DTSS_TEXTURETRANSFORMFLAGS = 24, + D3DTSS_ADDRESSW = 25, + D3DTSS_COLORARG0 = 26, + D3DTSS_ALPHAARG0 = 27, + D3DTSS_RESULTARG = 28, + + D3DTSS_FORCE_DWORD = 0x7fffffff +} D3DTEXTURESTAGESTATETYPE; + +typedef enum _D3DTEXTURETRANSFORMFLAGS { + D3DTTFF_DISABLE = 0, + D3DTTFF_COUNT1 = 1, + D3DTTFF_COUNT2 = 2, + D3DTTFF_COUNT3 = 3, + D3DTTFF_COUNT4 = 4, + D3DTTFF_PROJECTED = 256, + + D3DTTFF_FORCE_DWORD = 0x7fffffff +} D3DTEXTURETRANSFORMFLAGS; + +typedef enum _D3DTRANSFORMSTATETYPE { + D3DTS_VIEW = 2, + D3DTS_PROJECTION = 3, + D3DTS_TEXTURE0 = 16, + D3DTS_TEXTURE1 = 17, + D3DTS_TEXTURE2 = 18, + D3DTS_TEXTURE3 = 19, + D3DTS_TEXTURE4 = 20, + D3DTS_TEXTURE5 = 21, + D3DTS_TEXTURE6 = 22, + D3DTS_TEXTURE7 = 23, + + D3DTS_FORCE_DWORD = 0x7fffffff +} D3DTRANSFORMSTATETYPE; + +typedef enum _D3DVERTEXBLENDFLAGS { + D3DVBF_DISABLE = 0, + D3DVBF_1WEIGHTS = 1, + D3DVBF_2WEIGHTS = 2, + D3DVBF_3WEIGHTS = 3, + D3DVBF_TWEENING = 255, + D3DVBF_0WEIGHTS = 256 +} D3DVERTEXBLENDFLAGS; + +typedef enum _D3DZBUFFERTYPE { + D3DZB_FALSE = 0, + D3DZB_TRUE = 1, + D3DZB_USEW = 2, + + D3DZB_FORCE_DWORD = 0x7fffffff +} D3DZBUFFERTYPE; + + +/***************************************************************************** + * Direct 3D v8 typedefs + */ +typedef DWORD D3DCOLOR; + +/***************************************************************************** + * Direct 3D v8 structures + */ +typedef struct _D3DADAPTER_IDENTIFIER8 { + char Driver[MAX_DEVICE_IDENTIFIER_STRING]; + char Description[MAX_DEVICE_IDENTIFIER_STRING]; + + LARGE_INTEGER DriverVersion; + DWORD VendorId; + DWORD DeviceId; + DWORD SubSysId; + DWORD Revision; + + GUID DeviceIdentifier; + + DWORD WHQLLevel; +} D3DADAPTER_IDENTIFIER8; + +typedef struct _D3DBOX { + UINT Left; + UINT Top; + UINT Right; + UINT Bottom; + UINT Front; + UINT Back; +} D3DBOX; + +typedef struct _D3DCLIPSTATUS8 { + DWORD ClipUnion; + DWORD ClipIntersection; +} D3DCLIPSTATUS8; + +typedef struct _D3DCOLORVALUE { + float r; + float g; + float b; + float a; +} D3DCOLORVALUE; + +typedef struct _D3DDEVICE_CREATION_PARAMETERS { + UINT AdapterOrdinal; + D3DDEVTYPE DeviceType; + HWND hFocusWindow; + DWORD BehaviorFlags; +} D3DDEVICE_CREATION_PARAMETERS; + +typedef struct _D3DDISPLAYMODE { + UINT Width; + UINT Height; + UINT RefreshRate; + D3DFORMAT Format; +} D3DDISPLAYMODE; + +typedef struct _D3DGAMMARAMP { + WORD red [256]; + WORD green[256]; + WORD blue [256]; +} D3DGAMMARAMP; + +typedef struct _D3DINDEXBUFFER_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + UINT Size; +} D3DINDEXBUFFER_DESC; + +#ifndef D3DVECTOR_DEFINED +typedef struct _D3DVECTOR { + float x; + float y; + float z; +} D3DVECTOR; +#define D3DVECTOR_DEFINED +#endif + +typedef struct _D3DLIGHT8 { + D3DLIGHTTYPE Type; + D3DCOLORVALUE Diffuse; + D3DCOLORVALUE Specular; + D3DCOLORVALUE Ambient; + D3DVECTOR Position; + D3DVECTOR Direction; + float Range; + float Falloff; + float Attenuation0; + float Attenuation1; + float Attenuation2; + float Theta; + float Phi; +} D3DLIGHT8; + +typedef struct _D3DLINEPATTERN { + WORD wRepeatFactor; + WORD wLinePattern; +} D3DLINEPATTERN; + +typedef struct _D3DLOCKED_BOX { + INT RowPitch; + INT SlicePitch; + void* pBits; +} D3DLOCKED_BOX; + +typedef struct _D3DLOCKED_RECT { + INT Pitch; + void* pBits; +} D3DLOCKED_RECT; + +typedef struct _D3DMATERIAL8 { + D3DCOLORVALUE Diffuse; + D3DCOLORVALUE Ambient; + D3DCOLORVALUE Specular; + D3DCOLORVALUE Emissive; + float Power; +} D3DMATERIAL8; + +typedef struct _D3DMATRIX { + union { + struct { + float _11, _12, _13, _14; + float _21, _22, _23, _24; + float _31, _32, _33, _34; + float _41, _42, _43, _44; + } DUMMYSTRUCTNAME; + float m[4][4]; + } DUMMYUNIONNAME; +} D3DMATRIX; + +#define D3DPRESENT_RATE_DEFAULT 0 +#define D3DPRESENT_RATE_UNLIMITED 0x7fffffff + +typedef struct _D3DPRESENT_PARAMETERS_ { + UINT BackBufferWidth; + UINT BackBufferHeight; + D3DFORMAT BackBufferFormat; + UINT BackBufferCount; + + D3DMULTISAMPLE_TYPE MultiSampleType; + + D3DSWAPEFFECT SwapEffect; + HWND hDeviceWindow; + BOOL Windowed; + BOOL EnableAutoDepthStencil; + D3DFORMAT AutoDepthStencilFormat; + DWORD Flags; + + UINT FullScreen_RefreshRateInHz; + UINT FullScreen_PresentationInterval; + +} D3DPRESENT_PARAMETERS; + +#define D3DPRESENTFLAG_LOCKABLE_BACKBUFFER 0x00000001 + +typedef struct _D3DRANGE { + UINT Offset; + UINT Size; +} D3DRANGE; + +typedef struct _D3DRASTER_STATUS { + BOOL InVBlank; + UINT ScanLine; +} D3DRASTER_STATUS; + +typedef struct _D3DRECT { + LONG x1; + LONG y1; + LONG x2; + LONG y2; +} D3DRECT; + +typedef struct _D3DRECTPATCH_INFO { + UINT StartVertexOffsetWidth; + UINT StartVertexOffsetHeight; + UINT Width; + UINT Height; + UINT Stride; + D3DBASISTYPE Basis; + D3DORDERTYPE Order; +} D3DRECTPATCH_INFO; + +typedef struct _D3DSURFACE_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + UINT Size; + D3DMULTISAMPLE_TYPE MultiSampleType; + UINT Width; + UINT Height; +} D3DSURFACE_DESC; + +typedef struct _D3DTRIPATCH_INFO { + UINT StartVertexOffset; + UINT NumVertices; + D3DBASISTYPE Basis; + D3DORDERTYPE Order; +} D3DTRIPATCH_INFO; + +typedef struct _D3DVERTEXBUFFER_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + UINT Size; + DWORD FVF; +} D3DVERTEXBUFFER_DESC; + +typedef struct _D3DVIEWPORT8 { + DWORD X; + DWORD Y; + DWORD Width; + DWORD Height; + float MinZ; + float MaxZ; +} D3DVIEWPORT8; + +typedef struct _D3DVOLUME_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + UINT Size; + UINT Width; + UINT Height; + UINT Depth; +} D3DVOLUME_DESC; + +#ifdef __i386__ +#pragma pack(pop) +#endif + +#endif /* __WINE_D3D8TYPES_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3d9.h b/WineFix/lib/d2d1/include/windows/d3d9.h new file mode 100644 index 0000000..dd9f5c1 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d9.h @@ -0,0 +1,2228 @@ +/* + * Copyright (C) 2002-2003 Jason Edmeades + * Raphael Junqueira + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef _D3D9_H_ +#define _D3D9_H_ + +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0900 +#endif + +#include + +#define COM_NO_WINDOWS_H +#include +#include +#include +#include + +/***************************************************************************** + * Behavior Flags for IDirect3D8::CreateDevice + */ +#define D3DCREATE_FPU_PRESERVE __MSABI_LONG(0x00000002) +#define D3DCREATE_MULTITHREADED __MSABI_LONG(0x00000004) +#define D3DCREATE_PUREDEVICE __MSABI_LONG(0x00000010) +#define D3DCREATE_SOFTWARE_VERTEXPROCESSING __MSABI_LONG(0x00000020) +#define D3DCREATE_HARDWARE_VERTEXPROCESSING __MSABI_LONG(0x00000040) +#define D3DCREATE_MIXED_VERTEXPROCESSING __MSABI_LONG(0x00000080) +#define D3DCREATE_DISABLE_DRIVER_MANAGEMENT __MSABI_LONG(0x00000100) +#define D3DCREATE_ADAPTERGROUP_DEVICE __MSABI_LONG(0x00000200) +#define D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX __MSABI_LONG(0x00000400) +#define D3DCREATE_NOWINDOWCHANGES __MSABI_LONG(0x00000800) +#define D3DCREATE_DISABLE_PSGP_THREADING __MSABI_LONG(0x00002000) +#define D3DCREATE_ENABLE_PRESENTSTATS __MSABI_LONG(0x00004000) +#define D3DCREATE_DISABLE_PRINTSCREEN __MSABI_LONG(0x00008000) +#define D3DCREATE_SCREENSAVER __MSABI_LONG(0x10000000) + +/***************************************************************************** + * Flags for SetPrivateData + */ +#define D3DSPD_IUNKNOWN __MSABI_LONG(0x00000001) + + +/***************************************************************************** + * #defines and error codes + */ +#define D3D_SDK_VERSION 32 +#define D3DADAPTER_DEFAULT 0 +#define D3DENUM_WHQL_LEVEL __MSABI_LONG(0x00000002) +#define D3DPRESENT_DONOTWAIT __MSABI_LONG(1) +#define D3DPRESENT_LINEAR_CONTENT __MSABI_LONG(2) +#define D3DPRESENT_BACK_BUFFERS_MAX __MSABI_LONG(3) +#define D3DPRESENT_BACK_BUFFERS_MAX_EX __MSABI_LONG(30) +#define D3DSGR_NO_CALIBRATION __MSABI_LONG(0x00000000) +#define D3DSGR_CALIBRATE __MSABI_LONG(0x00000001) +#define D3DCURSOR_IMMEDIATE_UPDATE __MSABI_LONG(0x00000001) + +#define _FACD3D 0x876 +#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code ) +#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code ) + +/***************************************************************************** + * Direct3D Errors + */ +#define D3D_OK S_OK +#define D3DERR_WRONGTEXTUREFORMAT MAKE_D3DHRESULT(2072) +#define D3DERR_UNSUPPORTEDCOLOROPERATION MAKE_D3DHRESULT(2073) +#define D3DERR_UNSUPPORTEDCOLORARG MAKE_D3DHRESULT(2074) +#define D3DERR_UNSUPPORTEDALPHAOPERATION MAKE_D3DHRESULT(2075) +#define D3DERR_UNSUPPORTEDALPHAARG MAKE_D3DHRESULT(2076) +#define D3DERR_TOOMANYOPERATIONS MAKE_D3DHRESULT(2077) +#define D3DERR_CONFLICTINGTEXTUREFILTER MAKE_D3DHRESULT(2078) +#define D3DERR_UNSUPPORTEDFACTORVALUE MAKE_D3DHRESULT(2079) +#define D3DERR_CONFLICTINGRENDERSTATE MAKE_D3DHRESULT(2081) +#define D3DERR_UNSUPPORTEDTEXTUREFILTER MAKE_D3DHRESULT(2082) +#define D3DERR_CONFLICTINGTEXTUREPALETTE MAKE_D3DHRESULT(2086) +#define D3DERR_DRIVERINTERNALERROR MAKE_D3DHRESULT(2087) +#define D3DERR_NOTFOUND MAKE_D3DHRESULT(2150) +#define D3DERR_MOREDATA MAKE_D3DHRESULT(2151) +#define D3DERR_DEVICELOST MAKE_D3DHRESULT(2152) +#define D3DERR_DEVICENOTRESET MAKE_D3DHRESULT(2153) +#define D3DERR_NOTAVAILABLE MAKE_D3DHRESULT(2154) +#define D3DERR_OUTOFVIDEOMEMORY MAKE_D3DHRESULT(380) +#define D3DERR_INVALIDDEVICE MAKE_D3DHRESULT(2155) +#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156) +#define D3DERR_DRIVERINVALIDCALL MAKE_D3DHRESULT(2157) +#define D3DERR_WASSTILLDRAWING MAKE_D3DHRESULT(540) +#define D3DOK_NOAUTOGEN MAKE_D3DSTATUS(2159) + +#define D3DERR_DEVICEREMOVED MAKE_D3DHRESULT(2160) +#define D3DERR_DEVICEHUNG MAKE_D3DHRESULT(2164) +#define S_NOT_RESIDENT MAKE_D3DSTATUS(2165) +#define S_RESIDENT_IN_SHARED_MEMORY MAKE_D3DSTATUS(2166) +#define S_PRESENT_MODE_CHANGED MAKE_D3DSTATUS(2167) +#define S_PRESENT_OCCLUDED MAKE_D3DSTATUS(2168) +#define D3DERR_UNSUPPORTEDOVERLAY MAKE_D3DHRESULT(2171) +#define D3DERR_UNSUPPORTEDOVERLAYFORMAT MAKE_D3DHRESULT(2172) +#define D3DERR_CANNOTPROTECTCONTENT MAKE_D3DHRESULT(2173) +#define D3DERR_UNSUPPORTEDCRYPTO MAKE_D3DHRESULT(2174) +#define D3DERR_PRESENT_STATISTICS_DISJOINT MAKE_D3DHRESULT(2180) + + +/***************************************************************************** + * Predeclare the interfaces + */ +DEFINE_GUID(IID_IDirect3D9, 0x81BDCBCA, 0x64D4, 0x426D, 0xAE, 0x8D, 0xAD, 0x1, 0x47, 0xF4, 0x27, 0x5C); +typedef struct IDirect3D9 *LPDIRECT3D9, *PDIRECT3D9; + +DEFINE_GUID(IID_IDirect3DDevice9, 0xd0223b96, 0xbf7a, 0x43fd, 0x92, 0xbd, 0xa4, 0x3b, 0xd, 0x82, 0xb9, 0xeb); +typedef struct IDirect3DDevice9 *LPDIRECT3DDEVICE9; + +DEFINE_GUID(IID_IDirect3DResource9, 0x5eec05d, 0x8f7d, 0x4362, 0xb9, 0x99, 0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x4); +typedef struct IDirect3DResource9 *LPDIRECT3DRESOURCE9, *PDIRECT3DRESOURCE9; + +DEFINE_GUID(IID_IDirect3DVertexBuffer9, 0xb64bb1b5, 0xfd70, 0x4df6, 0xbf, 0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3); +typedef struct IDirect3DVertexBuffer9 *LPDIRECT3DVERTEXBUFFER9, *PDIRECT3DVERTEXBUFFER9; + +DEFINE_GUID(IID_IDirect3DVolume9, 0x24f416e6, 0x1f67, 0x4aa7, 0xb8, 0x8e, 0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1); +typedef struct IDirect3DVolume9 *LPDIRECT3DVOLUME9, *PDIRECT3DVOLUME9; + +DEFINE_GUID(IID_IDirect3DSwapChain9, 0x794950f2, 0xadfc, 0x458a, 0x90, 0x5e, 0x10, 0xa1, 0xb, 0xb, 0x50, 0x3b); +typedef struct IDirect3DSwapChain9 *LPDIRECT3DSWAPCHAIN9, *PDIRECT3DSWAPCHAIN9; + +DEFINE_GUID(IID_IDirect3DSurface9, 0xcfbaf3a, 0x9ff6, 0x429a, 0x99, 0xb3, 0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b); +typedef struct IDirect3DSurface9 *LPDIRECT3DSURFACE9, *PDIRECT3DSURFACE9; + +DEFINE_GUID(IID_IDirect3DIndexBuffer9, 0x7c9dd65e, 0xd3f7, 0x4529, 0xac, 0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35); +typedef struct IDirect3DIndexBuffer9 *LPDIRECT3DINDEXBUFFER9, *PDIRECT3DINDEXBUFFER9; + +DEFINE_GUID(IID_IDirect3DBaseTexture9, 0x580ca87e, 0x1d3c, 0x4d54, 0x99, 0x1d, 0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce); +typedef struct IDirect3DBaseTexture9 *LPDIRECT3DBASETEXTURE9, *PDIRECT3DBASETEXTURE9; + +DEFINE_GUID(IID_IDirect3DTexture9, 0x85c31227, 0x3de5, 0x4f00, 0x9b, 0x3a, 0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5); +typedef struct IDirect3DTexture9 *LPDIRECT3DTEXTURE9, *PDIRECT3DTEXTURE9; + +DEFINE_GUID(IID_IDirect3DCubeTexture9, 0xfff32f81, 0xd953, 0x473a, 0x92, 0x23, 0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f); +typedef struct IDirect3DCubeTexture9 *LPDIRECT3DCUBETEXTURE9, *PDIRECT3DCUBETEXTURE9; + +DEFINE_GUID(IID_IDirect3DVolumeTexture9, 0x2518526c, 0xe789, 0x4111, 0xa7, 0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6); +typedef struct IDirect3DVolumeTexture9 *LPDIRECT3DVOLUMETEXTURE9, *PDIRECT3DVOLUMETEXTURE9; + +DEFINE_GUID(IID_IDirect3DVertexDeclaration9, 0xdd13c59c, 0x36fa, 0x4098, 0xa8, 0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46); +typedef struct IDirect3DVertexDeclaration9 *LPDIRECT3DVERTEXDECLARATION9; + +DEFINE_GUID(IID_IDirect3DVertexShader9, 0xefc5557e, 0x6265, 0x4613, 0x8a, 0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36); +typedef struct IDirect3DVertexShader9 *LPDIRECT3DVERTEXSHADER9; + +DEFINE_GUID(IID_IDirect3DPixelShader9, 0x6d3bdbdc, 0x5b02, 0x4415, 0xb8, 0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89); +typedef struct IDirect3DPixelShader9 *LPDIRECT3DPIXELSHADER9; + +DEFINE_GUID(IID_IDirect3DStateBlock9, 0xb07c4fe5, 0x310d, 0x4ba8, 0xa2, 0x3c, 0x4f, 0xf, 0x20, 0x6f, 0x21, 0x8b); +typedef struct IDirect3DStateBlock9 *LPDIRECT3DSTATEBLOCK9; + +DEFINE_GUID(IID_IDirect3DQuery9, 0xd9771460, 0xa695, 0x4f26, 0xbb, 0xd3, 0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc); +typedef struct IDirect3DQuery9 *LPDIRECT3DQUERY9, *PDIRECT3DQUERY9; + +/***************************************************************************** + * IDirect3D9 interface + */ +#undef INTERFACE +#define INTERFACE IDirect3D9 +DECLARE_INTERFACE_IID_(IDirect3D9,IUnknown,"81bdcbca-64d4-426d-ae8d-ad0147f4275c") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3D9 methods ***/ + STDMETHOD(RegisterSoftwareDevice)(THIS_ void* pInitializeFunction) PURE; + STDMETHOD_(UINT, GetAdapterCount)(THIS) PURE; + STDMETHOD(GetAdapterIdentifier)(THIS_ UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier) PURE; + STDMETHOD_(UINT, GetAdapterModeCount)(THIS_ UINT Adapter, D3DFORMAT Format) PURE; + STDMETHOD(EnumAdapterModes)(THIS_ UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE* pMode) PURE; + STDMETHOD(GetAdapterDisplayMode)(THIS_ UINT Adapter, D3DDISPLAYMODE* pMode) PURE; + STDMETHOD(CheckDeviceType)(THIS_ UINT iAdapter, D3DDEVTYPE DevType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL bWindowed) PURE; + STDMETHOD(CheckDeviceFormat)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) PURE; + STDMETHOD(CheckDeviceMultiSampleType)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) PURE; + STDMETHOD(CheckDepthStencilMatch)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) PURE; + STDMETHOD(CheckDeviceFormatConversion)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) PURE; + STDMETHOD(GetDeviceCaps)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps) PURE; + STDMETHOD_(HMONITOR, GetAdapterMonitor)(THIS_ UINT Adapter) PURE; + STDMETHOD(CreateDevice)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, struct IDirect3DDevice9** ppReturnedDeviceInterface) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3D9, 0x81BDCBCA, 0x64D4, 0x426D, 0xAE, 0x8D, 0xAD, 0x1, 0x47, 0xF4, 0x27, 0x5C); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3D9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3D9 methods ***/ +#define IDirect3D9_RegisterSoftwareDevice(p,a) (p)->lpVtbl->RegisterSoftwareDevice(p,a) +#define IDirect3D9_GetAdapterCount(p) (p)->lpVtbl->GetAdapterCount(p) +#define IDirect3D9_GetAdapterIdentifier(p,a,b,c) (p)->lpVtbl->GetAdapterIdentifier(p,a,b,c) +#define IDirect3D9_GetAdapterModeCount(p,a,b) (p)->lpVtbl->GetAdapterModeCount(p,a,b) +#define IDirect3D9_EnumAdapterModes(p,a,b,c,d) (p)->lpVtbl->EnumAdapterModes(p,a,b,c,d) +#define IDirect3D9_GetAdapterDisplayMode(p,a,b) (p)->lpVtbl->GetAdapterDisplayMode(p,a,b) +#define IDirect3D9_CheckDeviceType(p,a,b,c,d,e) (p)->lpVtbl->CheckDeviceType(p,a,b,c,d,e) +#define IDirect3D9_CheckDeviceFormat(p,a,b,c,d,e,f) (p)->lpVtbl->CheckDeviceFormat(p,a,b,c,d,e,f) +#define IDirect3D9_CheckDeviceMultiSampleType(p,a,b,c,d,e,f) (p)->lpVtbl->CheckDeviceMultiSampleType(p,a,b,c,d,e,f) +#define IDirect3D9_CheckDepthStencilMatch(p,a,b,c,d,e) (p)->lpVtbl->CheckDepthStencilMatch(p,a,b,c,d,e) +#define IDirect3D9_CheckDeviceFormatConversion(p,a,b,c,d) (p)->lpVtbl->CheckDeviceFormatConversion(p,a,b,c,d) +#define IDirect3D9_GetDeviceCaps(p,a,b,c) (p)->lpVtbl->GetDeviceCaps(p,a,b,c) +#define IDirect3D9_GetAdapterMonitor(p,a) (p)->lpVtbl->GetAdapterMonitor(p,a) +#define IDirect3D9_CreateDevice(p,a,b,c,d,e,f) (p)->lpVtbl->CreateDevice(p,a,b,c,d,e,f) +#else +/*** IUnknown methods ***/ +#define IDirect3D9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D9_AddRef(p) (p)->AddRef() +#define IDirect3D9_Release(p) (p)->Release() +/*** IDirect3D9 methods ***/ +#define IDirect3D9_RegisterSoftwareDevice(p,a) (p)->RegisterSoftwareDevice(a) +#define IDirect3D9_GetAdapterCount(p) (p)->GetAdapterCount() +#define IDirect3D9_GetAdapterIdentifier(p,a,b,c) (p)->GetAdapterIdentifier(a,b,c) +#define IDirect3D9_GetAdapterModeCount(p,a,b) (p)->GetAdapterModeCount(a,b) +#define IDirect3D9_EnumAdapterModes(p,a,b,c,d) (p)->EnumAdapterModes(a,b,c,d) +#define IDirect3D9_GetAdapterDisplayMode(p,a,b) (p)->GetAdapterDisplayMode(a,b) +#define IDirect3D9_CheckDeviceType(p,a,b,c,d,e) (p)->CheckDeviceType(a,b,c,d,e) +#define IDirect3D9_CheckDeviceFormat(p,a,b,c,d,e,f) (p)->CheckDeviceFormat(a,b,c,d,e,f) +#define IDirect3D9_CheckDeviceMultiSampleType(p,a,b,c,d,e,f) (p)->CheckDeviceMultiSampleType(a,b,c,d,e,f) +#define IDirect3D9_CheckDepthStencilMatch(p,a,b,c,d,e) (p)->CheckDepthStencilMatch(a,b,c,d,e) +#define IDirect3D9_CheckDeviceFormatConversion(p,a,b,c,d) (p)->CheckDeviceFormatConversion(a,b,c,d) +#define IDirect3D9_GetDeviceCaps(p,a,b,c) (p)->GetDeviceCaps(a,b,c) +#define IDirect3D9_GetAdapterMonitor(p,a) (p)->GetAdapterMonitor(a) +#define IDirect3D9_CreateDevice(p,a,b,c,d,e,f) (p)->CreateDevice(a,b,c,d,e,f) +#endif + +/***************************************************************************** + * IDirect3DVolume9 interface + */ +#define INTERFACE IDirect3DVolume9 +DECLARE_INTERFACE_IID_(IDirect3DVolume9,IUnknown,"24f416e6-1f67-4aa7-b88e-d33f6f3128a1") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DVolume9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD(GetContainer)(THIS_ REFIID riid, void** ppContainer) PURE; + STDMETHOD(GetDesc)(THIS_ D3DVOLUME_DESC* pDesc) PURE; + STDMETHOD(LockBox)(THIS_ D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) PURE; + STDMETHOD(UnlockBox)(THIS) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DVolume9, 0x24f416e6, 0x1f67, 0x4aa7, 0xb8, 0x8e, 0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVolume9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVolume9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVolume9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVolume9 methods ***/ +#define IDirect3DVolume9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVolume9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DVolume9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DVolume9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DVolume9_GetContainer(p,a,b) (p)->lpVtbl->GetContainer(p,a,b) +#define IDirect3DVolume9_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define IDirect3DVolume9_LockBox(p,a,b,c) (p)->lpVtbl->LockBox(p,a,b,c) +#define IDirect3DVolume9_UnlockBox(p) (p)->lpVtbl->UnlockBox(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DVolume9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVolume9_AddRef(p) (p)->AddRef() +#define IDirect3DVolume9_Release(p) (p)->Release() +/*** IDirect3DVolume9 methods ***/ +#define IDirect3DVolume9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVolume9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DVolume9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DVolume9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DVolume9_GetContainer(p,a,b) (p)->GetContainer(a,b) +#define IDirect3DVolume9_GetDesc(p,a) (p)->GetDesc(a) +#define IDirect3DVolume9_LockBox(p,a,b,c) (p)->LockBox(a,b,c) +#define IDirect3DVolume9_UnlockBox(p) (p)->UnlockBox() +#endif + +/***************************************************************************** + * IDirect3DSwapChain9 interface + */ +#define INTERFACE IDirect3DSwapChain9 +DECLARE_INTERFACE_IID_(IDirect3DSwapChain9,IUnknown,"794950f2-adfc-458a-905e-10a10b0b503b") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void **ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DSwapChain9 methods ***/ + STDMETHOD(Present)(THIS_ const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region, DWORD flags) PURE; + STDMETHOD(GetFrontBufferData)(THIS_ struct IDirect3DSurface9 *pDestSurface) PURE; + STDMETHOD(GetBackBuffer)(THIS_ UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, struct IDirect3DSurface9 **ppBackBuffer) PURE; + STDMETHOD(GetRasterStatus)(THIS_ D3DRASTER_STATUS *pRasterStatus) PURE; + STDMETHOD(GetDisplayMode)(THIS_ D3DDISPLAYMODE *pMode) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **ppDevice) PURE; + STDMETHOD(GetPresentParameters)(THIS_ D3DPRESENT_PARAMETERS *pPresentationParameters) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DSwapChain9, 0x794950f2, 0xadfc, 0x458a, 0x90, 0x5e, 0x10, 0xa1, 0xb, 0xb, 0x50, 0x3b); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DSwapChain9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DSwapChain9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DSwapChain9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DSwapChain9 methods ***/ +#define IDirect3DSwapChain9_Present(p,a,b,c,d,e) (p)->lpVtbl->Present(p,a,b,c,d,e) +#define IDirect3DSwapChain9_GetFrontBufferData(p,a) (p)->lpVtbl->GetFrontBufferData(p,a) +#define IDirect3DSwapChain9_GetBackBuffer(p,a,b,c) (p)->lpVtbl->GetBackBuffer(p,a,b,c) +#define IDirect3DSwapChain9_GetRasterStatus(p,a) (p)->lpVtbl->GetRasterStatus(p,a) +#define IDirect3DSwapChain9_GetDisplayMode(p,a) (p)->lpVtbl->GetDisplayMode(p,a) +#define IDirect3DSwapChain9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DSwapChain9_GetPresentParameters(p,a) (p)->lpVtbl->GetPresentParameters(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DSwapChain9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DSwapChain9_AddRef(p) (p)->AddRef() +#define IDirect3DSwapChain9_Release(p) (p)->Release() +/*** IDirect3DSwapChain9 methods ***/ +#define IDirect3DSwapChain9_Present(p,a,b,c,d,e) (p)->Present(a,b,c,d,e) +#define IDirect3DSwapChain9_GetFrontBufferData(p,a) (p)->GetFrontBufferData(a) +#define IDirect3DSwapChain9_GetBackBuffer(p,a,b,c) (p)->GetBackBuffer(a,b,c) +#define IDirect3DSwapChain9_GetRasterStatus(p,a) (p)->GetRasterStatus(a) +#define IDirect3DSwapChain9_GetDisplayMode(p,a) (p)->GetDisplayMode(a) +#define IDirect3DSwapChain9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DSwapChain9_GetPresentParameters(p,a) (p)->GetPresentParameters(a) +#endif + +/***************************************************************************** + * IDirect3DResource9 interface + */ +#define INTERFACE IDirect3DResource9 +DECLARE_INTERFACE_IID_(IDirect3DResource9,IUnknown,"05eec05d-8f7d-4362-b999-d1baf357c704") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DResource9, 0x5eec05d, 0x8f7d, 0x4362, 0xb9, 0x99, 0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x4); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DResource9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DResource9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DResource9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DResource9 methods ***/ +#define IDirect3DResource9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DResource9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DResource9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DResource9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DResource9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DResource9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DResource9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DResource9_GetType(p) (p)->lpVtbl->GetType(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DResource9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DResource9_AddRef(p) (p)->AddRef() +#define IDirect3DResource9_Release(p) (p)->Release() +/*** IDirect3DResource9 methods ***/ +#define IDirect3DResource9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DResource9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DResource9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DResource9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DResource9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DResource9_GetPriority(p) (p)->GetPriority() +#define IDirect3DResource9_PreLoad(p) (p)->PreLoad() +#define IDirect3DResource9_GetType(p) (p)->GetType() +#endif + +/***************************************************************************** + * IDirect3DSurface9 interface + */ +#define INTERFACE IDirect3DSurface9 +DECLARE_INTERFACE_IID_(IDirect3DSurface9,IDirect3DResource9,"0cfbaf3a-9ff6-429a-99b3-a2796af8b89b") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DSurface9 methods ***/ + STDMETHOD(GetContainer)(THIS_ REFIID riid, void** ppContainer) PURE; + STDMETHOD(GetDesc)(THIS_ D3DSURFACE_DESC* pDesc) PURE; + STDMETHOD(LockRect)(THIS_ D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) PURE; + STDMETHOD(UnlockRect)(THIS) PURE; + STDMETHOD(GetDC)(THIS_ HDC* phdc) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC hdc) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DSurface9, 0xcfbaf3a, 0x9ff6, 0x429a, 0x99, 0xb3, 0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DSurface9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DSurface9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DSurface9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DSurface9 methods: IDirect3DResource9 ***/ +#define IDirect3DSurface9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DSurface9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DSurface9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DSurface9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DSurface9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DSurface9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DSurface9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DSurface9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DSurface9 methods ***/ +#define IDirect3DSurface9_GetContainer(p,a,b) (p)->lpVtbl->GetContainer(p,a,b) +#define IDirect3DSurface9_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define IDirect3DSurface9_LockRect(p,a,b,c) (p)->lpVtbl->LockRect(p,a,b,c) +#define IDirect3DSurface9_UnlockRect(p) (p)->lpVtbl->UnlockRect(p) +#define IDirect3DSurface9_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirect3DSurface9_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DSurface9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DSurface9_AddRef(p) (p)->AddRef() +#define IDirect3DSurface9_Release(p) (p)->Release() +/*** IDirect3DSurface9 methods: IDirect3DResource9 ***/ +#define IDirect3DSurface9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DSurface9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DSurface9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DSurface9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DSurface9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DSurface9_GetPriority(p) (p)->GetPriority() +#define IDirect3DSurface9_PreLoad(p) (p)->PreLoad() +#define IDirect3DSurface9_GetType(p) (p)->GetType() +/*** IDirect3DSurface9 methods ***/ +#define IDirect3DSurface9_GetContainer(p,a,b) (p)->GetContainer(a,b) +#define IDirect3DSurface9_GetDesc(p,a) (p)->GetDesc(a) +#define IDirect3DSurface9_LockRect(p,a,b,c) (p)->LockRect(a,b,c) +#define IDirect3DSurface9_UnlockRect(p) (p)->UnlockRect() +#define IDirect3DSurface9_GetDC(p,a) (p)->GetDC(a) +#define IDirect3DSurface9_ReleaseDC(p,a) (p)->ReleaseDC(a) +#endif + +/***************************************************************************** + * IDirect3DVertexBuffer9 interface + */ +#define INTERFACE IDirect3DVertexBuffer9 +DECLARE_INTERFACE_IID_(IDirect3DVertexBuffer9,IDirect3DResource9,"b64bb1b5-fd70-4df6-bf91-19d0a12455e3") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DVertexBuffer9 methods ***/ + STDMETHOD(Lock)(THIS_ UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(GetDesc)(THIS_ D3DVERTEXBUFFER_DESC* pDesc) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DVertexBuffer9, 0xb64bb1b5, 0xfd70, 0x4df6, 0xbf, 0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexBuffer9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexBuffer9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVertexBuffer9 methods: IDirect3DResource9 ***/ +#define IDirect3DVertexBuffer9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVertexBuffer9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DVertexBuffer9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DVertexBuffer9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DVertexBuffer9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DVertexBuffer9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DVertexBuffer9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DVertexBuffer9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DVertexBuffer9 methods ***/ +#define IDirect3DVertexBuffer9_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirect3DVertexBuffer9_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DVertexBuffer9_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DVertexBuffer9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexBuffer9_AddRef(p) (p)->AddRef() +#define IDirect3DVertexBuffer9_Release(p) (p)->Release() +/*** IDirect3DVertexBuffer9 methods: IDirect3DResource9 ***/ +#define IDirect3DVertexBuffer9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVertexBuffer9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DVertexBuffer9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DVertexBuffer9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DVertexBuffer9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DVertexBuffer9_GetPriority(p) (p)->GetPriority() +#define IDirect3DVertexBuffer9_PreLoad(p) (p)->PreLoad() +#define IDirect3DVertexBuffer9_GetType(p) (p)->GetType() +/*** IDirect3DVertexBuffer9 methods ***/ +#define IDirect3DVertexBuffer9_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirect3DVertexBuffer9_Unlock(p) (p)->Unlock() +#define IDirect3DVertexBuffer9_GetDesc(p,a) (p)->GetDesc(a) +#endif + +/***************************************************************************** + * IDirect3DIndexBuffer9 interface + */ +#define INTERFACE IDirect3DIndexBuffer9 +DECLARE_INTERFACE_IID_(IDirect3DIndexBuffer9,IDirect3DResource9,"7c9dd65e-d3f7-4529-acee-785830acde35") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DIndexBuffer9 methods ***/ + STDMETHOD(Lock)(THIS_ UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(GetDesc)(THIS_ D3DINDEXBUFFER_DESC* pDesc) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DIndexBuffer9, 0x7c9dd65e, 0xd3f7, 0x4529, 0xac, 0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DIndexBuffer9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DIndexBuffer9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DIndexBuffer9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DIndexBuffer9 methods: IDirect3DResource9 ***/ +#define IDirect3DIndexBuffer9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DIndexBuffer9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DIndexBuffer9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DIndexBuffer9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DIndexBuffer9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DIndexBuffer9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DIndexBuffer9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DIndexBuffer9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DIndexBuffer9 methods ***/ +#define IDirect3DIndexBuffer9_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirect3DIndexBuffer9_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DIndexBuffer9_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DIndexBuffer9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DIndexBuffer9_AddRef(p) (p)->AddRef() +#define IDirect3DIndexBuffer9_Release(p) (p)->Release() +/*** IDirect3DIndexBuffer9 methods: IDirect3DResource9 ***/ +#define IDirect3DIndexBuffer9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DIndexBuffer9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DIndexBuffer9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DIndexBuffer9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DIndexBuffer9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DIndexBuffer9_GetPriority(p) (p)->GetPriority() +#define IDirect3DIndexBuffer9_PreLoad(p) (p)->PreLoad() +#define IDirect3DIndexBuffer9_GetType(p) (p)->GetType() +/*** IDirect3DIndexBuffer9 methods ***/ +#define IDirect3DIndexBuffer9_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirect3DIndexBuffer9_Unlock(p) (p)->Unlock() +#define IDirect3DIndexBuffer9_GetDesc(p,a) (p)->GetDesc(a) +#endif + +/***************************************************************************** + * IDirect3DBaseTexture9 interface + */ +#define INTERFACE IDirect3DBaseTexture9 +DECLARE_INTERFACE_IID_(IDirect3DBaseTexture9,IDirect3DResource9,"580ca87e-1d3c-4d54-991d-b7d3e3c298ce") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DBaseTexture9 methods ***/ + STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD, GetLOD)(THIS) PURE; + STDMETHOD_(DWORD, GetLevelCount)(THIS) PURE; + STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType) PURE; + STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS) PURE; + STDMETHOD_(void, GenerateMipSubLevels)(THIS) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DBaseTexture9, 0x580ca87e, 0x1d3c, 0x4d54, 0x99, 0x1d, 0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DBaseTexture9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DBaseTexture9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DBaseTexture9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DBaseTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DBaseTexture9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DBaseTexture9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DBaseTexture9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DBaseTexture9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DBaseTexture9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DBaseTexture9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DBaseTexture9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DBaseTexture9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DBaseTexture9 methods ***/ +#define IDirect3DBaseTexture9_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DBaseTexture9_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DBaseTexture9_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +#define IDirect3DBaseTexture9_SetAutoGenFilterType(p,a) (p)->lpVtbl->SetAutoGenFilterType(p,a) +#define IDirect3DBaseTexture9_GetAutoGenFilterType(p) (p)->lpVtbl->GetAutoGenFilterType(p) +#define IDirect3DBaseTexture9_GenerateMipSubLevels(p) (p)->lpVtbl->GenerateMipSubLevels(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DBaseTexture9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DBaseTexture9_AddRef(p) (p)->AddRef() +#define IDirect3DBaseTexture9_Release(p) (p)->Release() +/*** IDirect3DBaseTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DBaseTexture9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DBaseTexture9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DBaseTexture9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DBaseTexture9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DBaseTexture9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DBaseTexture9_GetPriority(p) (p)->GetPriority() +#define IDirect3DBaseTexture9_PreLoad(p) (p)->PreLoad() +#define IDirect3DBaseTexture9_GetType(p) (p)->GetType() +/*** IDirect3DBaseTexture9 methods ***/ +#define IDirect3DBaseTexture9_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DBaseTexture9_GetLOD(p) (p)->GetLOD() +#define IDirect3DBaseTexture9_GetLevelCount(p) (p)->GetLevelCount() +#define IDirect3DBaseTexture9_SetAutoGenFilterType(p,a) (p)->SetAutoGenFilterType(a) +#define IDirect3DBaseTexture9_GetAutoGenFilterType(p) (p)->GetAutoGenFilterType() +#define IDirect3DBaseTexture9_GenerateMipSubLevels(p) (p)->GenerateMipSubLevels() +#endif + +/***************************************************************************** + * IDirect3DCubeTexture9 interface + */ +#define INTERFACE IDirect3DCubeTexture9 +DECLARE_INTERFACE_IID_(IDirect3DCubeTexture9,IDirect3DBaseTexture9,"fff32f81-d953-473a-9223-93d652aba93f") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DBaseTexture9 methods ***/ + STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD, GetLOD)(THIS) PURE; + STDMETHOD_(DWORD, GetLevelCount)(THIS) PURE; + STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType) PURE; + STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS) PURE; + STDMETHOD_(void, GenerateMipSubLevels)(THIS) PURE; + /*** IDirect3DCubeTexture9 methods ***/ + STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DSURFACE_DESC* pDesc) PURE; + STDMETHOD(GetCubeMapSurface)(THIS_ D3DCUBEMAP_FACES FaceType, UINT Level, IDirect3DSurface9** ppCubeMapSurface) PURE; + STDMETHOD(LockRect)(THIS_ D3DCUBEMAP_FACES face, UINT level, + D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) PURE; + STDMETHOD(UnlockRect)(THIS_ D3DCUBEMAP_FACES FaceType, UINT Level) PURE; + STDMETHOD(AddDirtyRect)(THIS_ D3DCUBEMAP_FACES face, const RECT *dirty_rect) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DCubeTexture9, 0xfff32f81, 0xd953, 0x473a, 0x92, 0x23, 0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DCubeTexture9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DCubeTexture9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DCubeTexture9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DCubeTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DCubeTexture9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DCubeTexture9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DCubeTexture9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DCubeTexture9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DCubeTexture9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DCubeTexture9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DCubeTexture9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DCubeTexture9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DCubeTexture9 methods: IDirect3DBaseTexture9 ***/ +#define IDirect3DCubeTexture9_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DCubeTexture9_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DCubeTexture9_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +#define IDirect3DCubeTexture9_SetAutoGenFilterType(p,a) (p)->lpVtbl->SetAutoGenFilterType(p,a) +#define IDirect3DCubeTexture9_GetAutoGenFilterType(p) (p)->lpVtbl->GetAutoGenFilterType(p) +#define IDirect3DCubeTexture9_GenerateMipSubLevels(p) (p)->lpVtbl->GenerateMipSubLevels(p) +/*** IDirect3DCubeTexture9 methods ***/ +#define IDirect3DCubeTexture9_GetLevelDesc(p,a,b) (p)->lpVtbl->GetLevelDesc(p,a,b) +#define IDirect3DCubeTexture9_GetCubeMapSurface(p,a,b,c) (p)->lpVtbl->GetCubeMapSurface(p,a,b,c) +#define IDirect3DCubeTexture9_LockRect(p,a,b,c,d,e) (p)->lpVtbl->LockRect(p,a,b,c,d,e) +#define IDirect3DCubeTexture9_UnlockRect(p,a,b) (p)->lpVtbl->UnlockRect(p,a,b) +#define IDirect3DCubeTexture9_AddDirtyRect(p,a,b) (p)->lpVtbl->AddDirtyRect(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DCubeTexture9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DCubeTexture9_AddRef(p) (p)->AddRef() +#define IDirect3DCubeTexture9_Release(p) (p)->Release() +/*** IDirect3DCubeTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DCubeTexture9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DCubeTexture9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DCubeTexture9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DCubeTexture9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DCubeTexture9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DCubeTexture9_GetPriority(p) (p)->GetPriority() +#define IDirect3DCubeTexture9_PreLoad(p) (p)->PreLoad() +#define IDirect3DCubeTexture9_GetType(p) (p)->GetType() +/*** IDirect3DCubeTexture9 methods: IDirect3DBaseTexture9 ***/ +#define IDirect3DCubeTexture9_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DCubeTexture9_GetLOD(p) (p)->GetLOD() +#define IDirect3DCubeTexture9_GetLevelCount(p) (p)->GetLevelCount() +#define IDirect3DCubeTexture9_SetAutoGenFilterType(p,a) (p)->SetAutoGenFilterType(a) +#define IDirect3DCubeTexture9_GetAutoGenFilterType(p) (p)->GetAutoGenFilterType() +#define IDirect3DCubeTexture9_GenerateMipSubLevels(p) (p)->GenerateMipSubLevels() +/*** IDirect3DCubeTexture9 methods ***/ +#define IDirect3DCubeTexture9_GetLevelDesc(p,a,b) (p)->GetLevelDesc(a,b) +#define IDirect3DCubeTexture9_GetCubeMapSurface(p,a,b,c) (p)->GetCubeMapSurface(a,b,c) +#define IDirect3DCubeTexture9_LockRect(p,a,b,c,d,e) (p)->LockRect(a,b,c,d,e) +#define IDirect3DCubeTexture9_UnlockRect(p,a,b) (p)->UnlockRect(a,b) +#define IDirect3DCubeTexture9_AddDirtyRect(p,a,b) (p)->AddDirtyRect(a,b) +#endif + +/***************************************************************************** + * IDirect3DTexture9 interface + */ +#define INTERFACE IDirect3DTexture9 +DECLARE_INTERFACE_IID_(IDirect3DTexture9,IDirect3DBaseTexture9,"85c31227-3de5-4f00-9b3a-f11ac38c18b5") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DBaseTexture9 methods ***/ + STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD, GetLOD)(THIS) PURE; + STDMETHOD_(DWORD, GetLevelCount)(THIS) PURE; + STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType) PURE; + STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS) PURE; + STDMETHOD_(void, GenerateMipSubLevels)(THIS) PURE; + /*** IDirect3DTexture9 methods ***/ + STDMETHOD(GetLevelDesc)(THIS_ UINT Level, D3DSURFACE_DESC* pDesc) PURE; + STDMETHOD(GetSurfaceLevel)(THIS_ UINT Level, IDirect3DSurface9** ppSurfaceLevel) PURE; + STDMETHOD(LockRect)(THIS_ UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) PURE; + STDMETHOD(UnlockRect)(THIS_ UINT Level) PURE; + STDMETHOD(AddDirtyRect)(THIS_ const RECT *dirty_rect) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DTexture9, 0x85c31227, 0x3de5, 0x4f00, 0x9b, 0x3a, 0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DTexture9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DTexture9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DTexture9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DTexture9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DTexture9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DTexture9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DTexture9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DTexture9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DTexture9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DTexture9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DTexture9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DTexture9 methods: IDirect3DBaseTexture9 ***/ +#define IDirect3DTexture9_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DTexture9_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DTexture9_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +#define IDirect3DTexture9_SetAutoGenFilterType(p,a) (p)->lpVtbl->SetAutoGenFilterType(p,a) +#define IDirect3DTexture9_GetAutoGenFilterType(p) (p)->lpVtbl->GetAutoGenFilterType(p) +#define IDirect3DTexture9_GenerateMipSubLevels(p) (p)->lpVtbl->GenerateMipSubLevels(p) +/*** IDirect3DTexture9 methods ***/ +#define IDirect3DTexture9_GetLevelDesc(p,a,b) (p)->lpVtbl->GetLevelDesc(p,a,b) +#define IDirect3DTexture9_GetSurfaceLevel(p,a,b) (p)->lpVtbl->GetSurfaceLevel(p,a,b) +#define IDirect3DTexture9_LockRect(p,a,b,c,d) (p)->lpVtbl->LockRect(p,a,b,c,d) +#define IDirect3DTexture9_UnlockRect(p,a) (p)->lpVtbl->UnlockRect(p,a) +#define IDirect3DTexture9_AddDirtyRect(p,a) (p)->lpVtbl->AddDirtyRect(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DTexture9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DTexture9_AddRef(p) (p)->AddRef() +#define IDirect3DTexture9_Release(p) (p)->Release() +/*** IDirect3DTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DTexture9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DTexture9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DTexture9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DTexture9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DTexture9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DTexture9_GetPriority(p) (p)->GetPriority() +#define IDirect3DTexture9_PreLoad(p) (p)->PreLoad() +#define IDirect3DTexture9_GetType(p) (p)->GetType() +/*** IDirect3DTexture9 methods: IDirect3DBaseTexture9 ***/ +#define IDirect3DTexture9_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DTexture9_GetLOD(p) (p)->GetLOD() +#define IDirect3DTexture9_GetLevelCount(p) (p)->GetLevelCount() +#define IDirect3DTexture9_SetAutoGenFilterType(p,a) (p)->SetAutoGenFilterType(a) +#define IDirect3DTexture9_GetAutoGenFilterType(p) (p)->GetAutoGenFilterType() +#define IDirect3DTexture9_GenerateMipSubLevels(p) (p)->GenerateMipSubLevels() +/*** IDirect3DTexture9 methods ***/ +#define IDirect3DTexture9_GetLevelDesc(p,a,b) (p)->GetLevelDesc(a,b) +#define IDirect3DTexture9_GetSurfaceLevel(p,a,b) (p)->GetSurfaceLevel(a,b) +#define IDirect3DTexture9_LockRect(p,a,b,c,d) (p)->LockRect(a,b,c,d) +#define IDirect3DTexture9_UnlockRect(p,a) (p)->UnlockRect(a) +#define IDirect3DTexture9_AddDirtyRect(p,a) (p)->AddDirtyRect(a) +#endif + +/***************************************************************************** + * IDirect3DVolumeTexture9 interface + */ +#define INTERFACE IDirect3DVolumeTexture9 +DECLARE_INTERFACE_IID_(IDirect3DVolumeTexture9,IDirect3DBaseTexture9,"2518526c-e789-4111-a7b9-47ef328d13e6") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DResource9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(SetPrivateData)(THIS_ REFGUID guid, const void *data, DWORD data_size, DWORD flags) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; + STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; + STDMETHOD_(DWORD, GetPriority)(THIS) PURE; + STDMETHOD_(void, PreLoad)(THIS) PURE; + STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; + /*** IDirect3DBaseTexture9 methods ***/ + STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew) PURE; + STDMETHOD_(DWORD, GetLOD)(THIS) PURE; + STDMETHOD_(DWORD, GetLevelCount)(THIS) PURE; + STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType) PURE; + STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS) PURE; + STDMETHOD_(void, GenerateMipSubLevels)(THIS) PURE; + /*** IDirect3DVolumeTexture9 methods ***/ + STDMETHOD(GetLevelDesc)(THIS_ UINT Level, D3DVOLUME_DESC *pDesc) PURE; + STDMETHOD(GetVolumeLevel)(THIS_ UINT Level, IDirect3DVolume9** ppVolumeLevel) PURE; + STDMETHOD(LockBox)(THIS_ UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) PURE; + STDMETHOD(UnlockBox)(THIS_ UINT Level) PURE; + STDMETHOD(AddDirtyBox)(THIS_ const D3DBOX *dirty_box) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DVolumeTexture9, 0x2518526c, 0xe789, 0x4111, 0xa7, 0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVolumeTexture9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVolumeTexture9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVolumeTexture9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVolumeTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DVolumeTexture9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVolumeTexture9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DVolumeTexture9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DVolumeTexture9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DVolumeTexture9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DVolumeTexture9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DVolumeTexture9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DVolumeTexture9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DVolumeTexture9 methods: IDirect3DBaseTexture9 ***/ +#define IDirect3DVolumeTexture9_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirect3DVolumeTexture9_GetLOD(p) (p)->lpVtbl->GetLOD(p) +#define IDirect3DVolumeTexture9_GetLevelCount(p) (p)->lpVtbl->GetLevelCount(p) +#define IDirect3DVolumeTexture9_SetAutoGenFilterType(p,a) (p)->lpVtbl->SetAutoGenFilterType(p,a) +#define IDirect3DVolumeTexture9_GetAutoGenFilterType(p) (p)->lpVtbl->GetAutoGenFilterType(p) +#define IDirect3DVolumeTexture9_GenerateMipSubLevels(p) (p)->lpVtbl->GenerateMipSubLevels(p) +/*** IDirect3DVolumeTexture9 methods ***/ +#define IDirect3DVolumeTexture9_GetLevelDesc(p,a,b) (p)->lpVtbl->GetLevelDesc(p,a,b) +#define IDirect3DVolumeTexture9_GetVolumeLevel(p,a,b) (p)->lpVtbl->GetVolumeLevel(p,a,b) +#define IDirect3DVolumeTexture9_LockBox(p,a,b,c,d) (p)->lpVtbl->LockBox(p,a,b,c,d) +#define IDirect3DVolumeTexture9_UnlockBox(p,a) (p)->lpVtbl->UnlockBox(p,a) +#define IDirect3DVolumeTexture9_AddDirtyBox(p,a) (p)->lpVtbl->AddDirtyBox(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DVolumeTexture9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVolumeTexture9_AddRef(p) (p)->AddRef() +#define IDirect3DVolumeTexture9_Release(p) (p)->Release() +/*** IDirect3DVolumeTexture9 methods: IDirect3DResource9 ***/ +#define IDirect3DVolumeTexture9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVolumeTexture9_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirect3DVolumeTexture9_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirect3DVolumeTexture9_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirect3DVolumeTexture9_SetPriority(p,a) (p)->SetPriority(a) +#define IDirect3DVolumeTexture9_GetPriority(p) (p)->GetPriority() +#define IDirect3DVolumeTexture9_PreLoad(p) (p)->PreLoad() +#define IDirect3DVolumeTexture9_GetType(p) (p)->GetType() +/*** IDirect3DVolumeTexture9 methods: IDirect3DBaseTexture9 ***/ +#define IDirect3DVolumeTexture9_SetLOD(p,a) (p)->SetLOD(a) +#define IDirect3DVolumeTexture9_GetLOD(p) (p)->GetLOD() +#define IDirect3DVolumeTexture9_GetLevelCount(p) (p)->GetLevelCount() +#define IDirect3DVolumeTexture9_SetAutoGenFilterType(p,a) (p)->SetAutoGenFilterType(a) +#define IDirect3DVolumeTexture9_GetAutoGenFilterType(p) (p)->GetAutoGenFilterType() +#define IDirect3DVolumeTexture9_GenerateMipSubLevels(p) (p)->GenerateMipSubLevels() +/*** IDirect3DVolumeTexture9 methods ***/ +#define IDirect3DVolumeTexture9_GetLevelDesc(p,a,b) (p)->GetLevelDesc(a,b) +#define IDirect3DVolumeTexture9_GetVolumeLevel(p,a,b) (p)->GetVolumeLevel(a,b) +#define IDirect3DVolumeTexture9_LockBox(p,a,b,c,d) (p)->LockBox(a,b,c,d) +#define IDirect3DVolumeTexture9_UnlockBox(p,a) (p)->UnlockBox(a) +#define IDirect3DVolumeTexture9_AddDirtyBox(p,a) (p)->AddDirtyBox(a) +#endif + +/***************************************************************************** + * IDirect3DVertexDeclaration9 interface + */ +#define INTERFACE IDirect3DVertexDeclaration9 +DECLARE_INTERFACE_IID_(IDirect3DVertexDeclaration9,IUnknown,"dd13c59c-36fa-4098-a8fb-c7ed39dc8546") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DVertexDeclaration9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9*, UINT* pNumElements) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DVertexDeclaration9, 0xdd13c59c, 0x36fa, 0x4098, 0xa8, 0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVertexDeclaration9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexDeclaration9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexDeclaration9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVertexShader9 methods ***/ +#define IDirect3DVertexDeclaration9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVertexDeclaration9_GetDeclaration(p,a,b) (p)->lpVtbl->GetDeclaration(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DVertexDeclaration9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexDeclaration9_AddRef(p) (p)->AddRef() +#define IDirect3DVertexDeclaration9_Release(p) (p)->Release() +/*** IDirect3DVertexShader9 methods ***/ +#define IDirect3DVertexDeclaration9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVertexDeclaration9_GetDeclaration(p,a,b) (p)->GetDeclaration(a,b) +#endif + +/***************************************************************************** + * IDirect3DVertexShader9 interface + */ +#define INTERFACE IDirect3DVertexShader9 +DECLARE_INTERFACE_IID_(IDirect3DVertexShader9,IUnknown,"efc5557e-6265-4613-8a94-43857889eb36") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DVertexShader9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(GetFunction)(THIS_ void*, UINT* pSizeOfData) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DVertexShader9, 0xefc5557e, 0x6265, 0x4613, 0x8a, 0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DVertexShader9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexShader9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexShader9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DVertexShader9 methods ***/ +#define IDirect3DVertexShader9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DVertexShader9_GetFunction(p,a,b) (p)->lpVtbl->GetFunction(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DVertexShader9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexShader9_AddRef(p) (p)->AddRef() +#define IDirect3DVertexShader9_Release(p) (p)->Release() +/*** IDirect3DVertexShader9 methods ***/ +#define IDirect3DVertexShader9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DVertexShader9_GetFunction(p,a,b) (p)->GetFunction(a,b) +#endif + +/***************************************************************************** + * IDirect3DPixelShader9 interface + */ +#define INTERFACE IDirect3DPixelShader9 +DECLARE_INTERFACE_IID_(IDirect3DPixelShader9,IUnknown,"6d3bdbdc-5b02-4415-b852-ce5e8bccb289") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DPixelShader9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(GetFunction)(THIS_ void*, UINT* pSizeOfData) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DPixelShader9, 0x6d3bdbdc, 0x5b02, 0x4415, 0xb8, 0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DPixelShader9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DPixelShader9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DPixelShader9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DPixelShader9 methods ***/ +#define IDirect3DPixelShader9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DPixelShader9_GetFunction(p,a,b) (p)->lpVtbl->GetFunction(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DPixelShader9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DPixelShader9_AddRef(p) (p)->AddRef() +#define IDirect3DPixelShader9_Release(p) (p)->Release() +/*** IDirect3DPixelShader9 methods ***/ +#define IDirect3DPixelShader9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DPixelShader9_GetFunction(p,a,b) (p)->GetFunction(a,b) +#endif + +/***************************************************************************** + * IDirect3DStateBlock9 interface + */ +#define INTERFACE IDirect3DStateBlock9 +DECLARE_INTERFACE_IID_(IDirect3DStateBlock9,IUnknown,"b07c4fe5-310d-4ba8-a23c-4f0f206f218b") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DStateBlock9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD(Capture)(THIS) PURE; + STDMETHOD(Apply)(THIS) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DStateBlock9, 0xb07c4fe5, 0x310d, 0x4ba8, 0xa2, 0x3c, 0x4f, 0xf, 0x20, 0x6f, 0x21, 0x8b); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DStateBlock9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DStateBlock9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DStateBlock9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DStateBlock9 methods ***/ +#define IDirect3DStateBlock9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DStateBlock9_Capture(p) (p)->lpVtbl->Capture(p) +#define IDirect3DStateBlock9_Apply(p) (p)->lpVtbl->Apply(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DStateBlock9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DStateBlock9_AddRef(p) (p)->AddRef() +#define IDirect3DStateBlock9_Release(p) (p)->Release() +/*** IDirect3DStateBlock9 methods ***/ +#define IDirect3DStateBlock9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DStateBlock9_Capture(p) (p)->Capture() +#define IDirect3DStateBlock9_Apply(p) (p)->Apply() +#endif + +/***************************************************************************** + * IDirect3DQuery9 interface + */ +#define INTERFACE IDirect3DQuery9 +DECLARE_INTERFACE_IID_(IDirect3DQuery9,IUnknown,"d9771460-a695-4f26-bbd3-27b840b541cc") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DQuery9 methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9** ppDevice) PURE; + STDMETHOD_(D3DQUERYTYPE, GetType)(THIS) PURE; + STDMETHOD_(DWORD, GetDataSize)(THIS) PURE; + STDMETHOD(Issue)(THIS_ DWORD dwIssueFlags) PURE; + STDMETHOD(GetData)(THIS_ void* pData, DWORD dwSize, DWORD dwGetDataFlags) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DQuery9, 0xd9771460, 0xa695, 0x4f26, 0xbb, 0xd3, 0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DQuery9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DQuery9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DQuery9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DQuery9 ***/ +#define IDirect3DQuery9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DQuery9_GetType(p) (p)->lpVtbl->GetType(p) +#define IDirect3DQuery9_GetDataSize(p) (p)->lpVtbl->GetDataSize(p) +#define IDirect3DQuery9_Issue(p,a) (p)->lpVtbl->Issue(p,a) +#define IDirect3DQuery9_GetData(p,a,b,c) (p)->lpVtbl->GetData(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DQuery9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DQuery9_AddRef(p) (p)->AddRef() +#define IDirect3DQuery9_Release(p) (p)->Release() +/*** IDirect3DQuery9 ***/ +#define IDirect3DQuery9_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DQuery9_GetType(p) (p)->GetType() +#define IDirect3DQuery9_GetDataSize(p) (p)->GetDataSize() +#define IDirect3DQuery9_Issue(p,a) (p)->Issue(a) +#define IDirect3DQuery9_GetData(p,a,b,c) (p)->GetData(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DDevice9 interface + */ +#define INTERFACE IDirect3DDevice9 +DECLARE_INTERFACE_IID_(IDirect3DDevice9,IUnknown,"d0223b96-bf7a-43fd-92bd-a43b0d82b9eb") +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DDevice9 methods ***/ + STDMETHOD(TestCooperativeLevel)(THIS) PURE; + STDMETHOD_(UINT, GetAvailableTextureMem)(THIS) PURE; + STDMETHOD(EvictManagedResources)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D9** ppD3D9) PURE; + STDMETHOD(GetDeviceCaps)(THIS_ D3DCAPS9* pCaps) PURE; + STDMETHOD(GetDisplayMode)(THIS_ UINT iSwapChain, D3DDISPLAYMODE* pMode) PURE; + STDMETHOD(GetCreationParameters)(THIS_ D3DDEVICE_CREATION_PARAMETERS *pParameters) PURE; + STDMETHOD(SetCursorProperties)(THIS_ UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) PURE; + STDMETHOD_(void, SetCursorPosition)(THIS_ int X,int Y, DWORD Flags) PURE; + STDMETHOD_(BOOL, ShowCursor)(THIS_ BOOL bShow) PURE; + STDMETHOD(CreateAdditionalSwapChain)(THIS_ D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain) PURE; + STDMETHOD(GetSwapChain)(THIS_ UINT iSwapChain, IDirect3DSwapChain9** pSwapChain) PURE; + STDMETHOD_(UINT, GetNumberOfSwapChains)(THIS) PURE; + STDMETHOD(Reset)(THIS_ D3DPRESENT_PARAMETERS* pPresentationParameters) PURE; + STDMETHOD(Present)(THIS_ const RECT *src_rect, const RECT *dst_rect, + HWND dst_window_override, const RGNDATA *dirty_region) PURE; + STDMETHOD(GetBackBuffer)(THIS_ UINT iSwapChain, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) PURE; + STDMETHOD(GetRasterStatus)(THIS_ UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) PURE; + STDMETHOD(SetDialogBoxMode)(THIS_ BOOL bEnableDialogs) PURE; + STDMETHOD_(void, SetGammaRamp)(THIS_ UINT swapchain_idx, DWORD flags, const D3DGAMMARAMP *ramp) PURE; + STDMETHOD_(void, GetGammaRamp)(THIS_ UINT iSwapChain, D3DGAMMARAMP* pRamp) PURE; + STDMETHOD(CreateTexture)(THIS_ UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle) PURE; + STDMETHOD(CreateVolumeTexture)(THIS_ UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle) PURE; + STDMETHOD(CreateCubeTexture)(THIS_ UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle) PURE; + STDMETHOD(CreateIndexBuffer)(THIS_ UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle) PURE; + STDMETHOD(CreateRenderTarget)(THIS_ UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) PURE; + STDMETHOD(CreateDepthStencilSurface)(THIS_ UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Discard, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) PURE; + STDMETHOD(UpdateSurface)(THIS_ IDirect3DSurface9 *src_surface, const RECT *src_rect, + IDirect3DSurface9 *dst_surface, const POINT *dst_point) PURE; + STDMETHOD(UpdateTexture)(THIS_ IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture) PURE; + STDMETHOD(GetRenderTargetData)(THIS_ IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface) PURE; + STDMETHOD(GetFrontBufferData)(THIS_ UINT iSwapChain, IDirect3DSurface9* pDestSurface) PURE; + STDMETHOD(StretchRect)(THIS_ IDirect3DSurface9 *src_surface, const RECT *src_rect, + IDirect3DSurface9 *dst_surface, const RECT *dst_rect, D3DTEXTUREFILTERTYPE filter) PURE; + STDMETHOD(ColorFill)(THIS_ IDirect3DSurface9 *surface, const RECT *rect, D3DCOLOR color) PURE; + STDMETHOD(CreateOffscreenPlainSurface)(THIS_ UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) PURE; + STDMETHOD(SetRenderTarget)(THIS_ DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) PURE; + STDMETHOD(GetRenderTarget)(THIS_ DWORD RenderTargetIndex, IDirect3DSurface9** ppRenderTarget) PURE; + STDMETHOD(SetDepthStencilSurface)(THIS_ IDirect3DSurface9* pNewZStencil) PURE; + STDMETHOD(GetDepthStencilSurface)(THIS_ IDirect3DSurface9** ppZStencilSurface) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(Clear)(THIS_ DWORD rect_count, const D3DRECT *rects, DWORD flags, + D3DCOLOR color, float z, DWORD stencil) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(SetViewport)(THIS_ const D3DVIEWPORT9 *viewport) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT9* pViewport) PURE; + STDMETHOD(SetMaterial)(THIS_ const D3DMATERIAL9 *material) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL9* pMaterial) PURE; + STDMETHOD(SetLight)(THIS_ DWORD index, const D3DLIGHT9 *light) PURE; + STDMETHOD(GetLight)(THIS_ DWORD Index, D3DLIGHT9*) PURE; + STDMETHOD(LightEnable)(THIS_ DWORD Index, BOOL Enable) PURE; + STDMETHOD(GetLightEnable)(THIS_ DWORD Index, BOOL* pEnable) PURE; + STDMETHOD(SetClipPlane)(THIS_ DWORD index, const float *plane) PURE; + STDMETHOD(GetClipPlane)(THIS_ DWORD Index, float* pPlane) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE State, DWORD Value) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE State, DWORD* pValue) PURE; + STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppSB) PURE; + STDMETHOD(BeginStateBlock)(THIS) PURE; + STDMETHOD(EndStateBlock)(THIS_ IDirect3DStateBlock9** ppSB) PURE; + STDMETHOD(SetClipStatus)(THIS_ const D3DCLIPSTATUS9 *clip_status) PURE; + STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS9* pClipStatus) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD Stage, IDirect3DBaseTexture9** ppTexture) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD Stage, IDirect3DBaseTexture9* pTexture) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) PURE; + STDMETHOD(GetSamplerState)(THIS_ DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue) PURE; + STDMETHOD(SetSamplerState)(THIS_ DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) PURE; + STDMETHOD(ValidateDevice)(THIS_ DWORD* pNumPasses) PURE; + STDMETHOD(SetPaletteEntries)(THIS_ UINT palette_idx, const PALETTEENTRY *entries) PURE; + STDMETHOD(GetPaletteEntries)(THIS_ UINT PaletteNumber,PALETTEENTRY* pEntries) PURE; + STDMETHOD(SetCurrentTexturePalette)(THIS_ UINT PaletteNumber) PURE; + STDMETHOD(GetCurrentTexturePalette)(THIS_ UINT *PaletteNumber) PURE; + STDMETHOD(SetScissorRect)(THIS_ const RECT *rect) PURE; + STDMETHOD(GetScissorRect)(THIS_ RECT* pRect) PURE; + STDMETHOD(SetSoftwareVertexProcessing)(THIS_ BOOL bSoftware) PURE; + STDMETHOD_(BOOL, GetSoftwareVertexProcessing)(THIS) PURE; + STDMETHOD(SetNPatchMode)(THIS_ float nSegments) PURE; + STDMETHOD_(float, GetNPatchMode)(THIS) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount) PURE; + STDMETHOD(DrawPrimitiveUP)(THIS_ D3DPRIMITIVETYPE primitive_type, + UINT primitive_count, const void *data, UINT stride) PURE; + STDMETHOD(DrawIndexedPrimitiveUP)(THIS_ D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count, + UINT primitive_count, const void *index_data, D3DFORMAT index_format, const void *data, UINT stride) PURE; + STDMETHOD(ProcessVertices)(THIS_ UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags) PURE; + STDMETHOD(CreateVertexDeclaration)(THIS_ const D3DVERTEXELEMENT9 *elements, + IDirect3DVertexDeclaration9 **declaration) PURE; + STDMETHOD(SetVertexDeclaration)(THIS_ IDirect3DVertexDeclaration9* pDecl) PURE; + STDMETHOD(GetVertexDeclaration)(THIS_ IDirect3DVertexDeclaration9** ppDecl) PURE; + STDMETHOD(SetFVF)(THIS_ DWORD FVF) PURE; + STDMETHOD(GetFVF)(THIS_ DWORD* pFVF) PURE; + STDMETHOD(CreateVertexShader)(THIS_ const DWORD *byte_code, IDirect3DVertexShader9 **shader) PURE; + STDMETHOD(SetVertexShader)(THIS_ IDirect3DVertexShader9* pShader) PURE; + STDMETHOD(GetVertexShader)(THIS_ IDirect3DVertexShader9** ppShader) PURE; + STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT reg_idx, const float *data, UINT count) PURE; + STDMETHOD(GetVertexShaderConstantF)(THIS_ UINT StartRegister, float* pConstantData, UINT Vector4fCount) PURE; + STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT reg_idx, const int *data, UINT count) PURE; + STDMETHOD(GetVertexShaderConstantI)(THIS_ UINT StartRegister, int* pConstantData, UINT Vector4iCount) PURE; + STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT reg_idx, const BOOL *data, UINT count) PURE; + STDMETHOD(GetVertexShaderConstantB)(THIS_ UINT StartRegister, BOOL* pConstantData, UINT BoolCount) PURE; + STDMETHOD(SetStreamSource)(THIS_ UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride) PURE; + STDMETHOD(GetStreamSource)(THIS_ UINT StreamNumber, IDirect3DVertexBuffer9** ppStreamData, UINT* OffsetInBytes, UINT* pStride) PURE; + STDMETHOD(SetStreamSourceFreq)(THIS_ UINT StreamNumber, UINT Divider) PURE; + STDMETHOD(GetStreamSourceFreq)(THIS_ UINT StreamNumber, UINT* Divider) PURE; + STDMETHOD(SetIndices)(THIS_ IDirect3DIndexBuffer9* pIndexData) PURE; + STDMETHOD(GetIndices)(THIS_ IDirect3DIndexBuffer9** ppIndexData) PURE; + STDMETHOD(CreatePixelShader)(THIS_ const DWORD *byte_code, IDirect3DPixelShader9 **shader) PURE; + STDMETHOD(SetPixelShader)(THIS_ IDirect3DPixelShader9* pShader) PURE; + STDMETHOD(GetPixelShader)(THIS_ IDirect3DPixelShader9** ppShader) PURE; + STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT reg_idx, const float *data, UINT count) PURE; + STDMETHOD(GetPixelShaderConstantF)(THIS_ UINT StartRegister, float* pConstantData, UINT Vector4fCount) PURE; + STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT reg_idx, const int *data, UINT count) PURE; + STDMETHOD(GetPixelShaderConstantI)(THIS_ UINT StartRegister, int* pConstantData, UINT Vector4iCount) PURE; + STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT reg_idx, const BOOL *data, UINT count) PURE; + STDMETHOD(GetPixelShaderConstantB)(THIS_ UINT StartRegister, BOOL* pConstantData, UINT BoolCount) PURE; + STDMETHOD(DrawRectPatch)(THIS_ UINT handle, const float *segment_count, const D3DRECTPATCH_INFO *patch_info) PURE; + STDMETHOD(DrawTriPatch)(THIS_ UINT handle, const float *segment_count, const D3DTRIPATCH_INFO *patch_info) PURE; + STDMETHOD(DeletePatch)(THIS_ UINT Handle) PURE; + STDMETHOD(CreateQuery)(THIS_ D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery) PURE; +}; +#undef INTERFACE + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DDevice9, 0xd0223b96, 0xbf7a, 0x43fd, 0x92, 0xbd, 0xa4, 0x3b, 0xd, 0x82, 0xb9, 0xeb); +#endif + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DDevice9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DDevice9 methods ***/ +#define IDirect3DDevice9_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p) +#define IDirect3DDevice9_GetAvailableTextureMem(p) (p)->lpVtbl->GetAvailableTextureMem(p) +#define IDirect3DDevice9_EvictManagedResources(p) (p)->lpVtbl->EvictManagedResources(p) +#define IDirect3DDevice9_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice9_GetDeviceCaps(p,a) (p)->lpVtbl->GetDeviceCaps(p,a) +#define IDirect3DDevice9_GetDisplayMode(p,a,b) (p)->lpVtbl->GetDisplayMode(p,a,b) +#define IDirect3DDevice9_GetCreationParameters(p,a) (p)->lpVtbl->GetCreationParameters(p,a) +#define IDirect3DDevice9_SetCursorProperties(p,a,b,c) (p)->lpVtbl->SetCursorProperties(p,a,b,c) +#define IDirect3DDevice9_SetCursorPosition(p,a,b,c) (p)->lpVtbl->SetCursorPosition(p,a,b,c) +#define IDirect3DDevice9_ShowCursor(p,a) (p)->lpVtbl->ShowCursor(p,a) +#define IDirect3DDevice9_CreateAdditionalSwapChain(p,a,b) (p)->lpVtbl->CreateAdditionalSwapChain(p,a,b) +#define IDirect3DDevice9_GetSwapChain(p,a,b) (p)->lpVtbl->GetSwapChain(p,a,b) +#define IDirect3DDevice9_GetNumberOfSwapChains(p) (p)->lpVtbl->GetNumberOfSwapChains(p) +#define IDirect3DDevice9_Reset(p,a) (p)->lpVtbl->Reset(p,a) +#define IDirect3DDevice9_Present(p,a,b,c,d) (p)->lpVtbl->Present(p,a,b,c,d) +#define IDirect3DDevice9_GetBackBuffer(p,a,b,c,d) (p)->lpVtbl->GetBackBuffer(p,a,b,c,d) +#define IDirect3DDevice9_GetRasterStatus(p,a,b) (p)->lpVtbl->GetRasterStatus(p,a,b) +#define IDirect3DDevice9_SetDialogBoxMode(p,a) (p)->lpVtbl->SetDialogBoxMode(p,a) +#define IDirect3DDevice9_SetGammaRamp(p,a,b,c) (p)->lpVtbl->SetGammaRamp(p,a,b,c) +#define IDirect3DDevice9_GetGammaRamp(p,a,b) (p)->lpVtbl->GetGammaRamp(p,a,b) +#define IDirect3DDevice9_CreateTexture(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateTexture(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_CreateVolumeTexture(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateVolumeTexture(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9_CreateCubeTexture(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateCubeTexture(p,a,b,c,d,e,f,g) +#define IDirect3DDevice9_CreateVertexBuffer(p,a,b,c,d,e,f) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c,d,e,f) +#define IDirect3DDevice9_CreateIndexBuffer(p,a,b,c,d,e,f) (p)->lpVtbl->CreateIndexBuffer(p,a,b,c,d,e,f) +#define IDirect3DDevice9_CreateRenderTarget(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateRenderTarget(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_CreateDepthStencilSurface(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateDepthStencilSurface(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_UpdateSurface(p,a,b,c,d) (p)->lpVtbl->UpdateSurface(p,a,b,c,d) +#define IDirect3DDevice9_UpdateTexture(p,a,b) (p)->lpVtbl->UpdateTexture(p,a,b) +#define IDirect3DDevice9_GetRenderTargetData(p,a,b) (p)->lpVtbl->GetRenderTargetData(p,a,b) +#define IDirect3DDevice9_GetFrontBufferData(p,a,b) (p)->lpVtbl->GetFrontBufferData(p,a,b) +#define IDirect3DDevice9_StretchRect(p,a,b,c,d,e) (p)->lpVtbl->StretchRect(p,a,b,c,d,e) +#define IDirect3DDevice9_ColorFill(p,a,b,c) (p)->lpVtbl->ColorFill(p,a,b,c) +#define IDirect3DDevice9_CreateOffscreenPlainSurface(p,a,b,c,d,e,f) (p)->lpVtbl->CreateOffscreenPlainSurface(p,a,b,c,d,e,f) +#define IDirect3DDevice9_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice9_GetRenderTarget(p,a,b) (p)->lpVtbl->GetRenderTarget(p,a,b) +#define IDirect3DDevice9_SetDepthStencilSurface(p,a) (p)->lpVtbl->SetDepthStencilSurface(p,a) +#define IDirect3DDevice9_GetDepthStencilSurface(p,a) (p)->lpVtbl->GetDepthStencilSurface(p,a) +#define IDirect3DDevice9_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice9_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice9_Clear(p,a,b,c,d,e,f) (p)->lpVtbl->Clear(p,a,b,c,d,e,f) +#define IDirect3DDevice9_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice9_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice9_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice9_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DDevice9_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DDevice9_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DDevice9_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DDevice9_SetLight(p,a,b) (p)->lpVtbl->SetLight(p,a,b) +#define IDirect3DDevice9_GetLight(p,a,b) (p)->lpVtbl->GetLight(p,a,b) +#define IDirect3DDevice9_LightEnable(p,a,b) (p)->lpVtbl->LightEnable(p,a,b) +#define IDirect3DDevice9_GetLightEnable(p,a,b) (p)->lpVtbl->GetLightEnable(p,a,b) +#define IDirect3DDevice9_SetClipPlane(p,a,b) (p)->lpVtbl->SetClipPlane(p,a,b) +#define IDirect3DDevice9_GetClipPlane(p,a,b) (p)->lpVtbl->GetClipPlane(p,a,b) +#define IDirect3DDevice9_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice9_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice9_CreateStateBlock(p,a,b) (p)->lpVtbl->CreateStateBlock(p,a,b) +#define IDirect3DDevice9_BeginStateBlock(p) (p)->lpVtbl->BeginStateBlock(p) +#define IDirect3DDevice9_EndStateBlock(p,a) (p)->lpVtbl->EndStateBlock(p,a) +#define IDirect3DDevice9_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice9_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice9_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice9_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice9_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice9_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice9_GetSamplerState(p,a,b,c) (p)->lpVtbl->GetSamplerState(p,a,b,c) +#define IDirect3DDevice9_SetSamplerState(p,a,b,c) (p)->lpVtbl->SetSamplerState(p,a,b,c) +#define IDirect3DDevice9_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#define IDirect3DDevice9_SetPaletteEntries(p,a,b) (p)->lpVtbl->SetPaletteEntries(p,a,b) +#define IDirect3DDevice9_GetPaletteEntries(p,a,b) (p)->lpVtbl->GetPaletteEntries(p,a,b) +#define IDirect3DDevice9_SetCurrentTexturePalette(p,a) (p)->lpVtbl->SetCurrentTexturePalette(p,a) +#define IDirect3DDevice9_GetCurrentTexturePalette(p,a) (p)->lpVtbl->GetCurrentTexturePalette(p,a) +#define IDirect3DDevice9_SetScissorRect(p,a) (p)->lpVtbl->SetScissorRect(p,a) +#define IDirect3DDevice9_GetScissorRect(p,a) (p)->lpVtbl->GetScissorRect(p,a) +#define IDirect3DDevice9_SetSoftwareVertexProcessing(p,a) (p)->lpVtbl->SetSoftwareVertexProcessing(p,a) +#define IDirect3DDevice9_GetSoftwareVertexProcessing(p) (p)->lpVtbl->GetSoftwareVertexProcessing(p) +#define IDirect3DDevice9_SetNPatchMode(p,a) (p)->lpVtbl->SetNPatchMode(p,a) +#define IDirect3DDevice9_GetNPatchMode(p) (p)->lpVtbl->GetNPatchMode(p) +#define IDirect3DDevice9_DrawPrimitive(p,a,b,c) (p)->lpVtbl->DrawPrimitive(p,a,b,c) +#define IDirect3DDevice9_DrawIndexedPrimitive(p,a,b,c,d,e,f) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f) +#define IDirect3DDevice9_DrawPrimitiveUP(p,a,b,c,d) (p)->lpVtbl->DrawPrimitiveUP(p,a,b,c,d) +#define IDirect3DDevice9_DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_ProcessVertices(p,a,b,c,d,e,f) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e,f) +#define IDirect3DDevice9_CreateVertexDeclaration(p,a,b) (p)->lpVtbl->CreateVertexDeclaration(p,a,b) +#define IDirect3DDevice9_SetVertexDeclaration(p,a) (p)->lpVtbl->SetVertexDeclaration(p,a) +#define IDirect3DDevice9_GetVertexDeclaration(p,a) (p)->lpVtbl->GetVertexDeclaration(p,a) +#define IDirect3DDevice9_SetFVF(p,a) (p)->lpVtbl->SetFVF(p,a) +#define IDirect3DDevice9_GetFVF(p,a) (p)->lpVtbl->GetFVF(p,a) +#define IDirect3DDevice9_CreateVertexShader(p,a,b) (p)->lpVtbl->CreateVertexShader(p,a,b) +#define IDirect3DDevice9_SetVertexShader(p,a) (p)->lpVtbl->SetVertexShader(p,a) +#define IDirect3DDevice9_GetVertexShader(p,a) (p)->lpVtbl->GetVertexShader(p,a) +#define IDirect3DDevice9_SetVertexShaderConstantF(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstantF(p,a,b,c) +#define IDirect3DDevice9_GetVertexShaderConstantF(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstantF(p,a,b,c) +#define IDirect3DDevice9_SetVertexShaderConstantI(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstantI(p,a,b,c) +#define IDirect3DDevice9_GetVertexShaderConstantI(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstantI(p,a,b,c) +#define IDirect3DDevice9_SetVertexShaderConstantB(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstantB(p,a,b,c) +#define IDirect3DDevice9_GetVertexShaderConstantB(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstantB(p,a,b,c) +#define IDirect3DDevice9_SetStreamSource(p,a,b,c,d) (p)->lpVtbl->SetStreamSource(p,a,b,c,d) +#define IDirect3DDevice9_GetStreamSource(p,a,b,c,d) (p)->lpVtbl->GetStreamSource(p,a,b,c,d) +#define IDirect3DDevice9_SetStreamSourceFreq(p,a,b) (p)->lpVtbl->SetStreamSourceFreq(p,a,b) +#define IDirect3DDevice9_GetStreamSourceFreq(p,a,b) (p)->lpVtbl->GetStreamSourceFreq(p,a,b) +#define IDirect3DDevice9_SetIndices(p,a) (p)->lpVtbl->SetIndices(p,a) +#define IDirect3DDevice9_GetIndices(p,a) (p)->lpVtbl->GetIndices(p,a) +#define IDirect3DDevice9_CreatePixelShader(p,a,b) (p)->lpVtbl->CreatePixelShader(p,a,b) +#define IDirect3DDevice9_SetPixelShader(p,a) (p)->lpVtbl->SetPixelShader(p,a) +#define IDirect3DDevice9_GetPixelShader(p,a) (p)->lpVtbl->GetPixelShader(p,a) +#define IDirect3DDevice9_SetPixelShaderConstantF(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstantF(p,a,b,c) +#define IDirect3DDevice9_GetPixelShaderConstantF(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstantF(p,a,b,c) +#define IDirect3DDevice9_SetPixelShaderConstantI(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstantI(p,a,b,c) +#define IDirect3DDevice9_GetPixelShaderConstantI(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstantI(p,a,b,c) +#define IDirect3DDevice9_SetPixelShaderConstantB(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstantB(p,a,b,c) +#define IDirect3DDevice9_GetPixelShaderConstantB(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstantB(p,a,b,c) +#define IDirect3DDevice9_DrawRectPatch(p,a,b,c) (p)->lpVtbl->DrawRectPatch(p,a,b,c) +#define IDirect3DDevice9_DrawTriPatch(p,a,b,c) (p)->lpVtbl->DrawTriPatch(p,a,b,c) +#define IDirect3DDevice9_DeletePatch(p,a) (p)->lpVtbl->DeletePatch(p,a) +#define IDirect3DDevice9_CreateQuery(p,a,b) (p)->lpVtbl->CreateQuery(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DDevice9_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice9_AddRef(p) (p)->AddRef() +#define IDirect3DDevice9_Release(p) (p)->Release() +/*** IDirect3DDevice9 methods ***/ +#define IDirect3DDevice9_TestCooperativeLevel(p) (p)->TestCooperativeLevel() +#define IDirect3DDevice9_GetAvailableTextureMem(p) (p)->GetAvailableTextureMem() +#define IDirect3DDevice9_EvictManagedResources(p) (p)->EvictManagedResources() +#define IDirect3DDevice9_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice9_GetDeviceCaps(p,a) (p)->GetDeviceCaps(a) +#define IDirect3DDevice9_GetDisplayMode(p,a,b) (p)->GetDisplayMode(a,b) +#define IDirect3DDevice9_GetCreationParameters(p,a) (p)->GetCreationParameters(a) +#define IDirect3DDevice9_SetCursorProperties(p,a,b,c) (p)->SetCursorProperties(a,b,c) +#define IDirect3DDevice9_SetCursorPosition(p,a,b,c) (p)->SetCursorPosition(a,b,c) +#define IDirect3DDevice9_ShowCursor(p,a) (p)->ShowCursor(a) +#define IDirect3DDevice9_CreateAdditionalSwapChain(p,a,b) (p)->CreateAdditionalSwapChain(a,b) +#define IDirect3DDevice9_GetSwapChain(p,a,b) (p)->GetSwapChain(a,b) +#define IDirect3DDevice9_GetNumberOfSwapChains(p) (p)->GetNumberOfSwapChains() +#define IDirect3DDevice9_Reset(p,a) (p)->Reset(a) +#define IDirect3DDevice9_Present(p,a,b,c,d) (p)->Present(a,b,c,d) +#define IDirect3DDevice9_GetBackBuffer(p,a,b,c,d) (p)->GetBackBuffer(a,b,c,d) +#define IDirect3DDevice9_GetRasterStatus(p,a,b) (p)->GetRasterStatus(a,b) +#define IDirect3DDevice9_SetDialogBoxMode(p,a) (p)->SetDialogBoxMode(a) +#define IDirect3DDevice9_SetGammaRamp(p,a,b,c) (p)->SetGammaRamp(a,b,c) +#define IDirect3DDevice9_GetGammaRamp(p,a,b) (p)->GetGammaRamp(a,b) +#define IDirect3DDevice9_CreateTexture(p,a,b,c,d,e,f,g,h) (p)->CreateTexture(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_CreateVolumeTexture(p,a,b,c,d,e,f,g,h,i) (p)->CreateVolumeTexture(a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9_CreateCubeTexture(p,a,b,c,d,e,f,g) (p)->CreateCubeTexture(a,b,c,d,e,f,g) +#define IDirect3DDevice9_CreateVertexBuffer(p,a,b,c,d,e,f) (p)->CreateVertexBuffer(a,b,c,d,e,f) +#define IDirect3DDevice9_CreateIndexBuffer(p,a,b,c,d,e,f) (p)->CreateIndexBuffer(a,b,c,d,e,f) +#define IDirect3DDevice9_CreateRenderTarget(p,a,b,c,d,e,f,g,h) (p)->CreateRenderTarget(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_CreateDepthStencilSurface(p,a,b,c,d,e,f,g,h) (p)->CreateDepthStencilSurface(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_UpdateSurface(p,a,b,c,d) (p)->UpdateSurface(a,b,c,d) +#define IDirect3DDevice9_UpdateTexture(p,a,b) (p)->UpdateTexture(a,b) +#define IDirect3DDevice9_GetRenderTargetData(p,a,b) (p)->GetRenderTargetData(a,b) +#define IDirect3DDevice9_GetFrontBufferData(p,a,b) (p)->GetFrontBufferData(a,b) +#define IDirect3DDevice9_StretchRect(p,a,b,c,d,e) (p)->StretchRect(a,b,c,d,e) +#define IDirect3DDevice9_ColorFill(p,a,b,c) (p)->ColorFill(a,b,c) +#define IDirect3DDevice9_CreateOffscreenPlainSurface(p,a,b,c,d,e,f) (p)->CreateOffscreenPlainSurface(a,b,c,d,e,f) +#define IDirect3DDevice9_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice9_GetRenderTarget(p,a,b) (p)->GetRenderTarget(a,b) +#define IDirect3DDevice9_SetDepthStencilSurface(p,a) (p)->SetDepthStencilSurface(a) +#define IDirect3DDevice9_GetDepthStencilSurface(p,a) (p)->GetDepthStencilSurface(a) +#define IDirect3DDevice9_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice9_EndScene(p) (p)->EndScene() +#define IDirect3DDevice9_Clear(p,a,b,c,d,e,f) (p)->Clear(a,b,c,d,e,f) +#define IDirect3DDevice9_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice9_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice9_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice9_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DDevice9_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DDevice9_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DDevice9_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DDevice9_SetLight(p,a,b) (p)->SetLight(a,b) +#define IDirect3DDevice9_GetLight(p,a,b) (p)->GetLight(a,b) +#define IDirect3DDevice9_LightEnable(p,a,b) (p)->LightEnable(a,b) +#define IDirect3DDevice9_GetLightEnable(p,a,b) (p)->GetLightEnable(a,b) +#define IDirect3DDevice9_SetClipPlane(p,a,b) (p)->SetClipPlane(a,b) +#define IDirect3DDevice9_GetClipPlane(p,a,b) (p)->GetClipPlane(a,b) +#define IDirect3DDevice9_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice9_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice9_CreateStateBlock(p,a,b) (p)->CreateStateBlock(a,b) +#define IDirect3DDevice9_BeginStateBlock(p) (p)->BeginStateBlock() +#define IDirect3DDevice9_EndStateBlock(p,a) (p)->EndStateBlock(a) +#define IDirect3DDevice9_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice9_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice9_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice9_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice9_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice9_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice9_GetSamplerState(p,a,b,c) (p)->GetSamplerState(a,b,c) +#define IDirect3DDevice9_SetSamplerState(p,a,b,c) (p)->SetSamplerState(a,b,c) +#define IDirect3DDevice9_ValidateDevice(p,a) (p)->ValidateDevice(a) +#define IDirect3DDevice9_SetPaletteEntries(p,a,b) (p)->SetPaletteEntries(a,b) +#define IDirect3DDevice9_GetPaletteEntries(p,a,b) (p)->GetPaletteEntries(a,b) +#define IDirect3DDevice9_SetCurrentTexturePalette(p,a) (p)->SetCurrentTexturePalette(a) +#define IDirect3DDevice9_GetCurrentTexturePalette(p,a) (p)->GetCurrentTexturePalette(a) +#define IDirect3DDevice9_SetScissorRect(p,a) (p)->SetScissorRect(a) +#define IDirect3DDevice9_GetScissorRect(p,a) (p)->GetScissorRect(a) +#define IDirect3DDevice9_SetSoftwareVertexProcessing(p,a) (p)->SetSoftwareVertexProcessing(a) +#define IDirect3DDevice9_GetSoftwareVertexProcessing(p) (p)->GetSoftwareVertexProcessing() +#define IDirect3DDevice9_SetNPatchMode(p,a) (p)->SetNPatchMode(a) +#define IDirect3DDevice9_GetNPatchMode(p) (p)->GetNPatchMode() +#define IDirect3DDevice9_DrawPrimitive(p,a,b,c) (p)->DrawPrimitive(a,b,c) +#define IDirect3DDevice9_DrawIndexedPrimitive(p,a,b,c,d,e,f) (p)->DrawIndexedPrimitive(a,b,c,d,e,f) +#define IDirect3DDevice9_DrawPrimitiveUP(p,a,b,c,d) (p)->DrawPrimitiveUP(a,b,c,d) +#define IDirect3DDevice9_DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) (p)->DrawIndexedPrimitiveUP(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9_ProcessVertices(p,a,b,c,d,e,f) (p)->ProcessVertices(a,b,c,d,e,f) +#define IDirect3DDevice9_CreateVertexDeclaration(p,a,b) (p)->CreateVertexDeclaration(a,b) +#define IDirect3DDevice9_SetVertexDeclaration(p,a) (p)->SetVertexDeclaration(a) +#define IDirect3DDevice9_GetVertexDeclaration(p,a) (p)->GetVertexDeclaration(a) +#define IDirect3DDevice9_SetFVF(p,a) (p)->SetFVF(a) +#define IDirect3DDevice9_GetFVF(p,a) (p)->GetFVF(a) +#define IDirect3DDevice9_CreateVertexShader(p,a,b) (p)->CreateVertexShader(a,b) +#define IDirect3DDevice9_SetVertexShader(p,a) (p)->SetVertexShader(a) +#define IDirect3DDevice9_GetVertexShader(p,a) (p)->GetVertexShader(a) +#define IDirect3DDevice9_SetVertexShaderConstantF(p,a,b,c) (p)->SetVertexShaderConstantF(a,b,c) +#define IDirect3DDevice9_GetVertexShaderConstantF(p,a,b,c) (p)->GetVertexShaderConstantF(a,b,c) +#define IDirect3DDevice9_SetVertexShaderConstantI(p,a,b,c) (p)->SetVertexShaderConstantI(a,b,c) +#define IDirect3DDevice9_GetVertexShaderConstantI(p,a,b,c) (p)->GetVertexShaderConstantI(a,b,c) +#define IDirect3DDevice9_SetVertexShaderConstantB(p,a,b,c) (p)->SetVertexShaderConstantB(a,b,c) +#define IDirect3DDevice9_GetVertexShaderConstantB(p,a,b,c) (p)->GetVertexShaderConstantB(a,b,c) +#define IDirect3DDevice9_SetStreamSource(p,a,b,c,d) (p)->SetStreamSource(a,b,c,d) +#define IDirect3DDevice9_GetStreamSource(p,a,b,c,d) (p)->GetStreamSource(a,b,c,d) +#define IDirect3DDevice9_SetStreamSourceFreq(p,a,b) (p)->SetStreamSourceFreq(a,b) +#define IDirect3DDevice9_GetStreamSourceFreq(p,a,b) (p)->GetStreamSourceFreq(a,b) +#define IDirect3DDevice9_SetIndices(p,a) (p)->SetIndices(a) +#define IDirect3DDevice9_GetIndices(p,a) (p)->GetIndices(a) +#define IDirect3DDevice9_CreatePixelShader(p,a,b) (p)->CreatePixelShader(a,b) +#define IDirect3DDevice9_SetPixelShader(p,a) (p)->SetPixelShader(a) +#define IDirect3DDevice9_GetPixelShader(p,a) (p)->GetPixelShader(a) +#define IDirect3DDevice9_SetPixelShaderConstantF(p,a,b,c) (p)->SetPixelShaderConstantF(a,b,c) +#define IDirect3DDevice9_GetPixelShaderConstantF(p,a,b,c) (p)->GetPixelShaderConstantF(a,b,c) +#define IDirect3DDevice9_SetPixelShaderConstantI(p,a,b,c) (p)->SetPixelShaderConstantI(a,b,c) +#define IDirect3DDevice9_GetPixelShaderConstantI(p,a,b,c) (p)->GetPixelShaderConstantI(a,b,c) +#define IDirect3DDevice9_SetPixelShaderConstantB(p,a,b,c) (p)->SetPixelShaderConstantB(a,b,c) +#define IDirect3DDevice9_GetPixelShaderConstantB(p,a,b,c) (p)->GetPixelShaderConstantB(a,b,c) +#define IDirect3DDevice9_DrawRectPatch(p,a,b,c) (p)->DrawRectPatch(a,b,c) +#define IDirect3DDevice9_DrawTriPatch(p,a,b,c) (p)->DrawTriPatch(a,b,c) +#define IDirect3DDevice9_DeletePatch(p,a) (p)->DeletePatch(a) +#define IDirect3DDevice9_CreateQuery(p,a,b) (p)->CreateQuery(a,b) +#endif + + +#if !defined(D3D_DISABLE_9EX) + +typedef struct IDirect3D9Ex *LPDIRECT3D9EX, *PDIRECT3D9EX; +typedef struct IDirect3DSwapChain9Ex *LPDIRECT3DSWAPCHAIN9EX, *PDIRECT3DSWAPCHAIN9EX; +typedef struct IDirect3DDevice9Ex *LPDIRECT3DDEVICE9EX, *PDIRECT3DDEVICE9EX; + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3D9Ex, 0x02177241, 0x69fc, 0x400c, 0x8f, 0xf1, 0x93, 0xa4, 0x4d, 0xf6, 0x86, 0x1d); +#endif +DEFINE_GUID(IID_IDirect3D9Ex, 0x02177241, 0x69fc, 0x400c, 0x8f, 0xf1, 0x93, 0xa4, 0x4d, 0xf6, 0x86, 0x1d); + +#define INTERFACE IDirect3D9Ex +DECLARE_INTERFACE_IID_(IDirect3D9Ex,IDirect3D9,"02177241-69fc-400c-8ff1-93a44df6861d") +{ + /* IUnknown */ + STDMETHOD_(HRESULT, QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /* IDirect3D9 */ + STDMETHOD(RegisterSoftwareDevice)(THIS_ void *init) PURE; + STDMETHOD_(UINT, GetAdapterCount)(THIS) PURE; + STDMETHOD(GetAdapterIdentifier)(THIS_ UINT adapter_idx, DWORD flags, D3DADAPTER_IDENTIFIER9 *identifier) PURE; + STDMETHOD_(UINT, GetAdapterModeCount)(THIS_ UINT adapter_idx, D3DFORMAT format) PURE; + STDMETHOD(EnumAdapterModes)(THIS_ UINT adapter_idx, D3DFORMAT format, UINT mode_idx, D3DDISPLAYMODE *mode) PURE; + STDMETHOD(GetAdapterDisplayMode)(THIS_ UINT adapter_idx, D3DDISPLAYMODE *mode) PURE; + STDMETHOD(CheckDeviceType)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, + D3DFORMAT display_format, D3DFORMAT backbuffer_format, BOOL windowed) PURE; + STDMETHOD(CheckDeviceFormat)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, D3DFORMAT adapter_format, + DWORD usage, D3DRESOURCETYPE resource_type, D3DFORMAT format) PURE; + STDMETHOD(CheckDeviceMultiSampleType)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, D3DFORMAT surface_format, + BOOL windowed, D3DMULTISAMPLE_TYPE multisample_type, DWORD *quality_levels) PURE; + STDMETHOD(CheckDepthStencilMatch)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, + D3DFORMAT adapter_format, D3DFORMAT rt_format, D3DFORMAT ds_format) PURE; + STDMETHOD(CheckDeviceFormatConversion)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, + D3DFORMAT src_format, D3DFORMAT dst_format) PURE; + STDMETHOD(GetDeviceCaps)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, D3DCAPS9 *caps) PURE; + STDMETHOD_(HMONITOR, GetAdapterMonitor)(THIS_ UINT adapter_idx) PURE; + STDMETHOD(CreateDevice)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, HWND focus_window, DWORD flags, + D3DPRESENT_PARAMETERS *parameters, struct IDirect3DDevice9 **device) PURE; + /* IDirect3D9Ex */ + STDMETHOD_(UINT, GetAdapterModeCountEx)(THIS_ UINT adapter_idx, const D3DDISPLAYMODEFILTER *filter) PURE; + STDMETHOD(EnumAdapterModesEx)(THIS_ UINT adapter_idx, const D3DDISPLAYMODEFILTER *filter, + UINT mode_idx, D3DDISPLAYMODEEX *mode) PURE; + STDMETHOD(GetAdapterDisplayModeEx)(THIS_ UINT adapter_idx, + D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation) PURE; + STDMETHOD(CreateDeviceEx)(THIS_ UINT adapter_idx, D3DDEVTYPE device_type, HWND focus_window, DWORD flags, + D3DPRESENT_PARAMETERS *parameters, D3DDISPLAYMODEEX *mode, struct IDirect3DDevice9Ex **device) PURE; + STDMETHOD(GetAdapterLUID)(THIS_ UINT adapter_idx, LUID *luid) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/* IUnknown */ +#define IDirect3D9Ex_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D9Ex_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D9Ex_Release(p) (p)->lpVtbl->Release(p) +/* IDirect3D9 */ +#define IDirect3D9Ex_RegisterSoftwareDevice(p,a) (p)->lpVtbl->RegisterSoftwareDevice(p,a) +#define IDirect3D9Ex_GetAdapterCount(p) (p)->lpVtbl->GetAdapterCount(p) +#define IDirect3D9Ex_GetAdapterIdentifier(p,a,b,c) (p)->lpVtbl->GetAdapterIdentifier(p,a,b,c) +#define IDirect3D9Ex_GetAdapterModeCount(p,a,b) (p)->lpVtbl->GetAdapterModeCount(p,a,b) +#define IDirect3D9Ex_EnumAdapterModes(p,a,b,c,d) (p)->lpVtbl->EnumAdapterModes(p,a,b,c,d) +#define IDirect3D9Ex_GetAdapterDisplayMode(p,a,b) (p)->lpVtbl->GetAdapterDisplayMode(p,a,b) +#define IDirect3D9Ex_CheckDeviceType(p,a,b,c,d,e) (p)->lpVtbl->CheckDeviceType(p,a,b,c,d,e) +#define IDirect3D9Ex_CheckDeviceFormat(p,a,b,c,d,e,f) (p)->lpVtbl->CheckDeviceFormat(p,a,b,c,d,e,f) +#define IDirect3D9Ex_CheckDeviceMultiSampleType(p,a,b,c,d,e,f) (p)->lpVtbl->CheckDeviceMultiSampleType(p,a,b,c,d,e,f) +#define IDirect3D9Ex_CheckDepthStencilMatch(p,a,b,c,d,e) (p)->lpVtbl->CheckDepthStencilMatch(p,a,b,c,d,e) +#define IDirect3D9Ex_CheckDeviceFormatConversion(p,a,b,c,d) (p)->lpVtbl->CheckDeviceFormatConversion(p,a,b,c,d) +#define IDirect3D9Ex_GetDeviceCaps(p,a,b,c) (p)->lpVtbl->GetDeviceCaps(p,a,b,c) +#define IDirect3D9Ex_GetAdapterMonitor(p,a) (p)->lpVtbl->GetAdapterMonitor(p,a) +#define IDirect3D9Ex_CreateDevice(p,a,b,c,d,e,f) (p)->lpVtbl->CreateDevice(p,a,b,c,d,e,f) +/* IDirect3D9Ex */ +#define IDirect3D9Ex_GetAdapterModeCountEx(p,a,b) (p)->lpVtbl->GetAdapterModeCountEx(p,a,b) +#define IDirect3D9Ex_EnumAdapterModesEx(p,a,b,c,d) (p)->lpVtbl->EnumAdapterModesEx(p,a,b,c,d) +#define IDirect3D9Ex_GetAdapterDisplayModeEx(p,a,b,c) (p)->lpVtbl->GetAdapterDisplayModeEx(p,a,b,c) +#define IDirect3D9Ex_CreateDeviceEx(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateDeviceEx(p,a,b,c,d,e,f,g) +#define IDirect3D9Ex_GetAdapterLUID(p,a,b) (p)->lpVtbl->GetAdapterLUID(p,a,b) +#else +/* IUnknown */ +#define IDirect3D9Ex_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D9Ex_AddRef(p) (p)->AddRef() +#define IDirect3D9Ex_Release(p) (p)->Release() +/* IDirect3D9 */ +#define IDirect3D9Ex_RegisterSoftwareDevice(p,a) (p)->RegisterSoftwareDevice(a) +#define IDirect3D9Ex_GetAdapterCount(p) (p)->GetAdapterCount() +#define IDirect3D9Ex_GetAdapterIdentifier(p,a,b,c) (p)->GetAdapterIdentifier(a,b,c) +#define IDirect3D9Ex_GetAdapterModeCount(p,a,b) (p)->GetAdapterModeCount(a,b) +#define IDirect3D9Ex_EnumAdapterModes(p,a,b,c,d) (p)->EnumAdapterModes(a,b,c,d) +#define IDirect3D9Ex_GetAdapterDisplayMode(p,a,b) (p)->GetAdapterDisplayMode(a,b) +#define IDirect3D9Ex_CheckDeviceType(p,a,b,c,d,e) (p)->CheckDeviceType(a,b,c,d,e) +#define IDirect3D9Ex_CheckDeviceFormat(p,a,b,c,d,e,f) (p)->CheckDeviceFormat(a,b,c,d,e,f) +#define IDirect3D9Ex_CheckDeviceMultiSampleType(p,a,b,c,d,e,f) (p)->CheckDeviceMultiSampleType(a,b,c,d,e,f) +#define IDirect3D9Ex_CheckDepthStencilMatch(p,a,b,c,d,e) (p)->CheckDepthStencilMatch(a,b,c,d,e) +#define IDirect3D9Ex_CheckDeviceFormatConversion(p,a,b,c,d) (p)->CheckDeviceFormatConversion(a,b,c,d) +#define IDirect3D9Ex_GetDeviceCaps(p,a,b,c) (p)->GetDeviceCaps(a,b,c) +#define IDirect3D9Ex_GetAdapterMonitor(p,a) (p)->GetAdapterMonitor(a) +#define IDirect3D9Ex_CreateDevice(p,a,b,c,d,e,f) (p)->CreateDevice(a,b,c,d,e,f) +/* IDirect3D9Ex */ +#define IDirect3D9Ex_GetAdapterModeCountEx(p,a,b) (p)->GetAdapterModeCountEx(a,b) +#define IDirect3D9Ex_EnumAdapterModesEx(p,a,b,c,d) (p)->EnumAdapterModesEx(a,b,c,d) +#define IDirect3D9Ex_GetAdapterDisplayModeEx(p,a,b,c) (p)->GetAdapterDisplayModeEx(a,b,c) +#define IDirect3D9Ex_CreateDeviceEx(p,a,b,c,d,e,f,g) (p)->CreateDeviceEx(a,b,c,d,e,f,g) +#define IDirect3D9Ex_GetAdapterLUID(p,a,b) (p)->GetAdapterLUID(a,b) +#endif + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DSwapChain9Ex, 0x91886caf, 0x1c3d, 0x4d2e, 0xa0, 0xab, 0x3e, 0x4c, 0x7d, 0x8d, 0x33, 0x3); +#endif +DEFINE_GUID(IID_IDirect3DSwapChain9Ex, 0x91886caf, 0x1c3d, 0x4d2e, 0xa0, 0xab, 0x3e, 0x4c, 0x7d, 0x8d, 0x33, 0x3); + +#define INTERFACE IDirect3DSwapChain9Ex +DECLARE_INTERFACE_IID_(IDirect3DSwapChain9Ex,IDirect3DSwapChain9,"91886caf-1c3d-4d2e-a0ab-3e4c7d8d3303") +{ + /* IUnknown */ + STDMETHOD_(HRESULT, QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /* IDirect3DSwapChain9 */ + STDMETHOD(Present)(THIS_ const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region, DWORD flags) PURE; + STDMETHOD(GetFrontBufferData)(THIS_ struct IDirect3DSurface9 *dst_surface) PURE; + STDMETHOD(GetBackBuffer)(THIS_ UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, + struct IDirect3DSurface9 **backbuffer) PURE; + STDMETHOD(GetRasterStatus)(THIS_ D3DRASTER_STATUS *raster_status) PURE; + STDMETHOD(GetDisplayMode)(THIS_ D3DDISPLAYMODE *mode) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(GetPresentParameters)(THIS_ D3DPRESENT_PARAMETERS *parameters) PURE; + /* IDirect3DSwapChain9Ex */ + STDMETHOD(GetLastPresentCount)(THIS_ UINT *last_present_count) PURE; + STDMETHOD(GetPresentStats)(THIS_ D3DPRESENTSTATS *stats) PURE; + STDMETHOD(GetDisplayModeEx)(THIS_ D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/* IUnknown */ +#define IDirect3DSwapChain9Ex_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DSwapChain9Ex_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DSwapChain9Ex_Release(p) (p)->lpVtbl->Release(p) +/* IDirect3DSwapChain9 */ +#define IDirect3DSwapChain9Ex_Present(p,a,b,c,d,e) (p)->lpVtbl->Present(p,a,b,c,d,e) +#define IDirect3DSwapChain9Ex_GetFrontBufferData(p,a) (p)->lpVtbl->GetFrontBufferData(p,a) +#define IDirect3DSwapChain9Ex_GetBackBuffer(p,a,b,c) (p)->lpVtbl->GetBackBuffer(p,a,b,c) +#define IDirect3DSwapChain9Ex_GetRasterStatus(p,a) (p)->lpVtbl->GetRasterStatus(p,a) +#define IDirect3DSwapChain9Ex_GetDisplayMode(p,a) (p)->lpVtbl->GetDisplayMode(p,a) +#define IDirect3DSwapChain9Ex_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DSwapChain9Ex_GetPresentParameters(p,a) (p)->lpVtbl->GetPresentParameters(p,a) +/* IDirect3DSwapChain9Ex */ +#define IDirect3DSwapChain9Ex_GetLastPresentCount(p,a) (p)->lpVtbl->GetLastPresentCount(p,a) +#define IDirect3DSwapChain9Ex_GetPresentStats(p,a) (p)->lpVtbl->GetPresentStats(p,a) +#define IDirect3DSwapChain9Ex_GetDisplayModeEx(p,a,b) (p)->lpVtbl->GetDisplayModeEx(p,a,b) +#else +/* IUnknown */ +#define IDirect3DSwapChain9Ex_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DSwapChain9Ex_AddRef(p) (p)->AddRef() +#define IDirect3DSwapChain9Ex_Release(p) (p)->Release() +/* IDirect3DSwapChain9 */ +#define IDirect3DSwapChain9Ex_Present(p,a,b,c,d,e) (p)->Present(a,b,c,d,e) +#define IDirect3DSwapChain9Ex_GetFrontBufferData(p,a) (p)->GetFrontBufferData(a) +#define IDirect3DSwapChain9Ex_GetBackBuffer(p,a,b,c) (p)->GetBackBuffer(a,b,c) +#define IDirect3DSwapChain9Ex_GetRasterStatus(p,a) (p)->GetRasterStatus(a) +#define IDirect3DSwapChain9Ex_GetDisplayMode(p,a) (p)->GetDisplayMode(a) +#define IDirect3DSwapChain9Ex_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DSwapChain9Ex_GetPresentParameters(p,a) (p)->GetPresentParameters(a) +/* IDirect3DSwapChain9Ex */ +#define IDirect3DSwapChain9Ex_GetLastPresentCount(p,a) (p)->GetLastPresentCount(a) +#define IDirect3DSwapChain9Ex_GetPresentStats(p,a) (p)->GetPresentStats(a) +#define IDirect3DSwapChain9Ex_GetDisplayModeEx(p,a,b) (p)->GetDisplayModeEx(a,b) +#endif + +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDirect3DDevice9Ex, 0xb18b10ce, 0x2649, 0x405a, 0x87, 0xf, 0x95, 0xf7, 0x77, 0xd4, 0x31, 0x3a); +#endif +DEFINE_GUID(IID_IDirect3DDevice9Ex, 0xb18b10ce, 0x2649, 0x405a, 0x87, 0xf, 0x95, 0xf7, 0x77, 0xd4, 0x31, 0x3a); + +#define INTERFACE IDirect3DDevice9Ex +DECLARE_INTERFACE_IID_(IDirect3DDevice9Ex,IDirect3DDevice9,"b18b10ce-2649-405a-870f-95f777d4313a") +{ + /* IUnknown */ + STDMETHOD_(HRESULT, QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /* IDirect3DDevice9 */ + STDMETHOD(TestCooperativeLevel)(THIS) PURE; + STDMETHOD_(UINT, GetAvailableTextureMem)(THIS) PURE; + STDMETHOD(EvictManagedResources)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ IDirect3D9 **d3d9) PURE; + STDMETHOD(GetDeviceCaps)(THIS_ D3DCAPS9 *caps) PURE; + STDMETHOD(GetDisplayMode)(THIS_ UINT swapchain_idx, D3DDISPLAYMODE *mode) PURE; + STDMETHOD(GetCreationParameters)(THIS_ D3DDEVICE_CREATION_PARAMETERS *parameters) PURE; + STDMETHOD(SetCursorProperties)(THIS_ UINT hotspot_x, UINT hotspot_y, IDirect3DSurface9 *bitmap) PURE; + STDMETHOD_(void, SetCursorPosition)(THIS_ int x, int y, DWORD flags) PURE; + STDMETHOD_(BOOL, ShowCursor)(THIS_ BOOL show) PURE; + STDMETHOD(CreateAdditionalSwapChain)(THIS_ D3DPRESENT_PARAMETERS *parameters, + IDirect3DSwapChain9 **swapchain) PURE; + STDMETHOD(GetSwapChain)(THIS_ UINT swapchain_idx, IDirect3DSwapChain9 **swapchain) PURE; + STDMETHOD_(UINT, GetNumberOfSwapChains)(THIS) PURE; + STDMETHOD(Reset)(THIS_ D3DPRESENT_PARAMETERS *parameters) PURE; + STDMETHOD(Present)(THIS_ const RECT *src_rect, const RECT *dst_rect, + HWND dst_window_override, const RGNDATA *dirty_region) PURE; + STDMETHOD(GetBackBuffer)(THIS_ UINT swapchain_idx, UINT backbuffer_idx, + D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface9 **backbuffer) PURE; + STDMETHOD(GetRasterStatus)(THIS_ UINT swapchain_idx, D3DRASTER_STATUS *raster_status) PURE; + STDMETHOD(SetDialogBoxMode)(THIS_ BOOL enable) PURE; + STDMETHOD_(void, SetGammaRamp)(THIS_ UINT swapchain_idx, DWORD flags, const D3DGAMMARAMP *ramp) PURE; + STDMETHOD_(void, GetGammaRamp)(THIS_ UINT swapchain_idx, D3DGAMMARAMP *ramp) PURE; + STDMETHOD(CreateTexture)(THIS_ UINT width, UINT height, UINT levels, DWORD usage, + D3DFORMAT format, D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle) PURE; + STDMETHOD(CreateVolumeTexture)(THIS_ UINT width, UINT height, UINT depth, UINT levels, DWORD usage, + D3DFORMAT format, D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle) PURE; + STDMETHOD(CreateCubeTexture)(THIS_ UINT edge_length, UINT levels, DWORD usage, + D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture9 **texture, HANDLE *shared_handle) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ UINT size, DWORD usage, DWORD fvf, D3DPOOL pool, + IDirect3DVertexBuffer9 **buffer, HANDLE *shared_handle) PURE; + STDMETHOD(CreateIndexBuffer)(THIS_ UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool, + IDirect3DIndexBuffer9 **buffer, HANDLE *shared_handle) PURE; + STDMETHOD(CreateRenderTarget)(THIS_ UINT width, UINT height, D3DFORMAT format, + D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, BOOL lockable, + IDirect3DSurface9 **surface, HANDLE *shared_handle) PURE; + STDMETHOD(CreateDepthStencilSurface)(THIS_ UINT width, UINT height, D3DFORMAT format, + D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, BOOL discard, + IDirect3DSurface9 **surface, HANDLE *shared_handle) PURE; + STDMETHOD(UpdateSurface)(THIS_ IDirect3DSurface9 *src_surface, const RECT *src_rect, + IDirect3DSurface9 *dst_surface, const POINT *dst_point) PURE; + STDMETHOD(UpdateTexture)(THIS_ IDirect3DBaseTexture9 *src_texture, IDirect3DBaseTexture9 *dst_texture) PURE; + STDMETHOD(GetRenderTargetData)(THIS_ IDirect3DSurface9 *render_target, IDirect3DSurface9 *dst_surface) PURE; + STDMETHOD(GetFrontBufferData)(THIS_ UINT swapchain_idx, IDirect3DSurface9 *dst_surface) PURE; + STDMETHOD(StretchRect)(THIS_ IDirect3DSurface9 *src_surface, const RECT *src_rect, + IDirect3DSurface9 *dst_surface, const RECT *dst_rect, D3DTEXTUREFILTERTYPE filter) PURE; + STDMETHOD(ColorFill)(THIS_ IDirect3DSurface9 *surface, const RECT *rect, D3DCOLOR colour) PURE; + STDMETHOD(CreateOffscreenPlainSurface)(THIS_ UINT width, UINT height, D3DFORMAT format, D3DPOOL pool, + IDirect3DSurface9 **surface, HANDLE *shared_handle) PURE; + STDMETHOD(SetRenderTarget)(THIS_ DWORD idx, IDirect3DSurface9 *surface) PURE; + STDMETHOD(GetRenderTarget)(THIS_ DWORD idx, IDirect3DSurface9 **surface) PURE; + STDMETHOD(SetDepthStencilSurface)(THIS_ IDirect3DSurface9 *depth_stencil) PURE; + STDMETHOD(GetDepthStencilSurface)(THIS_ IDirect3DSurface9 **depth_stencil) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(Clear)(THIS_ DWORD rect_count, const D3DRECT *rects, DWORD flags, + D3DCOLOR colour, float z, DWORD stencil) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE State, D3DMATRIX *matrix) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(SetViewport)(THIS_ const D3DVIEWPORT9 *viewport) PURE; + STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT9 *viewport) PURE; + STDMETHOD(SetMaterial)(THIS_ const D3DMATERIAL9 *material) PURE; + STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL9 *material) PURE; + STDMETHOD(SetLight)(THIS_ DWORD idx, const D3DLIGHT9 *light) PURE; + STDMETHOD(GetLight)(THIS_ DWORD idx, D3DLIGHT9 *light) PURE; + STDMETHOD(LightEnable)(THIS_ DWORD idx, BOOL enable) PURE; + STDMETHOD(GetLightEnable)(THIS_ DWORD idx, BOOL *enable) PURE; + STDMETHOD(SetClipPlane)(THIS_ DWORD idx, const float *plane) PURE; + STDMETHOD(GetClipPlane)(THIS_ DWORD idx, float *plane) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE state, DWORD value) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE state, DWORD *value) PURE; + STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE type, IDirect3DStateBlock9 **stateblock) PURE; + STDMETHOD(BeginStateBlock)(THIS) PURE; + STDMETHOD(EndStateBlock)(THIS_ IDirect3DStateBlock9 **stateblock) PURE; + STDMETHOD(SetClipStatus)(THIS_ const D3DCLIPSTATUS9 *clip_status) PURE; + STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS9 *clip_status) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD stage, IDirect3DBaseTexture9 **texture) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD stage, IDirect3DBaseTexture9 *texture) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value) PURE; + STDMETHOD(GetSamplerState)(THIS_ DWORD sampler_idx, D3DSAMPLERSTATETYPE state, DWORD *value) PURE; + STDMETHOD(SetSamplerState)(THIS_ DWORD sampler_idx, D3DSAMPLERSTATETYPE state, DWORD value) PURE; + STDMETHOD(ValidateDevice)(THIS_ DWORD *pass_count) PURE; + STDMETHOD(SetPaletteEntries)(THIS_ UINT palette_idx, const PALETTEENTRY *entries) PURE; + STDMETHOD(GetPaletteEntries)(THIS_ UINT palette_idx, PALETTEENTRY *entries) PURE; + STDMETHOD(SetCurrentTexturePalette)(THIS_ UINT palette_idx) PURE; + STDMETHOD(GetCurrentTexturePalette)(THIS_ UINT *palette_idx) PURE; + STDMETHOD(SetScissorRect)(THIS_ const RECT *rect) PURE; + STDMETHOD(GetScissorRect)(THIS_ RECT *rect) PURE; + STDMETHOD(SetSoftwareVertexProcessing)(THIS_ BOOL software) PURE; + STDMETHOD_(BOOL, GetSoftwareVertexProcessing)(THIS) PURE; + STDMETHOD(SetNPatchMode)(THIS_ float segment_count) PURE; + STDMETHOD_(float, GetNPatchMode)(THIS) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, UINT start_vertex, UINT primitive_count) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE primitive_type, INT base_vertex_idx, UINT min_vertex_idx, + UINT vertex_count, UINT start_idx, UINT primitive_count) PURE; + STDMETHOD(DrawPrimitiveUP)(THIS_ D3DPRIMITIVETYPE primitive_type, + UINT primitive_count, const void *data, UINT stride) PURE; + STDMETHOD(DrawIndexedPrimitiveUP)(THIS_ D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count, + UINT primitive_count, const void *index_data, D3DFORMAT index_format, const void *data, UINT stride) PURE; + STDMETHOD(ProcessVertices)(THIS_ UINT src_start_idx, UINT dst_idx, UINT vertex_count, + IDirect3DVertexBuffer9 *dst_buffer, IDirect3DVertexDeclaration9 *declaration, DWORD flags) PURE; + STDMETHOD(CreateVertexDeclaration)(THIS_ const D3DVERTEXELEMENT9 *elements, + IDirect3DVertexDeclaration9 **declaration) PURE; + STDMETHOD(SetVertexDeclaration)(THIS_ IDirect3DVertexDeclaration9 *declaration) PURE; + STDMETHOD(GetVertexDeclaration)(THIS_ IDirect3DVertexDeclaration9 **declaration) PURE; + STDMETHOD(SetFVF)(THIS_ DWORD fvf) PURE; + STDMETHOD(GetFVF)(THIS_ DWORD *fvf) PURE; + STDMETHOD(CreateVertexShader)(THIS_ const DWORD *byte_code, IDirect3DVertexShader9 **shader) PURE; + STDMETHOD(SetVertexShader)(THIS_ IDirect3DVertexShader9 *shader) PURE; + STDMETHOD(GetVertexShader)(THIS_ IDirect3DVertexShader9 **shader) PURE; + STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT reg_idx, const float *data, UINT count) PURE; + STDMETHOD(GetVertexShaderConstantF)(THIS_ UINT reg_idx, float *data, UINT count) PURE; + STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT reg_idx, const int *data, UINT count) PURE; + STDMETHOD(GetVertexShaderConstantI)(THIS_ UINT reg_idx, int *data, UINT count) PURE; + STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT reg_idx, const BOOL *data, UINT count) PURE; + STDMETHOD(GetVertexShaderConstantB)(THIS_ UINT reg_idx, BOOL *data, UINT count) PURE; + STDMETHOD(SetStreamSource)(THIS_ UINT stream_idx, IDirect3DVertexBuffer9 *buffer, UINT offset, UINT stride) PURE; + STDMETHOD(GetStreamSource)(THIS_ UINT stream_idx, IDirect3DVertexBuffer9 **buffer, UINT *offset, UINT *stride) PURE; + STDMETHOD(SetStreamSourceFreq)(THIS_ UINT stream_idx, UINT frequency) PURE; + STDMETHOD(GetStreamSourceFreq)(THIS_ UINT stream_idx, UINT *frequency) PURE; + STDMETHOD(SetIndices)(THIS_ IDirect3DIndexBuffer9 *buffer) PURE; + STDMETHOD(GetIndices)(THIS_ IDirect3DIndexBuffer9 **buffer) PURE; + STDMETHOD(CreatePixelShader)(THIS_ const DWORD *byte_code, IDirect3DPixelShader9 **shader) PURE; + STDMETHOD(SetPixelShader)(THIS_ IDirect3DPixelShader9 *shader) PURE; + STDMETHOD(GetPixelShader)(THIS_ IDirect3DPixelShader9 **shader) PURE; + STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT reg_idx, const float *data, UINT count) PURE; + STDMETHOD(GetPixelShaderConstantF)(THIS_ UINT reg_idx, float *data, UINT count) PURE; + STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT reg_idx, const int *data, UINT count) PURE; + STDMETHOD(GetPixelShaderConstantI)(THIS_ UINT reg_idx, int *data, UINT count) PURE; + STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT reg_idx, const BOOL *data, UINT count) PURE; + STDMETHOD(GetPixelShaderConstantB)(THIS_ UINT reg_idx, BOOL *data, UINT count) PURE; + STDMETHOD(DrawRectPatch)(THIS_ UINT handle, const float *segment_count, const D3DRECTPATCH_INFO *patch_info) PURE; + STDMETHOD(DrawTriPatch)(THIS_ UINT handle, const float *segment_count, const D3DTRIPATCH_INFO *patch_info) PURE; + STDMETHOD(DeletePatch)(THIS_ UINT handle) PURE; + STDMETHOD(CreateQuery)(THIS_ D3DQUERYTYPE type, IDirect3DQuery9 **query) PURE; + /* IDirect3DDevice9Ex */ + STDMETHOD(SetConvolutionMonoKernel)(THIS_ UINT width, UINT height, float *rows, float *columns) PURE; + STDMETHOD(ComposeRects)(THIS_ IDirect3DSurface9 *src_surface, IDirect3DSurface9 *dst_surface, + IDirect3DVertexBuffer9 *src_descs, UINT rect_count, IDirect3DVertexBuffer9 *dst_descs, + D3DCOMPOSERECTSOP operation, INT offset_x, INT offset_y) PURE; + STDMETHOD(PresentEx)(THIS_ const RECT *src_rect, const RECT *dst_rect, + HWND dst_window_override, const RGNDATA *dirty_region, DWORD flags) PURE; + STDMETHOD(GetGPUThreadPriority)(THIS_ INT *priority) PURE; + STDMETHOD(SetGPUThreadPriority)(THIS_ INT priority) PURE; + STDMETHOD(WaitForVBlank)(THIS_ UINT swapchain_idx) PURE; + STDMETHOD(CheckResourceResidency)(THIS_ IDirect3DResource9 **resources, UINT32 resource_count) PURE; + STDMETHOD(SetMaximumFrameLatency)(THIS_ UINT max_latency) PURE; + STDMETHOD(GetMaximumFrameLatency)(THIS_ UINT *max_latency) PURE; + STDMETHOD(CheckDeviceState)(THIS_ HWND dst_window) PURE; + STDMETHOD(CreateRenderTargetEx)(THIS_ UINT width, UINT height, D3DFORMAT format, + D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, BOOL lockable, + IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage) PURE; + STDMETHOD(CreateOffscreenPlainSurfaceEx)(THIS_ UINT width, UINT Height, D3DFORMAT format, + D3DPOOL pool, IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage) PURE; + STDMETHOD(CreateDepthStencilSurfaceEx)(THIS_ UINT width, UINT height, D3DFORMAT format, + D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, BOOL discard, + IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage) PURE; + STDMETHOD(ResetEx)(THIS_ D3DPRESENT_PARAMETERS *parameters, D3DDISPLAYMODEEX *mode) PURE; + STDMETHOD(GetDisplayModeEx)(THIS_ UINT swapchain_idx, D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/* IUnknown */ +#define IDirect3DDevice9Ex_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice9Ex_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice9Ex_Release(p) (p)->lpVtbl->Release(p) +/* IDirect3DDevice9 */ +#define IDirect3DDevice9Ex_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p) +#define IDirect3DDevice9Ex_GetAvailableTextureMem(p) (p)->lpVtbl->GetAvailableTextureMem(p) +#define IDirect3DDevice9Ex_EvictManagedResources(p) (p)->lpVtbl->EvictManagedResources(p) +#define IDirect3DDevice9Ex_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice9Ex_GetDeviceCaps(p,a) (p)->lpVtbl->GetDeviceCaps(p,a) +#define IDirect3DDevice9Ex_GetDisplayMode(p,a,b) (p)->lpVtbl->GetDisplayMode(p,a,b) +#define IDirect3DDevice9Ex_GetCreationParameters(p,a) (p)->lpVtbl->GetCreationParameters(p,a) +#define IDirect3DDevice9Ex_SetCursorProperties(p,a,b,c) (p)->lpVtbl->SetCursorProperties(p,a,b,c) +#define IDirect3DDevice9Ex_SetCursorPosition(p,a,b,c) (p)->lpVtbl->SetCursorPosition(p,a,b,c) +#define IDirect3DDevice9Ex_ShowCursor(p,a) (p)->lpVtbl->ShowCursor(p,a) +#define IDirect3DDevice9Ex_CreateAdditionalSwapChain(p,a,b) (p)->lpVtbl->CreateAdditionalSwapChain(p,a,b) +#define IDirect3DDevice9Ex_GetSwapChain(p,a,b) (p)->lpVtbl->GetSwapChain(p,a,b) +#define IDirect3DDevice9Ex_GetNumberOfSwapChains(p) (p)->lpVtbl->GetNumberOfSwapChains(p) +#define IDirect3DDevice9Ex_Reset(p,a) (p)->lpVtbl->Reset(p,a) +#define IDirect3DDevice9Ex_Present(p,a,b,c,d) (p)->lpVtbl->Present(p,a,b,c,d) +#define IDirect3DDevice9Ex_GetBackBuffer(p,a,b,c,d) (p)->lpVtbl->GetBackBuffer(p,a,b,c,d) +#define IDirect3DDevice9Ex_GetRasterStatus(p,a,b) (p)->lpVtbl->GetRasterStatus(p,a,b) +#define IDirect3DDevice9Ex_SetDialogBoxMode(p,a) (p)->lpVtbl->SetDialogBoxMode(p,a) +#define IDirect3DDevice9Ex_SetGammaRamp(p,a,b,c) (p)->lpVtbl->SetGammaRamp(p,a,b,c) +#define IDirect3DDevice9Ex_GetGammaRamp(p,a,b) (p)->lpVtbl->GetGammaRamp(p,a,b) +#define IDirect3DDevice9Ex_CreateTexture(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateTexture(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_CreateVolumeTexture(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateVolumeTexture(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9Ex_CreateCubeTexture(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateCubeTexture(p,a,b,c,d,e,f,g) +#define IDirect3DDevice9Ex_CreateVertexBuffer(p,a,b,c,d,e,f) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c,d,e,f) +#define IDirect3DDevice9Ex_CreateIndexBuffer(p,a,b,c,d,e,f) (p)->lpVtbl->CreateIndexBuffer(p,a,b,c,d,e,f) +#define IDirect3DDevice9Ex_CreateRenderTarget(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateRenderTarget(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_CreateDepthStencilSurface(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CreateDepthStencilSurface(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_UpdateSurface(p,a,b,c,d) (p)->lpVtbl->UpdateSurface(p,a,b,c,d) +#define IDirect3DDevice9Ex_UpdateTexture(p,a,b) (p)->lpVtbl->UpdateTexture(p,a,b) +#define IDirect3DDevice9Ex_GetRenderTargetData(p,a,b) (p)->lpVtbl->GetRenderTargetData(p,a,b) +#define IDirect3DDevice9Ex_GetFrontBufferData(p,a,b) (p)->lpVtbl->GetFrontBufferData(p,a,b) +#define IDirect3DDevice9Ex_StretchRect(p,a,b,c,d,e) (p)->lpVtbl->StretchRect(p,a,b,c,d,e) +#define IDirect3DDevice9Ex_ColorFill(p,a,b,c) (p)->lpVtbl->ColorFill(p,a,b,c) +#define IDirect3DDevice9Ex_CreateOffscreenPlainSurface(p,a,b,c,d,e,f) (p)->lpVtbl->CreateOffscreenPlainSurface(p,a,b,c,d,e,f) +#define IDirect3DDevice9Ex_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice9Ex_GetRenderTarget(p,a,b) (p)->lpVtbl->GetRenderTarget(p,a,b) +#define IDirect3DDevice9Ex_SetDepthStencilSurface(p,a) (p)->lpVtbl->SetDepthStencilSurface(p,a) +#define IDirect3DDevice9Ex_GetDepthStencilSurface(p,a) (p)->lpVtbl->GetDepthStencilSurface(p,a) +#define IDirect3DDevice9Ex_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice9Ex_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice9Ex_Clear(p,a,b,c,d,e,f) (p)->lpVtbl->Clear(p,a,b,c,d,e,f) +#define IDirect3DDevice9Ex_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice9Ex_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice9Ex_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice9Ex_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DDevice9Ex_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DDevice9Ex_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DDevice9Ex_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DDevice9Ex_SetLight(p,a,b) (p)->lpVtbl->SetLight(p,a,b) +#define IDirect3DDevice9Ex_GetLight(p,a,b) (p)->lpVtbl->GetLight(p,a,b) +#define IDirect3DDevice9Ex_LightEnable(p,a,b) (p)->lpVtbl->LightEnable(p,a,b) +#define IDirect3DDevice9Ex_GetLightEnable(p,a,b) (p)->lpVtbl->GetLightEnable(p,a,b) +#define IDirect3DDevice9Ex_SetClipPlane(p,a,b) (p)->lpVtbl->SetClipPlane(p,a,b) +#define IDirect3DDevice9Ex_GetClipPlane(p,a,b) (p)->lpVtbl->GetClipPlane(p,a,b) +#define IDirect3DDevice9Ex_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice9Ex_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice9Ex_CreateStateBlock(p,a,b) (p)->lpVtbl->CreateStateBlock(p,a,b) +#define IDirect3DDevice9Ex_BeginStateBlock(p) (p)->lpVtbl->BeginStateBlock(p) +#define IDirect3DDevice9Ex_EndStateBlock(p,a) (p)->lpVtbl->EndStateBlock(p,a) +#define IDirect3DDevice9Ex_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice9Ex_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice9Ex_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice9Ex_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice9Ex_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice9Ex_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice9Ex_GetSamplerState(p,a,b,c) (p)->lpVtbl->GetSamplerState(p,a,b,c) +#define IDirect3DDevice9Ex_SetSamplerState(p,a,b,c) (p)->lpVtbl->SetSamplerState(p,a,b,c) +#define IDirect3DDevice9Ex_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#define IDirect3DDevice9Ex_SetPaletteEntries(p,a,b) (p)->lpVtbl->SetPaletteEntries(p,a,b) +#define IDirect3DDevice9Ex_GetPaletteEntries(p,a,b) (p)->lpVtbl->GetPaletteEntries(p,a,b) +#define IDirect3DDevice9Ex_SetCurrentTexturePalette(p,a) (p)->lpVtbl->SetCurrentTexturePalette(p,a) +#define IDirect3DDevice9Ex_GetCurrentTexturePalette(p,a) (p)->lpVtbl->GetCurrentTexturePalette(p,a) +#define IDirect3DDevice9Ex_SetScissorRect(p,a) (p)->lpVtbl->SetScissorRect(p,a) +#define IDirect3DDevice9Ex_GetScissorRect(p,a) (p)->lpVtbl->GetScissorRect(p,a) +#define IDirect3DDevice9Ex_SetSoftwareVertexProcessing(p,a) (p)->lpVtbl->SetSoftwareVertexProcessing(p,a) +#define IDirect3DDevice9Ex_GetSoftwareVertexProcessing(p) (p)->lpVtbl->GetSoftwareVertexProcessing(p) +#define IDirect3DDevice9Ex_SetNPatchMode(p,a) (p)->lpVtbl->SetNPatchMode(p,a) +#define IDirect3DDevice9Ex_GetNPatchMode(p) (p)->lpVtbl->GetNPatchMode(p) +#define IDirect3DDevice9Ex_DrawPrimitive(p,a,b,c) (p)->lpVtbl->DrawPrimitive(p,a,b,c) +#define IDirect3DDevice9Ex_DrawIndexedPrimitive(p,a,b,c,d,e,f) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f) +#define IDirect3DDevice9Ex_DrawPrimitiveUP(p,a,b,c,d) (p)->lpVtbl->DrawPrimitiveUP(p,a,b,c,d) +#define IDirect3DDevice9Ex_DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_ProcessVertices(p,a,b,c,d,e,f) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e,f) +#define IDirect3DDevice9Ex_CreateVertexDeclaration(p,a,b) (p)->lpVtbl->CreateVertexDeclaration(p,a,b) +#define IDirect3DDevice9Ex_SetVertexDeclaration(p,a) (p)->lpVtbl->SetVertexDeclaration(p,a) +#define IDirect3DDevice9Ex_GetVertexDeclaration(p,a) (p)->lpVtbl->GetVertexDeclaration(p,a) +#define IDirect3DDevice9Ex_SetFVF(p,a) (p)->lpVtbl->SetFVF(p,a) +#define IDirect3DDevice9Ex_GetFVF(p,a) (p)->lpVtbl->GetFVF(p,a) +#define IDirect3DDevice9Ex_CreateVertexShader(p,a,b) (p)->lpVtbl->CreateVertexShader(p,a,b) +#define IDirect3DDevice9Ex_SetVertexShader(p,a) (p)->lpVtbl->SetVertexShader(p,a) +#define IDirect3DDevice9Ex_GetVertexShader(p,a) (p)->lpVtbl->GetVertexShader(p,a) +#define IDirect3DDevice9Ex_SetVertexShaderConstantF(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstantF(p,a,b,c) +#define IDirect3DDevice9Ex_GetVertexShaderConstantF(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstantF(p,a,b,c) +#define IDirect3DDevice9Ex_SetVertexShaderConstantI(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstantI(p,a,b,c) +#define IDirect3DDevice9Ex_GetVertexShaderConstantI(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstantI(p,a,b,c) +#define IDirect3DDevice9Ex_SetVertexShaderConstantB(p,a,b,c) (p)->lpVtbl->SetVertexShaderConstantB(p,a,b,c) +#define IDirect3DDevice9Ex_GetVertexShaderConstantB(p,a,b,c) (p)->lpVtbl->GetVertexShaderConstantB(p,a,b,c) +#define IDirect3DDevice9Ex_SetStreamSource(p,a,b,c,d) (p)->lpVtbl->SetStreamSource(p,a,b,c,d) +#define IDirect3DDevice9Ex_GetStreamSource(p,a,b,c,d) (p)->lpVtbl->GetStreamSource(p,a,b,c,d) +#define IDirect3DDevice9Ex_SetStreamSourceFreq(p,a,b) (p)->lpVtbl->SetStreamSourceFreq(p,a,b) +#define IDirect3DDevice9Ex_GetStreamSourceFreq(p,a,b) (p)->lpVtbl->GetStreamSourceFreq(p,a,b) +#define IDirect3DDevice9Ex_SetIndices(p,a) (p)->lpVtbl->SetIndices(p,a) +#define IDirect3DDevice9Ex_GetIndices(p,a) (p)->lpVtbl->GetIndices(p,a) +#define IDirect3DDevice9Ex_CreatePixelShader(p,a,b) (p)->lpVtbl->CreatePixelShader(p,a,b) +#define IDirect3DDevice9Ex_SetPixelShader(p,a) (p)->lpVtbl->SetPixelShader(p,a) +#define IDirect3DDevice9Ex_GetPixelShader(p,a) (p)->lpVtbl->GetPixelShader(p,a) +#define IDirect3DDevice9Ex_SetPixelShaderConstantF(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstantF(p,a,b,c) +#define IDirect3DDevice9Ex_GetPixelShaderConstantF(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstantF(p,a,b,c) +#define IDirect3DDevice9Ex_SetPixelShaderConstantI(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstantI(p,a,b,c) +#define IDirect3DDevice9Ex_GetPixelShaderConstantI(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstantI(p,a,b,c) +#define IDirect3DDevice9Ex_SetPixelShaderConstantB(p,a,b,c) (p)->lpVtbl->SetPixelShaderConstantB(p,a,b,c) +#define IDirect3DDevice9Ex_GetPixelShaderConstantB(p,a,b,c) (p)->lpVtbl->GetPixelShaderConstantB(p,a,b,c) +#define IDirect3DDevice9Ex_DrawRectPatch(p,a,b,c) (p)->lpVtbl->DrawRectPatch(p,a,b,c) +#define IDirect3DDevice9Ex_DrawTriPatch(p,a,b,c) (p)->lpVtbl->DrawTriPatch(p,a,b,c) +#define IDirect3DDevice9Ex_DeletePatch(p,a) (p)->lpVtbl->DeletePatch(p,a) +#define IDirect3DDevice9Ex_CreateQuery(p,a,b) (p)->lpVtbl->CreateQuery(p,a,b) +/* IDirect3DDevice9Ex */ +#define IDirect3DDevice9Ex_SetConvolutionMonoKernel(p,a,b,c,d) (p)->lpVtbl->SetConvolutionMonoKernel(p,a,b,c,d) +#define IDirect3DDevice9Ex_ComposeRects(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->ComposeRects(p,a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_PresentEx(p,a,b,c,d,e) (p)->lpVtbl->PresentEx(p,a,b,c,d,e) +#define IDirect3DDevice9Ex_GetGPUThreadPriority(p,a) (p)->lpVtbl->GetGPUThreadPriority(p,a) +#define IDirect3DDevice9Ex_SetGPUThreadPriority(p,a) (p)->lpVtbl->SetGPUThreadPriority(p,a) +#define IDirect3DDevice9Ex_WaitForVBlank(p,a) (p)->lpVtbl->WaitForVBlank(p,a) +#define IDirect3DDevice9Ex_CheckResourceResidency(p,a,b) (p)->lpVtbl->CheckResourceResidency(p,a,b) +#define IDirect3DDevice9Ex_SetMaximumFrameLatency(p,a) (p)->lpVtbl->SetMaximumFrameLatency(p,a) +#define IDirect3DDevice9Ex_GetMaximumFrameLatency(p,a) (p)->lpVtbl->GetMaximumFrameLatency(p,a) +#define IDirect3DDevice9Ex_CheckDeviceState(p,a) (p)->lpVtbl->CheckDeviceState(p,a) +#define IDirect3DDevice9Ex_CreateRenderTargetEx(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateRenderTargetEx(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9Ex_CreateOffscreenPlainSurfaceEx(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateOffscreenPlainSurfaceEx(p,a,b,c,d,e,f,g) +#define IDirect3DDevice9Ex_CreateDepthStencilSurfaceEx(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateDepthStencilSurfaceEx(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9Ex_ResetEx(p,a,b) (p)->lpVtbl->ResetEx(p,a,b) +#define IDirect3DDevice9Ex_GetDisplayModeEx(p,a,b,c) (p)->lpVtbl->GetDisplayModeEx(p,a,b,c) +#else +/* IUnknown */ +#define IDirect3DDevice9Ex_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice9Ex_AddRef(p) (p)->AddRef() +#define IDirect3DDevice9Ex_Release(p) (p)->Release() +/* IDirect3DDevice9 */ +#define IDirect3DDevice9Ex_TestCooperativeLevel(p) (p)->TestCooperativeLevel() +#define IDirect3DDevice9Ex_GetAvailableTextureMem(p) (p)->GetAvailableTextureMem() +#define IDirect3DDevice9Ex_EvictManagedResources(p) (p)->EvictManagedResources() +#define IDirect3DDevice9Ex_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice9Ex_GetDeviceCaps(p,a) (p)->GetDeviceCaps(a) +#define IDirect3DDevice9Ex_GetDisplayMode(p,a,b) (p)->GetDisplayMode(a,b) +#define IDirect3DDevice9Ex_GetCreationParameters(p,a) (p)->GetCreationParameters(a) +#define IDirect3DDevice9Ex_SetCursorProperties(p,a,b,c) (p)->SetCursorProperties(a,b,c) +#define IDirect3DDevice9Ex_SetCursorPosition(p,a,b,c) (p)->SetCursorPosition(a,b,c) +#define IDirect3DDevice9Ex_ShowCursor(p,a) (p)->ShowCursor(a) +#define IDirect3DDevice9Ex_CreateAdditionalSwapChain(p,a,b) (p)->CreateAdditionalSwapChain(a,b) +#define IDirect3DDevice9Ex_GetSwapChain(p,a,b) (p)->GetSwapChain(a,b) +#define IDirect3DDevice9Ex_GetNumberOfSwapChains(p) (p)->GetNumberOfSwapChains() +#define IDirect3DDevice9Ex_Reset(p,a) (p)->Reset(a) +#define IDirect3DDevice9Ex_Present(p,a,b,c,d) (p)->Present(a,b,c,d) +#define IDirect3DDevice9Ex_GetBackBuffer(p,a,b,c,d) (p)->GetBackBuffer(a,b,c,d) +#define IDirect3DDevice9Ex_GetRasterStatus(p,a,b) (p)->GetRasterStatus(a,b) +#define IDirect3DDevice9Ex_SetDialogBoxMode(p,a) (p)->SetDialogBoxMode(a) +#define IDirect3DDevice9Ex_SetGammaRamp(p,a,b,c) (p)->SetGammaRamp(a,b,c) +#define IDirect3DDevice9Ex_GetGammaRamp(p,a,b) (p)->GetGammaRamp(a,b) +#define IDirect3DDevice9Ex_CreateTexture(p,a,b,c,d,e,f,g,h) (p)->CreateTexture(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_CreateVolumeTexture(p,a,b,c,d,e,f,g,h,i) (p)->CreateVolumeTexture(a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9Ex_CreateCubeTexture(p,a,b,c,d,e,f,g) (p)->CreateCubeTexture(a,b,c,d,e,f,g) +#define IDirect3DDevice9Ex_CreateVertexBuffer(p,a,b,c,d,e,f) (p)->CreateVertexBuffer(a,b,c,d,e,f) +#define IDirect3DDevice9Ex_CreateIndexBuffer(p,a,b,c,d,e,f) (p)->CreateIndexBuffer(a,b,c,d,e,f) +#define IDirect3DDevice9Ex_CreateRenderTarget(p,a,b,c,d,e,f,g,h) (p)->CreateRenderTarget(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_CreateDepthStencilSurface(p,a,b,c,d,e,f,g,h) (p)->CreateDepthStencilSurface(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_UpdateSurface(p,a,b,c,d) (p)->UpdateSurface(a,b,c,d) +#define IDirect3DDevice9Ex_UpdateTexture(p,a,b) (p)->UpdateTexture(a,b) +#define IDirect3DDevice9Ex_GetRenderTargetData(p,a,b) (p)->GetRenderTargetData(a,b) +#define IDirect3DDevice9Ex_GetFrontBufferData(p,a,b) (p)->GetFrontBufferData(a,b) +#define IDirect3DDevice9Ex_StretchRect(p,a,b,c,d,e) (p)->StretchRect(a,b,c,d,e) +#define IDirect3DDevice9Ex_ColorFill(p,a,b,c) (p)->ColorFill(a,b,c) +#define IDirect3DDevice9Ex_CreateOffscreenPlainSurface(p,a,b,c,d,e,f) (p)->CreateOffscreenPlainSurface(a,b,c,d,e,f) +#define IDirect3DDevice9Ex_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice9Ex_GetRenderTarget(p,a,b) (p)->GetRenderTarget(a,b) +#define IDirect3DDevice9Ex_SetDepthStencilSurface(p,a) (p)->SetDepthStencilSurface(a) +#define IDirect3DDevice9Ex_GetDepthStencilSurface(p,a) (p)->GetDepthStencilSurface(a) +#define IDirect3DDevice9Ex_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice9Ex_EndScene(p) (p)->EndScene() +#define IDirect3DDevice9Ex_Clear(p,a,b,c,d,e,f) (p)->Clear(a,b,c,d,e,f) +#define IDirect3DDevice9Ex_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice9Ex_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice9Ex_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice9Ex_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DDevice9Ex_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DDevice9Ex_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DDevice9Ex_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DDevice9Ex_SetLight(p,a,b) (p)->SetLight(a,b) +#define IDirect3DDevice9Ex_GetLight(p,a,b) (p)->GetLight(a,b) +#define IDirect3DDevice9Ex_LightEnable(p,a,b) (p)->LightEnable(a,b) +#define IDirect3DDevice9Ex_GetLightEnable(p,a,b) (p)->GetLightEnable(a,b) +#define IDirect3DDevice9Ex_SetClipPlane(p,a,b) (p)->SetClipPlane(a,b) +#define IDirect3DDevice9Ex_GetClipPlane(p,a,b) (p)->GetClipPlane(a,b) +#define IDirect3DDevice9Ex_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice9Ex_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice9Ex_CreateStateBlock(p,a,b) (p)->CreateStateBlock(a,b) +#define IDirect3DDevice9Ex_BeginStateBlock(p) (p)->BeginStateBlock() +#define IDirect3DDevice9Ex_EndStateBlock(p,a) (p)->EndStateBlock(a) +#define IDirect3DDevice9Ex_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice9Ex_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice9Ex_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice9Ex_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice9Ex_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice9Ex_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice9Ex_GetSamplerState(p,a,b,c) (p)->GetSamplerState(a,b,c) +#define IDirect3DDevice9Ex_SetSamplerState(p,a,b,c) (p)->SetSamplerState(a,b,c) +#define IDirect3DDevice9Ex_ValidateDevice(p,a) (p)->ValidateDevice(a) +#define IDirect3DDevice9Ex_SetPaletteEntries(p,a,b) (p)->SetPaletteEntries(a,b) +#define IDirect3DDevice9Ex_GetPaletteEntries(p,a,b) (p)->GetPaletteEntries(a,b) +#define IDirect3DDevice9Ex_SetCurrentTexturePalette(p,a) (p)->SetCurrentTexturePalette(a) +#define IDirect3DDevice9Ex_GetCurrentTexturePalette(p,a) (p)->GetCurrentTexturePalette(a) +#define IDirect3DDevice9Ex_SetScissorRect(p,a) (p)->SetScissorRect(a) +#define IDirect3DDevice9Ex_GetScissorRect(p,a) (p)->GetScissorRect(a) +#define IDirect3DDevice9Ex_SetSoftwareVertexProcessing(p,a) (p)->SetSoftwareVertexProcessing(a) +#define IDirect3DDevice9Ex_GetSoftwareVertexProcessing(p) (p)->GetSoftwareVertexProcessing() +#define IDirect3DDevice9Ex_SetNPatchMode(p,a) (p)->SetNPatchMode(a) +#define IDirect3DDevice9Ex_GetNPatchMode(p) (p)->GetNPatchMode() +#define IDirect3DDevice9Ex_DrawPrimitive(p,a,b,c) (p)->DrawPrimitive(a,b,c) +#define IDirect3DDevice9Ex_DrawIndexedPrimitive(p,a,b,c,d,e,f) (p)->DrawIndexedPrimitive(a,b,c,d,e,f) +#define IDirect3DDevice9Ex_DrawPrimitiveUP(p,a,b,c,d) (p)->DrawPrimitiveUP(a,b,c,d) +#define IDirect3DDevice9Ex_DrawIndexedPrimitiveUP(p,a,b,c,d,e,f,g,h) (p)->DrawIndexedPrimitiveUP(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_ProcessVertices(p,a,b,c,d,e,f) (p)->ProcessVertices(a,b,c,d,e,f) +#define IDirect3DDevice9Ex_CreateVertexDeclaration(p,a,b) (p)->CreateVertexDeclaration(a,b) +#define IDirect3DDevice9Ex_SetVertexDeclaration(p,a) (p)->SetVertexDeclaration(a) +#define IDirect3DDevice9Ex_GetVertexDeclaration(p,a) (p)->GetVertexDeclaration(a) +#define IDirect3DDevice9Ex_SetFVF(p,a) (p)->SetFVF(a) +#define IDirect3DDevice9Ex_GetFVF(p,a) (p)->GetFVF(a) +#define IDirect3DDevice9Ex_CreateVertexShader(p,a,b) (p)->CreateVertexShader(a,b) +#define IDirect3DDevice9Ex_SetVertexShader(p,a) (p)->SetVertexShader(a) +#define IDirect3DDevice9Ex_GetVertexShader(p,a) (p)->GetVertexShader(a) +#define IDirect3DDevice9Ex_SetVertexShaderConstantF(p,a,b,c) (p)->SetVertexShaderConstantF(a,b,c) +#define IDirect3DDevice9Ex_GetVertexShaderConstantF(p,a,b,c) (p)->GetVertexShaderConstantF(a,b,c) +#define IDirect3DDevice9Ex_SetVertexShaderConstantI(p,a,b,c) (p)->SetVertexShaderConstantI(a,b,c) +#define IDirect3DDevice9Ex_GetVertexShaderConstantI(p,a,b,c) (p)->GetVertexShaderConstantI(a,b,c) +#define IDirect3DDevice9Ex_SetVertexShaderConstantB(p,a,b,c) (p)->SetVertexShaderConstantB(a,b,c) +#define IDirect3DDevice9Ex_GetVertexShaderConstantB(p,a,b,c) (p)->GetVertexShaderConstantB(a,b,c) +#define IDirect3DDevice9Ex_SetStreamSource(p,a,b,c,d) (p)->SetStreamSource(a,b,c,d) +#define IDirect3DDevice9Ex_GetStreamSource(p,a,b,c,d) (p)->GetStreamSource(a,b,c,d) +#define IDirect3DDevice9Ex_SetStreamSourceFreq(p,a,b) (p)->SetStreamSourceFreq(a,b) +#define IDirect3DDevice9Ex_GetStreamSourceFreq(p,a,b) (p)->GetStreamSourceFreq(a,b) +#define IDirect3DDevice9Ex_SetIndices(p,a) (p)->SetIndices(a) +#define IDirect3DDevice9Ex_GetIndices(p,a) (p)->GetIndices(a) +#define IDirect3DDevice9Ex_CreatePixelShader(p,a,b) (p)->CreatePixelShader(a,b) +#define IDirect3DDevice9Ex_SetPixelShader(p,a) (p)->SetPixelShader(a) +#define IDirect3DDevice9Ex_GetPixelShader(p,a) (p)->GetPixelShader(a) +#define IDirect3DDevice9Ex_SetPixelShaderConstantF(p,a,b,c) (p)->SetPixelShaderConstantF(a,b,c) +#define IDirect3DDevice9Ex_GetPixelShaderConstantF(p,a,b,c) (p)->GetPixelShaderConstantF(a,b,c) +#define IDirect3DDevice9Ex_SetPixelShaderConstantI(p,a,b,c) (p)->SetPixelShaderConstantI(a,b,c) +#define IDirect3DDevice9Ex_GetPixelShaderConstantI(p,a,b,c) (p)->GetPixelShaderConstantI(a,b,c) +#define IDirect3DDevice9Ex_SetPixelShaderConstantB(p,a,b,c) (p)->SetPixelShaderConstantB(a,b,c) +#define IDirect3DDevice9Ex_GetPixelShaderConstantB(p,a,b,c) (p)->GetPixelShaderConstantB(a,b,c) +#define IDirect3DDevice9Ex_DrawRectPatch(p,a,b,c) (p)->DrawRectPatch(a,b,c) +#define IDirect3DDevice9Ex_DrawTriPatch(p,a,b,c) (p)->DrawTriPatch(a,b,c) +#define IDirect3DDevice9Ex_DeletePatch(p,a) (p)->DeletePatch(a) +#define IDirect3DDevice9Ex_CreateQuery(p,a,b) (p)->CreateQuery(a,b) +/* IDirect3DDevice9Ex */ +#define IDirect3DDevice9Ex_SetConvolutionMonoKernel(p,a,b,c,d) (p)->SetConvolutionMonoKernel(a,b,c,d) +#define IDirect3DDevice9Ex_ComposeRects(p,a,b,c,d,e,f,g,h) (p)->ComposeRects(a,b,c,d,e,f,g,h) +#define IDirect3DDevice9Ex_PresentEx(p,a,b,c,d,e) (p)->PresentEx(a,b,c,d,e) +#define IDirect3DDevice9Ex_GetGPUThreadPriority(p,a) (p)->GetGPUThreadPriority(a) +#define IDirect3DDevice9Ex_SetGPUThreadPriority(p,a) (p)->SetGPUThreadPriority(a) +#define IDirect3DDevice9Ex_WaitForVBlank(p,a) (p)->WaitForVBlank(a) +#define IDirect3DDevice9Ex_CheckResourceResidency(p,a,b) (p)->CheckResourceResidency(a,b) +#define IDirect3DDevice9Ex_SetMaximumFrameLatency(p,a) (p)->SetMaximumFrameLatency(a) +#define IDirect3DDevice9Ex_GetMaximumFrameLatency(p,a) (p)->GetMaximumFrameLatency(a) +#define IDirect3DDevice9Ex_CheckDeviceState(p,a) (p)->CheckDeviceState(a) +#define IDirect3DDevice9Ex_CreateRenderTargetEx(p,a,b,c,d,e,f,g,h,i) (p)->CreateRenderTargetEx(a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9Ex_CreateOffscreenPlainSurfaceEx(p,a,b,c,d,e,f,g) (p)->CreateOffscreenPlainSurfaceEx(a,b,c,d,e,f,g) +#define IDirect3DDevice9Ex_CreateDepthStencilSurfaceEx(p,a,b,c,d,e,f,g,h,i) (p)->CreateDepthStencilSurfaceEx(a,b,c,d,e,f,g,h,i) +#define IDirect3DDevice9Ex_ResetEx(p,a,b) (p)->ResetEx(a,b) +#define IDirect3DDevice9Ex_GetDisplayModeEx(p,a,b,c) (p)->GetDisplayModeEx(a,b,c) +#endif + +#endif /* !defined(D3D_DISABLE_9EX) */ + +#ifdef __cplusplus +extern "C" { +#endif /* defined(__cplusplus) */ + +int WINAPI D3DPERF_BeginEvent(D3DCOLOR color, const WCHAR *name); +int WINAPI D3DPERF_EndEvent(void); +DWORD WINAPI D3DPERF_GetStatus(void); +BOOL WINAPI D3DPERF_QueryRepeatFrame(void); +void WINAPI D3DPERF_SetMarker(D3DCOLOR color, const WCHAR *name); +void WINAPI D3DPERF_SetOptions(DWORD options); +void WINAPI D3DPERF_SetRegion(D3DCOLOR color, const WCHAR *name); + +IDirect3D9 * WINAPI Direct3DCreate9(UINT sdk_version); +#ifndef D3D_DISABLE_9EX +HRESULT WINAPI Direct3DCreate9Ex(UINT sdk_version, IDirect3D9Ex **d3d9ex); +#endif + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + + +#endif /* _D3D9_H_ */ diff --git a/WineFix/lib/d2d1/include/windows/d3d9caps.h b/WineFix/lib/d2d1/include/windows/d3d9caps.h new file mode 100644 index 0000000..ac21fac --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d9caps.h @@ -0,0 +1,455 @@ +/* + * Copyright (C) 2002-2003 Jason Edmeades + * Raphael Junqueira + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D9CAPS_H +#define __WINE_D3D9CAPS_H + +#ifdef __i386__ +#pragma pack(push,4) +#endif + +/* + * Definitions + */ +#define D3DCAPS_OVERLAY __MSABI_LONG(0x00000800) +#define D3DCAPS_READ_SCANLINE __MSABI_LONG(0x00020000) + +#define D3DCURSORCAPS_COLOR 1 +#define D3DCURSORCAPS_LOWRES 2 + + +#define D3DDEVCAPS2_STREAMOFFSET __MSABI_LONG(0x00000001) +#define D3DDEVCAPS2_DMAPNPATCH __MSABI_LONG(0x00000002) +#define D3DDEVCAPS2_ADAPTIVETESSRTPATCH __MSABI_LONG(0x00000004) +#define D3DDEVCAPS2_ADAPTIVETESSNPATCH __MSABI_LONG(0x00000008) +#define D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES __MSABI_LONG(0x00000010) +#define D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH __MSABI_LONG(0x00000020) +#define D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET __MSABI_LONG(0x00000040) + +#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x0000010 +#define D3DDEVCAPS_EXECUTEVIDEOMEMORY 0x0000020 +#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x0000040 +#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x0000080 +#define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x0000100 +#define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x0000200 +#define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x0000400 +#define D3DDEVCAPS_CANRENDERAFTERFLIP 0x0000800 +#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x0001000 +#define D3DDEVCAPS_DRAWPRIMITIVES2 0x0002000 +#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x0004000 +#define D3DDEVCAPS_DRAWPRIMITIVES2EX 0x0008000 +#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x0010000 +#define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x0020000 +#define D3DDEVCAPS_HWRASTERIZATION 0x0080000 +#define D3DDEVCAPS_PUREDEVICE 0x0100000 +#define D3DDEVCAPS_QUINTICRTPATCHES 0x0200000 +#define D3DDEVCAPS_RTPATCHES 0x0400000 +#define D3DDEVCAPS_RTPATCHHANDLEZERO 0x0800000 +#define D3DDEVCAPS_NPATCHES 0x1000000 + +#define D3DFVFCAPS_TEXCOORDCOUNTMASK 0x00FFFF +#define D3DFVFCAPS_DONOTSTRIPELEMENTS 0x080000 +#define D3DFVFCAPS_PSIZE 0x100000 + +#define D3DLINECAPS_TEXTURE 0x01 +#define D3DLINECAPS_ZTEST 0x02 +#define D3DLINECAPS_BLEND 0x04 +#define D3DLINECAPS_ALPHACMP 0x08 +#define D3DLINECAPS_FOG 0x10 +#define D3DLINECAPS_ANTIALIAS 0x20 + +#define D3DPBLENDCAPS_ZERO __MSABI_LONG(0x00000001) +#define D3DPBLENDCAPS_ONE __MSABI_LONG(0x00000002) +#define D3DPBLENDCAPS_SRCCOLOR __MSABI_LONG(0x00000004) +#define D3DPBLENDCAPS_INVSRCCOLOR __MSABI_LONG(0x00000008) +#define D3DPBLENDCAPS_SRCALPHA __MSABI_LONG(0x00000010) +#define D3DPBLENDCAPS_INVSRCALPHA __MSABI_LONG(0x00000020) +#define D3DPBLENDCAPS_DESTALPHA __MSABI_LONG(0x00000040) +#define D3DPBLENDCAPS_INVDESTALPHA __MSABI_LONG(0x00000080) +#define D3DPBLENDCAPS_DESTCOLOR __MSABI_LONG(0x00000100) +#define D3DPBLENDCAPS_INVDESTCOLOR __MSABI_LONG(0x00000200) +#define D3DPBLENDCAPS_SRCALPHASAT __MSABI_LONG(0x00000400) +#define D3DPBLENDCAPS_BOTHSRCALPHA __MSABI_LONG(0x00000800) +#define D3DPBLENDCAPS_BOTHINVSRCALPHA __MSABI_LONG(0x00001000) +#define D3DPBLENDCAPS_BLENDFACTOR __MSABI_LONG(0x00002000) +#ifndef D3D_DISABLE_9EX +#define D3DPBLENDCAPS_SRCCOLOR2 __MSABI_LONG(0x00004000) +#define D3DPBLENDCAPS_INVSRCCOLOR2 __MSABI_LONG(0x00008000) +#endif + +#define D3DPCMPCAPS_NEVER 0x01 +#define D3DPCMPCAPS_LESS 0x02 +#define D3DPCMPCAPS_EQUAL 0x04 +#define D3DPCMPCAPS_LESSEQUAL 0x08 +#define D3DPCMPCAPS_GREATER 0x10 +#define D3DPCMPCAPS_NOTEQUAL 0x20 +#define D3DPCMPCAPS_GREATEREQUAL 0x40 +#define D3DPCMPCAPS_ALWAYS 0x80 + +#define D3DPMISCCAPS_MASKZ __MSABI_LONG(0x00000002) +#define D3DPMISCCAPS_LINEPATTERNREP __MSABI_LONG(0x00000004) +#define D3DPMISCCAPS_CULLNONE __MSABI_LONG(0x00000010) +#define D3DPMISCCAPS_CULLCW __MSABI_LONG(0x00000020) +#define D3DPMISCCAPS_CULLCCW __MSABI_LONG(0x00000040) +#define D3DPMISCCAPS_COLORWRITEENABLE __MSABI_LONG(0x00000080) +#define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS __MSABI_LONG(0x00000100) +#define D3DPMISCCAPS_CLIPTLVERTS __MSABI_LONG(0x00000200) +#define D3DPMISCCAPS_TSSARGTEMP __MSABI_LONG(0x00000400) +#define D3DPMISCCAPS_BLENDOP __MSABI_LONG(0x00000800) +#define D3DPMISCCAPS_NULLREFERENCE __MSABI_LONG(0x00001000) +#define D3DPMISCCAPS_INDEPENDENTWRITEMASKS __MSABI_LONG(0x00004000) +#define D3DPMISCCAPS_PERSTAGECONSTANT __MSABI_LONG(0x00008000) +#define D3DPMISCCAPS_FOGANDSPECULARALPHA __MSABI_LONG(0x00010000) +#define D3DPMISCCAPS_SEPARATEALPHABLEND __MSABI_LONG(0x00020000) +#define D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS __MSABI_LONG(0x00040000) +#define D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING __MSABI_LONG(0x00080000) +#define D3DPMISCCAPS_FOGVERTEXCLAMPED __MSABI_LONG(0x00100000) +#ifndef D3D_DISABLE_9EX +#define D3DPMISCCAPS_POSTBLENDSRGBCONVERT __MSABI_LONG(0x00200000) +#endif + +#define D3DPRASTERCAPS_DITHER __MSABI_LONG(0x00000001) +#define D3DPRASTERCAPS_ZTEST __MSABI_LONG(0x00000010) +#define D3DPRASTERCAPS_FOGVERTEX __MSABI_LONG(0x00000080) +#define D3DPRASTERCAPS_FOGTABLE __MSABI_LONG(0x00000100) +#define D3DPRASTERCAPS_MIPMAPLODBIAS __MSABI_LONG(0x00002000) +#define D3DPRASTERCAPS_ZBUFFERLESSHSR __MSABI_LONG(0x00008000) +#define D3DPRASTERCAPS_FOGRANGE __MSABI_LONG(0x00010000) +#define D3DPRASTERCAPS_ANISOTROPY __MSABI_LONG(0x00020000) +#define D3DPRASTERCAPS_WBUFFER __MSABI_LONG(0x00040000) +#define D3DPRASTERCAPS_WFOG __MSABI_LONG(0x00100000) +#define D3DPRASTERCAPS_ZFOG __MSABI_LONG(0x00200000) +#define D3DPRASTERCAPS_COLORPERSPECTIVE __MSABI_LONG(0x00400000) +#define D3DPRASTERCAPS_SCISSORTEST __MSABI_LONG(0x01000000) +#define D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS __MSABI_LONG(0x02000000) +#define D3DPRASTERCAPS_DEPTHBIAS __MSABI_LONG(0x04000000) +#define D3DPRASTERCAPS_MULTISAMPLE_TOGGLE __MSABI_LONG(0x08000000) + +#define D3DPRESENT_INTERVAL_DEFAULT 0x00000000 +#define D3DPRESENT_INTERVAL_ONE 0x00000001 +#define D3DPRESENT_INTERVAL_TWO 0x00000002 +#define D3DPRESENT_INTERVAL_THREE 0x00000004 +#define D3DPRESENT_INTERVAL_FOUR 0x00000008 +#define D3DPRESENT_INTERVAL_IMMEDIATE 0x80000000 + +#define D3DPSHADECAPS_COLORGOURAUDRGB 0x00008 +#define D3DPSHADECAPS_SPECULARGOURAUDRGB 0x00200 +#define D3DPSHADECAPS_ALPHAGOURAUDBLEND 0x04000 +#define D3DPSHADECAPS_FOGGOURAUD 0x80000 + +#define D3DPTADDRESSCAPS_WRAP 0x01 +#define D3DPTADDRESSCAPS_MIRROR 0x02 +#define D3DPTADDRESSCAPS_CLAMP 0x04 +#define D3DPTADDRESSCAPS_BORDER 0x08 +#define D3DPTADDRESSCAPS_INDEPENDENTUV 0x10 +#define D3DPTADDRESSCAPS_MIRRORONCE 0x20 + +#define D3DPTEXTURECAPS_PERSPECTIVE __MSABI_LONG(0x00000001) +#define D3DPTEXTURECAPS_POW2 __MSABI_LONG(0x00000002) +#define D3DPTEXTURECAPS_ALPHA __MSABI_LONG(0x00000004) +#define D3DPTEXTURECAPS_SQUAREONLY __MSABI_LONG(0x00000020) +#define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE __MSABI_LONG(0x00000040) +#define D3DPTEXTURECAPS_ALPHAPALETTE __MSABI_LONG(0x00000080) +#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL __MSABI_LONG(0x00000100) +#define D3DPTEXTURECAPS_PROJECTED __MSABI_LONG(0x00000400) +#define D3DPTEXTURECAPS_CUBEMAP __MSABI_LONG(0x00000800) +#define D3DPTEXTURECAPS_VOLUMEMAP __MSABI_LONG(0x00002000) +#define D3DPTEXTURECAPS_MIPMAP __MSABI_LONG(0x00004000) +#define D3DPTEXTURECAPS_MIPVOLUMEMAP __MSABI_LONG(0x00008000) +#define D3DPTEXTURECAPS_MIPCUBEMAP __MSABI_LONG(0x00010000) +#define D3DPTEXTURECAPS_CUBEMAP_POW2 __MSABI_LONG(0x00020000) +#define D3DPTEXTURECAPS_VOLUMEMAP_POW2 __MSABI_LONG(0x00040000) +#define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV __MSABI_LONG(0x00200000) + +#define D3DPTFILTERCAPS_MINFPOINT __MSABI_LONG(0x00000100) +#define D3DPTFILTERCAPS_MINFLINEAR __MSABI_LONG(0x00000200) +#define D3DPTFILTERCAPS_MINFANISOTROPIC __MSABI_LONG(0x00000400) +#define D3DPTFILTERCAPS_MINFPYRAMIDALQUAD __MSABI_LONG(0x00000800) +#define D3DPTFILTERCAPS_MINFGAUSSIANQUAD __MSABI_LONG(0x00001000) +#define D3DPTFILTERCAPS_MIPFPOINT __MSABI_LONG(0x00010000) +#define D3DPTFILTERCAPS_MIPFLINEAR __MSABI_LONG(0x00020000) +#ifndef D3D_DISABLE_9EX +#define D3DPTFILTERCAPS_CONVOLUTIONMONO __MSABI_LONG(0x00040000) +#endif +#define D3DPTFILTERCAPS_MAGFPOINT __MSABI_LONG(0x01000000) +#define D3DPTFILTERCAPS_MAGFLINEAR __MSABI_LONG(0x02000000) +#define D3DPTFILTERCAPS_MAGFANISOTROPIC __MSABI_LONG(0x04000000) +#define D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD __MSABI_LONG(0x08000000) +#define D3DPTFILTERCAPS_MAGFGAUSSIANQUAD __MSABI_LONG(0x10000000) + +#define D3DSTENCILCAPS_KEEP 0x01 +#define D3DSTENCILCAPS_ZERO 0x02 +#define D3DSTENCILCAPS_REPLACE 0x04 +#define D3DSTENCILCAPS_INCRSAT 0x08 +#define D3DSTENCILCAPS_DECRSAT 0x10 +#define D3DSTENCILCAPS_INVERT 0x20 +#define D3DSTENCILCAPS_INCR 0x40 +#define D3DSTENCILCAPS_DECR 0x80 +#define D3DSTENCILCAPS_TWOSIDED 0x100 + +#define D3DTEXOPCAPS_DISABLE 0x0000001 +#define D3DTEXOPCAPS_SELECTARG1 0x0000002 +#define D3DTEXOPCAPS_SELECTARG2 0x0000004 +#define D3DTEXOPCAPS_MODULATE 0x0000008 +#define D3DTEXOPCAPS_MODULATE2X 0x0000010 +#define D3DTEXOPCAPS_MODULATE4X 0x0000020 +#define D3DTEXOPCAPS_ADD 0x0000040 +#define D3DTEXOPCAPS_ADDSIGNED 0x0000080 +#define D3DTEXOPCAPS_ADDSIGNED2X 0x0000100 +#define D3DTEXOPCAPS_SUBTRACT 0x0000200 +#define D3DTEXOPCAPS_ADDSMOOTH 0x0000400 +#define D3DTEXOPCAPS_BLENDDIFFUSEALPHA 0x0000800 +#define D3DTEXOPCAPS_BLENDTEXTUREALPHA 0x0001000 +#define D3DTEXOPCAPS_BLENDFACTORALPHA 0x0002000 +#define D3DTEXOPCAPS_BLENDTEXTUREALPHAPM 0x0004000 +#define D3DTEXOPCAPS_BLENDCURRENTALPHA 0x0008000 +#define D3DTEXOPCAPS_PREMODULATE 0x0010000 +#define D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR 0x0020000 +#define D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA 0x0040000 +#define D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR 0x0080000 +#define D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA 0x0100000 +#define D3DTEXOPCAPS_BUMPENVMAP 0x0200000 +#define D3DTEXOPCAPS_BUMPENVMAPLUMINANCE 0x0400000 +#define D3DTEXOPCAPS_DOTPRODUCT3 0x0800000 +#define D3DTEXOPCAPS_MULTIPLYADD 0x1000000 +#define D3DTEXOPCAPS_LERP 0x2000000 + +#define D3DVTXPCAPS_TEXGEN __MSABI_LONG(0x00000001) +#define D3DVTXPCAPS_MATERIALSOURCE7 __MSABI_LONG(0x00000002) +#define D3DVTXPCAPS_DIRECTIONALLIGHTS __MSABI_LONG(0x00000008) +#define D3DVTXPCAPS_POSITIONALLIGHTS __MSABI_LONG(0x00000010) +#define D3DVTXPCAPS_LOCALVIEWER __MSABI_LONG(0x00000020) +#define D3DVTXPCAPS_TWEENING __MSABI_LONG(0x00000040) +#define D3DVTXPCAPS_TEXGEN_SPHEREMAP __MSABI_LONG(0x00000100) +#define D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER __MSABI_LONG(0x00000200) + +#define D3DDTCAPS_UBYTE4 __MSABI_LONG(0x00000001) +#define D3DDTCAPS_UBYTE4N __MSABI_LONG(0x00000002) +#define D3DDTCAPS_SHORT2N __MSABI_LONG(0x00000004) +#define D3DDTCAPS_SHORT4N __MSABI_LONG(0x00000008) +#define D3DDTCAPS_USHORT2N __MSABI_LONG(0x00000010) +#define D3DDTCAPS_USHORT4N __MSABI_LONG(0x00000020) +#define D3DDTCAPS_UDEC3 __MSABI_LONG(0x00000040) +#define D3DDTCAPS_DEC3N __MSABI_LONG(0x00000080) +#define D3DDTCAPS_FLOAT16_2 __MSABI_LONG(0x00000100) +#define D3DDTCAPS_FLOAT16_4 __MSABI_LONG(0x00000200) + +#define D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD __MSABI_LONG(0x00000020) +#define D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION __MSABI_LONG(0x00000080) +#define D3DCAPS3_COPY_TO_VIDMEM __MSABI_LONG(0x00000100) +#define D3DCAPS3_COPY_TO_SYSTEMMEM __MSABI_LONG(0x00000200) +#define D3DCAPS3_DXVAHD __MSABI_LONG(0x00000400) +#define D3DCAPS3_DXVAHD_LIMITED __MSABI_LONG(0x00000800) +#define D3DCAPS3_RESERVED __MSABI_LONG(0x8000001F) + +#define D3DCAPS2_FULLSCREENGAMMA __MSABI_LONG(0x00020000) +#define D3DCAPS2_CANCALIBRATEGAMMA __MSABI_LONG(0x00100000) +#define D3DCAPS2_RESERVED __MSABI_LONG(0x02000000) +#define D3DCAPS2_CANMANAGERESOURCE __MSABI_LONG(0x10000000) +#define D3DCAPS2_DYNAMICTEXTURES __MSABI_LONG(0x20000000) +#define D3DCAPS2_CANAUTOGENMIPMAP __MSABI_LONG(0x40000000) +#ifndef D3D_DISABLE_9EX +#define D3DCAPS2_CANSHARERESOURCE __MSABI_LONG(0x80000000) +#endif + +#define D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH 24 +#define D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH 0 +#define D3DVS20_MAX_NUMTEMPS 32 +#define D3DVS20_MIN_NUMTEMPS 12 +#define D3DVS20_MAX_STATICFLOWCONTROLDEPTH 4 +#define D3DVS20_MIN_STATICFLOWCONTROLDEPTH 1 + +#define D3DVS20CAPS_PREDICATION (1 << 0) + +#define D3DPS20CAPS_ARBITRARYSWIZZLE (1 << 0) +#define D3DPS20CAPS_GRADIENTINSTRUCTIONS (1 << 1) +#define D3DPS20CAPS_PREDICATION (1 << 2) +#define D3DPS20CAPS_NODEPENDENTREADLIMIT (1 << 3) +#define D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT (1 << 4) + +#define D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH 24 +#define D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH 0 +#define D3DPS20_MAX_NUMTEMPS 32 +#define D3DPS20_MIN_NUMTEMPS 12 +#define D3DPS20_MAX_STATICFLOWCONTROLDEPTH 4 +#define D3DPS20_MIN_STATICFLOWCONTROLDEPTH 0 +#define D3DPS20_MAX_NUMINSTRUCTIONSLOTS 512 +#define D3DPS20_MIN_NUMINSTRUCTIONSLOTS 96 + +#define D3DMIN30SHADERINSTRUCTIONS 512 +#define D3DMAX30SHADERINSTRUCTIONS 32768 + + +typedef struct _D3DVSHADERCAPS2_0 { + DWORD Caps; + INT DynamicFlowControlDepth; + INT NumTemps; + INT StaticFlowControlDepth; +} D3DVSHADERCAPS2_0; + +typedef struct _D3DPSHADERCAPS2_0 { + DWORD Caps; + INT DynamicFlowControlDepth; + INT NumTemps; + INT StaticFlowControlDepth; + INT NumInstructionSlots; +} D3DPSHADERCAPS2_0; + +/* + * The d3dcaps9 structure + */ +typedef struct _D3DCAPS9 { + D3DDEVTYPE DeviceType; + UINT AdapterOrdinal; + + DWORD Caps; + DWORD Caps2; + DWORD Caps3; + DWORD PresentationIntervals; + + DWORD CursorCaps; + + DWORD DevCaps; + + DWORD PrimitiveMiscCaps; + DWORD RasterCaps; + DWORD ZCmpCaps; + DWORD SrcBlendCaps; + DWORD DestBlendCaps; + DWORD AlphaCmpCaps; + DWORD ShadeCaps; + DWORD TextureCaps; + DWORD TextureFilterCaps; + DWORD CubeTextureFilterCaps; + DWORD VolumeTextureFilterCaps; + DWORD TextureAddressCaps; + DWORD VolumeTextureAddressCaps; + + DWORD LineCaps; + + DWORD MaxTextureWidth, MaxTextureHeight; + DWORD MaxVolumeExtent; + + DWORD MaxTextureRepeat; + DWORD MaxTextureAspectRatio; + DWORD MaxAnisotropy; + float MaxVertexW; + + float GuardBandLeft; + float GuardBandTop; + float GuardBandRight; + float GuardBandBottom; + + float ExtentsAdjust; + DWORD StencilCaps; + + DWORD FVFCaps; + DWORD TextureOpCaps; + DWORD MaxTextureBlendStages; + DWORD MaxSimultaneousTextures; + + DWORD VertexProcessingCaps; + DWORD MaxActiveLights; + DWORD MaxUserClipPlanes; + DWORD MaxVertexBlendMatrices; + DWORD MaxVertexBlendMatrixIndex; + + float MaxPointSize; + + DWORD MaxPrimitiveCount; + DWORD MaxVertexIndex; + DWORD MaxStreams; + DWORD MaxStreamStride; + + DWORD VertexShaderVersion; + DWORD MaxVertexShaderConst; + + DWORD PixelShaderVersion; + float PixelShader1xMaxValue; + + /* DX 9 */ + DWORD DevCaps2; + + float MaxNpatchTessellationLevel; + DWORD Reserved5; + + UINT MasterAdapterOrdinal; + UINT AdapterOrdinalInGroup; + UINT NumberOfAdaptersInGroup; + DWORD DeclTypes; + DWORD NumSimultaneousRTs; + DWORD StretchRectFilterCaps; + D3DVSHADERCAPS2_0 VS20Caps; + D3DPSHADERCAPS2_0 PS20Caps; + DWORD VertexTextureFilterCaps; + DWORD MaxVShaderInstructionsExecuted; + DWORD MaxPShaderInstructionsExecuted; + DWORD MaxVertexShader30InstructionSlots; + DWORD MaxPixelShader30InstructionSlots; + +} D3DCAPS9; + +#ifndef D3D_DISABLE_9EX + +#define D3DOVERLAYCAPS_FULLRANGERGB 0x00000001 +#define D3DOVERLAYCAPS_LIMITEDRANGERGB 0x00000002 +#define D3DOVERLAYCAPS_YCbCr_BT601 0x00000004 +#define D3DOVERLAYCAPS_YCbCr_BT709 0x00000008 +#define D3DOVERLAYCAPS_YCbCr_BT601_xvYCC 0x00000010 +#define D3DOVERLAYCAPS_YCbCr_BT709_xvYCC 0x00000020 +#define D3DOVERLAYCAPS_STRETCHX 0x00000040 +#define D3DOVERLAYCAPS_STRETCHY 0x00000080 + +typedef struct _D3DOVERLAYCAPS { + UINT Caps; + UINT MaxOverlayDisplayWidth; + UINT MaxOverlayDisplayHeight; +} D3DOVERLAYCAPS; + +#define D3DCPCAPS_SOFTWARE 0x00000001 +#define D3DCPCAPS_HARDWARE 0x00000002 +#define D3DCPCAPS_PROTECTIONALWAYSON 0x00000004 +#define D3DCPCAPS_PARTIALDECRYPTION 0x00000008 +#define D3DCPCAPS_CONTENTKEY 0x00000010 +#define D3DCPCAPS_FRESHENSESSIONKEY 0x00000020 +#define D3DCPCAPS_ENCRYPTEDREADBACK 0x00000040 +#define D3DCPCAPS_ENCRYPTEDREADBACKKEY 0x00000080 +#define D3DCPCAPS_SEQUENTIAL_CTR_IV 0x00000100 +#define D3DCPCAPS_ENCRYPTSLICEDATAONLY 0x00000200 + +typedef struct _D3DCONTENTPROTECTIONCAPS { + DWORD Caps; + GUID KeyExchangeType; + UINT BufferAlignmentStart; + UINT BlockAlignmentSize; + ULONGLONG ProtectedMemorySize; +} D3DCONTENTPROTECTIONCAPS; + +DEFINE_GUID(D3DCRYPTOTYPE_AES128_CTR, 0x9b6bd711, 0x4f74, 0x41c9, 0x9e, 0x7b, 0xb, 0xe2, 0xd7, 0xd9, 0x3b, 0x4f); +DEFINE_GUID(D3DCRYPTOTYPE_PROPRIETARY, 0xab4e9afd, 0x1d1c, 0x46e6, 0xa7, 0x2f, 0x8, 0x69, 0x91, 0x7b, 0xd, 0xe8); +DEFINE_GUID(D3DKEYEXCHANGE_RSAES_OAEP, 0xc1949895, 0xd72a, 0x4a1d, 0x8e, 0x5d, 0xed, 0x85, 0x7d, 0x17, 0x15, 0x20); +DEFINE_GUID(D3DKEYEXCHANGE_DXVA, 0x43d3775c, 0x38e5, 0x4924, 0x8d, 0x86, 0xd3, 0xfc, 0xcf, 0x15, 0x3e, 0x9b); + +#endif + +#ifdef __i386__ +#pragma pack(pop) +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3d9on12.idl b/WineFix/lib/d2d1/include/windows/d3d9on12.idl new file mode 100644 index 0000000..1ae28ca --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d9on12.idl @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2024 Mohamad Al-Jaf + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +cpp_quote("#include ") +import "d3d12.idl"; + +interface IDirect3D9; +interface IDirect3DResource9; + +#define MAX_D3D9ON12_QUEUES 2 + +typedef struct D3D9ON12_ARGS +{ + BOOL Enable9On12; + IUnknown *pD3D12Device; + IUnknown *ppD3D12Queues[MAX_D3D9ON12_QUEUES]; + UINT NumQueues; + UINT NodeMask; +} D3D9ON12_ARGS; + +typedef IDirect3D9 * (__stdcall *PFN_Direct3DCreate9On12)(UINT sdk_version, D3D9ON12_ARGS *d3d9on12_args, UINT d3d9on12_args_count); +IDirect3D9 * __stdcall Direct3DCreate9On12(UINT,D3D9ON12_ARGS *,UINT); + +typedef struct IDirect3DDevice9On12 *LPDIRECT3DDEVICE9ON12, *PDIRECT3DDEVICE9ON12; + +[ + local, + object, + uuid(e7fda234-b589-4049-940d-8878977531c8) +] +interface IDirect3DDevice9On12 : IUnknown +{ + HRESULT GetD3D12Device(REFIID riid, void **out); + HRESULT UnwrapUnderlyingResource(IDirect3DResource9 *resource, ID3D12CommandQueue *queue, REFIID riid, void **out); + HRESULT ReturnUnderlyingResource(IDirect3DResource9 *resource, UINT fence_count, UINT64 *signal_values, ID3D12Fence **fences); +} diff --git a/WineFix/lib/d2d1/include/windows/d3d9types.h b/WineFix/lib/d2d1/include/windows/d3d9types.h new file mode 100644 index 0000000..4b822d4 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3d9types.h @@ -0,0 +1,1638 @@ +/* + * Copyright (C) 2002-2003 Jason Edmeades + * Copyright (C) 2002-2003 Raphael Junqueira + * Copyright (C) 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D9TYPES_H +#define __WINE_D3D9TYPES_H + +#ifdef __i386__ +#pragma pack(push,4) +#endif + +/***************************************************************************** + * Direct 3D v9 #defines + */ +#define D3DCLEAR_TARGET __MSABI_LONG(0x00000001) +#define D3DCLEAR_ZBUFFER __MSABI_LONG(0x00000002) +#define D3DCLEAR_STENCIL __MSABI_LONG(0x00000004) + +#define D3DCLIPPLANE0 (1 << 0) +#define D3DCLIPPLANE1 (1 << 1) +#define D3DCLIPPLANE2 (1 << 2) +#define D3DCLIPPLANE3 (1 << 3) +#define D3DCLIPPLANE4 (1 << 4) +#define D3DCLIPPLANE5 (1 << 5) + +#define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xffu)<<24)|(((r)&0xffu)<<16)|(((g)&0xffu)<<8)|((b)&0xffu))) +#define D3DCOLOR_COLORVALUE(r,g,b,a) D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f)) +#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b) +#define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b) +#define D3DCOLOR_XYUV(y,u,v) D3DCOLOR_ARGB(0xFF,y,u,v) +#define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v) + +#define D3DCS_LEFT __MSABI_LONG(0x001) +#define D3DCS_RIGHT __MSABI_LONG(0x002) +#define D3DCS_TOP __MSABI_LONG(0x004) +#define D3DCS_BOTTOM __MSABI_LONG(0x008) +#define D3DCS_FRONT __MSABI_LONG(0x010) +#define D3DCS_BACK __MSABI_LONG(0x020) +#define D3DCS_PLANE0 __MSABI_LONG(0x040) +#define D3DCS_PLANE1 __MSABI_LONG(0x080) +#define D3DCS_PLANE2 __MSABI_LONG(0x100) +#define D3DCS_PLANE3 __MSABI_LONG(0x200) +#define D3DCS_PLANE4 __MSABI_LONG(0x400) +#define D3DCS_PLANE5 __MSABI_LONG(0x800) +#define D3DCS_ALL __MSABI_LONG(0xFFF) + +#define D3DFVF_TEXTUREFORMAT1 3u +#define D3DFVF_TEXTUREFORMAT2 0u +#define D3DFVF_TEXTUREFORMAT3 1u +#define D3DFVF_TEXTUREFORMAT4 2u +#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) +#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) + +#define D3DLOCK_READONLY 0x0010 +#define D3DLOCK_NOSYSLOCK 0x0800 +#define D3DLOCK_NOOVERWRITE 0x1000 +#define D3DLOCK_DISCARD 0x2000 +#define D3DLOCK_DONOTWAIT 0x4000 +#define D3DLOCK_NO_DIRTY_UPDATE 0x8000 + +#define D3DMAXUSERCLIPPLANES 32 +#define D3DCLIPPLANE0 (1 << 0) +#define D3DCLIPPLANE1 (1 << 1) +#define D3DCLIPPLANE2 (1 << 2) +#define D3DCLIPPLANE3 (1 << 3) +#define D3DCLIPPLANE4 (1 << 4) +#define D3DCLIPPLANE5 (1 << 5) + + +#define D3DRENDERSTATE_WRAPBIAS __MSABI_LONG(128U) + +/* MSDN has this in d3d9caps.h, but it should be here */ +#define D3DTSS_TCI_PASSTHRU 0x00000 +#define D3DTSS_TCI_CAMERASPACENORMAL 0x10000 +#define D3DTSS_TCI_CAMERASPACEPOSITION 0x20000 +#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x30000 +#define D3DTSS_TCI_SPHEREMAP 0x40000 + + +#define D3DTS_WORLD D3DTS_WORLDMATRIX(0) +#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1) +#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2) +#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3) +#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256) + +#define D3DUSAGE_RENDERTARGET __MSABI_LONG(0x00000001) +#define D3DUSAGE_DEPTHSTENCIL __MSABI_LONG(0x00000002) +#define D3DUSAGE_WRITEONLY __MSABI_LONG(0x00000008) +#define D3DUSAGE_SOFTWAREPROCESSING __MSABI_LONG(0x00000010) +#define D3DUSAGE_DONOTCLIP __MSABI_LONG(0x00000020) +#define D3DUSAGE_POINTS __MSABI_LONG(0x00000040) +#define D3DUSAGE_RTPATCHES __MSABI_LONG(0x00000080) +#define D3DUSAGE_NPATCHES __MSABI_LONG(0x00000100) +#define D3DUSAGE_DYNAMIC __MSABI_LONG(0x00000200) +#define D3DUSAGE_AUTOGENMIPMAP __MSABI_LONG(0x00000400) +#define D3DUSAGE_DMAP __MSABI_LONG(0x00004000) + +/* Parts added with d3d9ex */ +#if !defined(D3D_DISABLE_9EX) +#define D3DUSAGE_RESTRICTED_CONTENT __MSABI_LONG(0x00000800) +#define D3DUSAGE_RESTRICT_SHARED_RESOURCE_DRIVER __MSABI_LONG(0x00001000) +#define D3DUSAGE_RESTRICT_SHARED_RESOURCE __MSABI_LONG(0x00002000) +#define D3DUSAGE_NONSECURE __MSABI_LONG(0x00800000) +#define D3DUSAGE_TEXTAPI __MSABI_LONG(0x10000000) +#endif /* D3D_DISABLE_9EX */ + +#define D3DUSAGE_QUERY_LEGACYBUMPMAP __MSABI_LONG(0x00008000) +#define D3DUSAGE_QUERY_SRGBREAD __MSABI_LONG(0x00010000) +#define D3DUSAGE_QUERY_FILTER __MSABI_LONG(0x00020000) +#define D3DUSAGE_QUERY_SRGBWRITE __MSABI_LONG(0x00040000) +#define D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING __MSABI_LONG(0x00080000) +#define D3DUSAGE_QUERY_VERTEXTEXTURE __MSABI_LONG(0x00100000) +#define D3DUSAGE_QUERY_WRAPANDMIP __MSABI_LONG(0x00200000) + +#define D3DWRAP_U 1 +#define D3DWRAP_V 2 +#define D3DWRAP_W 4 +#define D3DWRAPCOORD_0 1 +#define D3DWRAPCOORD_1 2 +#define D3DWRAPCOORD_2 4 +#define D3DWRAPCOORD_3 8 + +#define MAX_DEVICE_IDENTIFIER_STRING 512 + +#define D3DFVF_RESERVED0 0x0001 +#define D3DFVF_POSITION_MASK 0x400E +#define D3DFVF_XYZ 0x0002 +#define D3DFVF_XYZRHW 0x0004 +#define D3DFVF_XYZB1 0x0006 +#define D3DFVF_XYZB2 0x0008 +#define D3DFVF_XYZB3 0x000a +#define D3DFVF_XYZB4 0x000c +#define D3DFVF_XYZB5 0x000e +#define D3DFVF_XYZW 0x4002 +#define D3DFVF_NORMAL 0x0010 +#define D3DFVF_PSIZE 0x0020 +#define D3DFVF_DIFFUSE 0x0040 +#define D3DFVF_SPECULAR 0x0080 +#define D3DFVF_TEXCOUNT_MASK 0x0f00 +#define D3DFVF_TEXCOUNT_SHIFT 8 +#define D3DFVF_TEX0 0x0000 +#define D3DFVF_TEX1 0x0100 +#define D3DFVF_TEX2 0x0200 +#define D3DFVF_TEX3 0x0300 +#define D3DFVF_TEX4 0x0400 +#define D3DFVF_TEX5 0x0500 +#define D3DFVF_TEX6 0x0600 +#define D3DFVF_TEX7 0x0700 +#define D3DFVF_TEX8 0x0800 +#define D3DFVF_LASTBETA_UBYTE4 0x1000 +#define D3DFVF_LASTBETA_D3DCOLOR 0x8000 +#define D3DFVF_RESERVED2 0x6000 + +#define D3DTA_SELECTMASK 0x0000000f +#define D3DTA_DIFFUSE 0x00000000 +#define D3DTA_CURRENT 0x00000001 +#define D3DTA_TEXTURE 0x00000002 +#define D3DTA_TFACTOR 0x00000003 +#define D3DTA_SPECULAR 0x00000004 +#define D3DTA_TEMP 0x00000005 +#define D3DTA_CONSTANT 0x00000006 +#define D3DTA_COMPLEMENT 0x00000010 +#define D3DTA_ALPHAREPLICATE 0x00000020 + +#define D3DCOLORWRITEENABLE_RED (__MSABI_LONG(1)<<0) +#define D3DCOLORWRITEENABLE_GREEN (__MSABI_LONG(1)<<1) +#define D3DCOLORWRITEENABLE_BLUE (__MSABI_LONG(1)<<2) +#define D3DCOLORWRITEENABLE_ALPHA (__MSABI_LONG(1)<<3) + +#define D3DPV_DONOTCOPYDATA (1 << 0) + +#define D3DSTREAMSOURCE_INDEXEDDATA (1u << 30) +#define D3DSTREAMSOURCE_INSTANCEDATA (2u << 30) + +#define D3D_MAX_SIMULTANEOUS_RENDERTARGETS 4 + +#define MAXD3DDECLLENGTH 64 /* +end marker */ +#define MAXD3DDECLMETHOD D3DDECLMETHOD_LOOKUPPRESAMPLED +#define MAXD3DDECLTYPE D3DDECLTYPE_UNUSED +#define MAXD3DDECLUSAGE D3DDECLUSAGE_SAMPLE +#define MAXD3DDECLUSAGEINDEX 15 + +#define D3DDMAPSAMPLER 256 +#define D3DVERTEXTEXTURESAMPLER0 (D3DDMAPSAMPLER+1) +#define D3DVERTEXTEXTURESAMPLER1 (D3DDMAPSAMPLER+2) +#define D3DVERTEXTEXTURESAMPLER2 (D3DDMAPSAMPLER+3) +#define D3DVERTEXTEXTURESAMPLER3 (D3DDMAPSAMPLER+4) + +#ifndef MAKEFOURCC +#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ + ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) +#endif + +/* Constants used by D3DPRESENT_PARAMETERS. when creating a device or swapchain */ + +#define D3DPRESENTFLAG_LOCKABLE_BACKBUFFER 0x00000001 /* Create a lockable backbuffer */ +#define D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL 0x00000002 /* Discard Z buffer */ +#define D3DPRESENTFLAG_DEVICECLIP 0x00000004 /* Clip the window blited into the client area 2k + xp only */ +#define D3DPRESENTFLAG_VIDEO 0x00000010 /* backbuffer 'may' contain video data */ +#ifndef D3D_DISABLE_9EX +#define D3DPRESENTFLAG_NOAUTOROTATE 0x00000020 /* d3d9ex, ignore display rotation */ +#define D3DPRESENTFLAG_UNPRUNEDMODE 0x00000040 /* d3d9ex, specify invalid display modes */ +#define D3DPRESENTFLAG_OVERLAY_LIMITEDRGB 0x00000080 +#define D3DPRESENTFLAG_OVERLAY_YCbCr_BT709 0x00000100 +#define D3DPRESENTFLAG_OVERLAY_YCbCr_xvYCC 0x00000200 +#define D3DPRESENTFLAG_RESTRICTED_CONTENT 0x00000400 +#define D3DPRESENTFLAG_RESTRICT_SHARED_RESOURCE_DRIVER 0x00000800 +#endif + +#define D3DPRESENT_RATE_DEFAULT 0x00000000 + +/**************************** + * Vertex Shaders Declaration + */ + +typedef enum _D3DDECLUSAGE { + D3DDECLUSAGE_POSITION = 0, + D3DDECLUSAGE_BLENDWEIGHT = 1, + D3DDECLUSAGE_BLENDINDICES = 2, + D3DDECLUSAGE_NORMAL = 3, + D3DDECLUSAGE_PSIZE = 4, + D3DDECLUSAGE_TEXCOORD = 5, + D3DDECLUSAGE_TANGENT = 6, + D3DDECLUSAGE_BINORMAL = 7, + D3DDECLUSAGE_TESSFACTOR = 8, + D3DDECLUSAGE_POSITIONT = 9, + D3DDECLUSAGE_COLOR = 10, + D3DDECLUSAGE_FOG = 11, + D3DDECLUSAGE_DEPTH = 12, + D3DDECLUSAGE_SAMPLE = 13 +} D3DDECLUSAGE; + +#define D3DMAXDECLUSAGE D3DDECLUSAGE_SAMPLE +#define D3DMAXDECLUSAGEINDEX 15 +#define D3DMAXDECLLENGTH 18 +#define D3DMAXDECLUSAGE_DX8 D3DDECLUSAGE_TEXCOORD + +typedef enum _D3DDECLMETHOD { + D3DDECLMETHOD_DEFAULT = 0, + D3DDECLMETHOD_PARTIALU = 1, + D3DDECLMETHOD_PARTIALV = 2, + D3DDECLMETHOD_CROSSUV = 3, + D3DDECLMETHOD_UV = 4, + D3DDECLMETHOD_LOOKUP = 5, + D3DDECLMETHOD_LOOKUPPRESAMPLED = 6 +} D3DDECLMETHOD; + + +#define D3DMAXDECLMETHOD D3DDECLMETHOD_LOOKUPPRESAMPLED + +typedef enum _D3DDECLTYPE { + D3DDECLTYPE_FLOAT1 = 0, + D3DDECLTYPE_FLOAT2 = 1, + D3DDECLTYPE_FLOAT3 = 2, + D3DDECLTYPE_FLOAT4 = 3, + D3DDECLTYPE_D3DCOLOR = 4, + D3DDECLTYPE_UBYTE4 = 5, + D3DDECLTYPE_SHORT2 = 6, + D3DDECLTYPE_SHORT4 = 7, + /* VS 2.0 */ + D3DDECLTYPE_UBYTE4N = 8, + D3DDECLTYPE_SHORT2N = 9, + D3DDECLTYPE_SHORT4N = 10, + D3DDECLTYPE_USHORT2N = 11, + D3DDECLTYPE_USHORT4N = 12, + D3DDECLTYPE_UDEC3 = 13, + D3DDECLTYPE_DEC3N = 14, + D3DDECLTYPE_FLOAT16_2 = 15, + D3DDECLTYPE_FLOAT16_4 = 16, + D3DDECLTYPE_UNUSED = 17, +} D3DDECLTYPE; + +#define D3DMAXDECLTYPE D3DDECLTYPE_UNUSED + +typedef struct _D3DVERTEXELEMENT9 { + WORD Stream; + WORD Offset; + BYTE Type; + BYTE Method; + BYTE Usage; + BYTE UsageIndex; +} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9; + + +typedef enum _D3DQUERYTYPE { + D3DQUERYTYPE_VCACHE = 4, + D3DQUERYTYPE_RESOURCEMANAGER = 5, + D3DQUERYTYPE_VERTEXSTATS = 6, + D3DQUERYTYPE_EVENT = 8, + D3DQUERYTYPE_OCCLUSION = 9, + D3DQUERYTYPE_TIMESTAMP = 10, + D3DQUERYTYPE_TIMESTAMPDISJOINT = 11, + D3DQUERYTYPE_TIMESTAMPFREQ = 12, + D3DQUERYTYPE_PIPELINETIMINGS = 13, + D3DQUERYTYPE_INTERFACETIMINGS = 14, + D3DQUERYTYPE_VERTEXTIMINGS = 15, + D3DQUERYTYPE_PIXELTIMINGS = 16, + D3DQUERYTYPE_BANDWIDTHTIMINGS = 17, + D3DQUERYTYPE_CACHEUTILIZATION = 18, +#ifndef D3D_DISABLE_9EX + D3DQUERYTYPE_MEMORYPRESSURE = 19, +#endif +} D3DQUERYTYPE; + +#define D3DISSUE_BEGIN (1 << 1) +#define D3DISSUE_END (1 << 0) +#define D3DGETDATA_FLUSH (1 << 0) + + +#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0} +#define D3DDP_MAXTEXCOORD 8 + + +#define D3DVSD_MAKETOKENTYPE(TokenType) \ + ((TokenType << D3DVSD_TOKENTYPESHIFT) & D3DVSD_TOKENTYPEMASK) + +#define D3DVSD_CONST(ConstantAddress, Count) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_CONSTMEM) | ((Count) << D3DVSD_CONSTCOUNTSHIFT) | (ConstantAddress)) + +#define D3DVSD_END() 0xFFFFFFFF + +#define D3DVSD_NOP() 0x00000000 + +#define D3DVSD_REG(VertexRegister, Type) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | ((Type) << D3DVSD_DATATYPESHIFT) | (VertexRegister)) + +#define D3DVSD_SKIP(Count) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | 0x10000000 | ((Count) << D3DVSD_SKIPCOUNTSHIFT)) + +#define D3DVSD_STREAM(StreamNumber) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (StreamNumber)) + +#define D3DVSD_STREAM_TESS() \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (D3DVSD_STREAMTESSMASK)) + +#define D3DVSD_TESSNORMAL(RegisterIn, RegisterOut) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | ((RegisterIn) << D3DVSD_VERTEXREGINSHIFT) | ((0x02) << D3DVSD_DATATYPESHIFT) | (RegisterOut)) + +#define D3DVSD_TESSUV(Register) \ + (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | 0x10000000 | ((0x01) << D3DVSD_DATATYPESHIFT) | (Register)) + + +/******************************** + * Pixel/Vertex Shaders Functions + */ + +/** Maximum number of supported texture coordinates sets operation */ +#define D3DDP_MAXTEXCOORD 8 + +/** opcode token mask */ +#define D3DSI_OPCODE_MASK 0x0000FFFF +#define D3DSI_INSTLENGTH_MASK 0x0F000000 +#define D3DSI_INSTLENGTH_SHIFT 24 + +/** opcodes types for PS and VS */ +typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE { + D3DSIO_NOP = 0, + D3DSIO_MOV = 1, + D3DSIO_ADD = 2, + D3DSIO_SUB = 3, + D3DSIO_MAD = 4, + D3DSIO_MUL = 5, + D3DSIO_RCP = 6, + D3DSIO_RSQ = 7, + D3DSIO_DP3 = 8, + D3DSIO_DP4 = 9, + D3DSIO_MIN = 10, + D3DSIO_MAX = 11, + D3DSIO_SLT = 12, + D3DSIO_SGE = 13, + D3DSIO_EXP = 14, + D3DSIO_LOG = 15, + D3DSIO_LIT = 16, + D3DSIO_DST = 17, + D3DSIO_LRP = 18, + D3DSIO_FRC = 19, + D3DSIO_M4x4 = 20, + D3DSIO_M4x3 = 21, + D3DSIO_M3x4 = 22, + D3DSIO_M3x3 = 23, + D3DSIO_M3x2 = 24, + D3DSIO_CALL = 25, + D3DSIO_CALLNZ = 26, + D3DSIO_LOOP = 27, + D3DSIO_RET = 28, + D3DSIO_ENDLOOP = 29, + D3DSIO_LABEL = 30, + D3DSIO_DCL = 31, + D3DSIO_POW = 32, + D3DSIO_CRS = 33, + D3DSIO_SGN = 34, + D3DSIO_ABS = 35, + D3DSIO_NRM = 36, + D3DSIO_SINCOS = 37, + D3DSIO_REP = 38, + D3DSIO_ENDREP = 39, + D3DSIO_IF = 40, + D3DSIO_IFC = 41, + D3DSIO_ELSE = 42, + D3DSIO_ENDIF = 43, + D3DSIO_BREAK = 44, + D3DSIO_BREAKC = 45, + D3DSIO_MOVA = 46, + D3DSIO_DEFB = 47, + D3DSIO_DEFI = 48, + + D3DSIO_TEXCOORD = 64, + D3DSIO_TEXKILL = 65, + D3DSIO_TEX = 66, + D3DSIO_TEXBEM = 67, + D3DSIO_TEXBEML = 68, + D3DSIO_TEXREG2AR = 69, + D3DSIO_TEXREG2GB = 70, + D3DSIO_TEXM3x2PAD = 71, + D3DSIO_TEXM3x2TEX = 72, + D3DSIO_TEXM3x3PAD = 73, + D3DSIO_TEXM3x3TEX = 74, + D3DSIO_TEXM3x3DIFF = 75, + D3DSIO_TEXM3x3SPEC = 76, + D3DSIO_TEXM3x3VSPEC = 77, + D3DSIO_EXPP = 78, + D3DSIO_LOGP = 79, + D3DSIO_CND = 80, + D3DSIO_DEF = 81, + D3DSIO_TEXREG2RGB = 82, + D3DSIO_TEXDP3TEX = 83, + D3DSIO_TEXM3x2DEPTH = 84, + D3DSIO_TEXDP3 = 85, + D3DSIO_TEXM3x3 = 86, + D3DSIO_TEXDEPTH = 87, + D3DSIO_CMP = 88, + D3DSIO_BEM = 89, + D3DSIO_DP2ADD = 90, + D3DSIO_DSX = 91, + D3DSIO_DSY = 92, + D3DSIO_TEXLDD = 93, + D3DSIO_SETP = 94, + D3DSIO_TEXLDL = 95, + D3DSIO_BREAKP = 96, + + D3DSIO_PHASE = 0xFFFD, + D3DSIO_COMMENT = 0xFFFE, + D3DSIO_END = 0XFFFF, + + D3DSIO_FORCE_DWORD = 0X7FFFFFFF /** for 32-bit alignment */ +} D3DSHADER_INSTRUCTION_OPCODE_TYPE; + +#define D3DSINCOSCONST1 -1.5500992e-006f, -2.1701389e-005f, 0.0026041667f, 0.00026041668f +#define D3DSINCOSCONST2 -0.020833334f, -0.12500000f, 1.0f, 0.50000000f + +#define D3DSHADER_INSTRUCTION_PREDICATED (1 << 28) + +#define D3DSI_TEXLD_PROJECT 0x00010000 +#define D3DSI_TEXLD_BIAS 0x00020000 + +/** for parallelism */ +#define D3DSI_COISSUE 0x40000000 + +#define D3DSP_DCL_USAGE_SHIFT 0 +#define D3DSP_DCL_USAGE_MASK 0x0000000f + +#define D3DSP_DCL_USAGEINDEX_SHIFT 16 +#define D3DSP_DCL_USAGEINDEX_MASK 0x000f0000 + +#define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16 +#define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000 + +#define D3DSP_TEXTURETYPE_SHIFT 27 +#define D3DSP_TEXTURETYPE_MASK 0x78000000 + +typedef enum _D3DSAMPLER_TEXTURE_TYPE { + D3DSTT_UNKNOWN = 0 << D3DSP_TEXTURETYPE_SHIFT, + D3DSTT_1D = 1 << D3DSP_TEXTURETYPE_SHIFT, + D3DSTT_2D = 2 << D3DSP_TEXTURETYPE_SHIFT, + D3DSTT_CUBE = 3 << D3DSP_TEXTURETYPE_SHIFT, + D3DSTT_VOLUME = 4 << D3DSP_TEXTURETYPE_SHIFT, + + D3DSTT_FORCE_DWORD = 0x7FFFFFFF +} D3DSAMPLER_TEXTURE_TYPE; + +#define D3DSP_REGNUM_MASK 0x000007FF + +/** destination parameter modifiers (.xyzw) */ +#define D3DSP_WRITEMASK_0 0x00010000 /* .x r */ +#define D3DSP_WRITEMASK_1 0x00020000 /* .y g */ +#define D3DSP_WRITEMASK_2 0x00040000 /* .z b */ +#define D3DSP_WRITEMASK_3 0x00080000 /* .w a */ +#define D3DSP_WRITEMASK_ALL 0x000F0000 /* all */ + +#define D3DSP_DSTMOD_SHIFT 20 +#define D3DSP_DSTMOD_MASK (0xF << D3DSP_DSTMOD_SHIFT) + +typedef enum _D3DSHADER_PARAM_DSTMOD_TYPE { + D3DSPDM_NONE = 0 << D3DSP_DSTMOD_SHIFT, + D3DSPDM_SATURATE = 1 << D3DSP_DSTMOD_SHIFT, + D3DSPDM_PARTIALPRECISION = 2 << D3DSP_DSTMOD_SHIFT, + D3DSPDM_MSAMPCENTROID = 4 << D3DSP_DSTMOD_SHIFT, + + D3DSPDM_FORCE_DWORD = 0x7FFFFFFF +} D3DSHADER_PARAM_DSTMOD_TYPE; + +/** destination param */ +#define D3DSP_DSTSHIFT_SHIFT 24 +#define D3DSP_DSTSHIFT_MASK (0xF << D3DSP_DSTSHIFT_SHIFT) + +/** destination/source reg type */ +#define D3DSP_REGTYPE_SHIFT 28 +#define D3DSP_REGTYPE_SHIFT2 8 +#define D3DSP_REGTYPE_MASK (0x7 << D3DSP_REGTYPE_SHIFT) +#define D3DSP_REGTYPE_MASK2 0x00001800 + +typedef enum _D3DSHADER_PARAM_REGISTER_TYPE +{ + D3DSPR_TEMP = 0, + D3DSPR_INPUT = 1, + D3DSPR_CONST = 2, + D3DSPR_ADDR = 3, + D3DSPR_TEXTURE = 3, + D3DSPR_RASTOUT = 4, + D3DSPR_ATTROUT = 5, + D3DSPR_TEXCRDOUT = 6, + D3DSPR_OUTPUT = 6, + D3DSPR_CONSTINT = 7, + D3DSPR_COLOROUT = 8, + D3DSPR_DEPTHOUT = 9, + D3DSPR_SAMPLER = 10, + D3DSPR_CONST2 = 11, + D3DSPR_CONST3 = 12, + D3DSPR_CONST4 = 13, + D3DSPR_CONSTBOOL = 14, + D3DSPR_LOOP = 15, + D3DSPR_TEMPFLOAT16 = 16, + D3DSPR_MISCTYPE = 17, + D3DSPR_LABEL = 18, + D3DSPR_PREDICATE = 19, + + D3DSPR_FORCE_DWORD = 0x7fffffff +} D3DSHADER_PARAM_REGISTER_TYPE; + +typedef enum _D3DSHADER_MISCTYPE_OFFSETS { + D3DSMO_POSITION = 0, + D3DSMO_FACE = 1 +} D3DSHADER_MISCTYPE_OFFSETS; + +typedef enum _D3DVS_RASTOUT_OFFSETS { + D3DSRO_POSITION = 0, + D3DSRO_FOG = 1, + D3DSRO_POINT_SIZE = 2, + + D3DSRO_FORCE_DWORD = 0x7FFFFFFF +} D3DVS_RASTOUT_OFFSETS; + +#define D3DVS_ADDRESSMODE_SHIFT 13 +#define D3DVS_ADDRESSMODE_MASK (0x1 << D3DVS_ADDRESSMODE_SHIFT) + +typedef enum _D3DVS_ADDRESSMODE_TYPE { + D3DVS_ADDRMODE_ABSOLUTE = 0 << D3DVS_ADDRESSMODE_SHIFT, + D3DVS_ADDRMODE_RELATIVE = 1 << D3DVS_ADDRESSMODE_SHIFT, + + D3DVS_ADDRMODE_FORCE_DWORD = 0x7FFFFFFF +} D3DVS_ADDRESSMODE_TYPE; + +#define D3DSHADER_ADDRESSMODE_SHIFT 13 +#define D3DSHADER_ADDRESSMODE_MASK (1 << D3DSHADER_ADDRESSMODE_SHIFT) + +typedef enum _D3DSHADER_ADDRESSMODE_TYPE { + D3DSHADER_ADDRMODE_ABSOLUTE = 0 << D3DSHADER_ADDRESSMODE_SHIFT, + D3DSHADER_ADDRMODE_RELATIVE = 1 << D3DSHADER_ADDRESSMODE_SHIFT, + + D3DSHADER_ADDRMODE_FORCE_DWORD = 0x7FFFFFFF +} D3DSHADER_ADDRESSMODE_TYPE; + + +#define D3DVS_SWIZZLE_SHIFT 16 +#define D3DVS_SWIZZLE_MASK (0xFF << D3DVS_SWIZZLE_SHIFT) + +#define D3DSP_SWIZZLE_SHIFT 16 +#define D3DSP_SWIZZLE_MASK (0xFF << D3DSP_SWIZZLE_SHIFT) + +#define D3DVS_X_X (0 << D3DVS_SWIZZLE_SHIFT) +#define D3DVS_X_Y (1 << D3DVS_SWIZZLE_SHIFT) +#define D3DVS_X_Z (2 << D3DVS_SWIZZLE_SHIFT) +#define D3DVS_X_W (3 << D3DVS_SWIZZLE_SHIFT) + +#define D3DVS_Y_X (0 << (D3DVS_SWIZZLE_SHIFT + 2)) +#define D3DVS_Y_Y (1 << (D3DVS_SWIZZLE_SHIFT + 2)) +#define D3DVS_Y_Z (2 << (D3DVS_SWIZZLE_SHIFT + 2)) +#define D3DVS_Y_W (3 << (D3DVS_SWIZZLE_SHIFT + 2)) + +#define D3DVS_Z_X (0 << (D3DVS_SWIZZLE_SHIFT + 4)) +#define D3DVS_Z_Y (1 << (D3DVS_SWIZZLE_SHIFT + 4)) +#define D3DVS_Z_Z (2 << (D3DVS_SWIZZLE_SHIFT + 4)) +#define D3DVS_Z_W (3 << (D3DVS_SWIZZLE_SHIFT + 4)) + +#define D3DVS_W_X (0 << (D3DVS_SWIZZLE_SHIFT + 6)) +#define D3DVS_W_Y (1 << (D3DVS_SWIZZLE_SHIFT + 6)) +#define D3DVS_W_Z (2 << (D3DVS_SWIZZLE_SHIFT + 6)) +#define D3DVS_W_W (3 << (D3DVS_SWIZZLE_SHIFT + 6)) + +#define D3DVS_NOSWIZZLE (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z | D3DVS_W_W) + +#define D3DSP_NOSWIZZLE \ + ((0 << (D3DSP_SWIZZLE_SHIFT + 0)) | (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | (3 << (D3DSP_SWIZZLE_SHIFT + 6))) + +#define D3DSP_SRCMOD_SHIFT 24 +#define D3DSP_SRCMOD_MASK (0xF << D3DSP_SRCMOD_SHIFT) + +typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE { + D3DSPSM_NONE = 0 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_NEG = 1 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_BIAS = 2 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_BIASNEG = 3 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_SIGN = 4 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_SIGNNEG = 5 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_COMP = 6 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_X2 = 7 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_X2NEG = 8 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_DZ = 9 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_DW = 10 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_ABS = 11 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_ABSNEG = 12 << D3DSP_SRCMOD_SHIFT, + D3DSPSM_NOT = 13 << D3DSP_SRCMOD_SHIFT, + + D3DSPSM_FORCE_DWORD = 0x7FFFFFFF +} D3DSHADER_PARAM_SRCMOD_TYPE; + +#define D3DPS_VERSION(major, minor) (0xFFFF0000 | ((major) << 8) | (minor)) +#define D3DVS_VERSION(major, minor) (0xFFFE0000 | ((major) << 8) | (minor)) +#define D3DSHADER_VERSION_MAJOR(version) (((version) >> 8) & 0xFF) +#define D3DSHADER_VERSION_MINOR(version) (((version) >> 0) & 0xFF) + +#define D3DSI_COMMENTSIZE_SHIFT 16 +#define D3DSI_COMMENTSIZE_MASK (0x7FFF << D3DSI_COMMENTSIZE_SHIFT) + +#define D3DSHADER_COMMENT(commentSize) \ + ((((commentSize) << D3DSI_COMMENTSIZE_SHIFT) & D3DSI_COMMENTSIZE_MASK) | D3DSIO_COMMENT) + +#define D3DPS_END() 0x0000FFFF +#define D3DVS_END() 0x0000FFFF + + +/***************************************************************************** + * Direct 3D v8 enumerated types + */ +typedef enum _D3DBACKBUFFER_TYPE { + D3DBACKBUFFER_TYPE_MONO = 0, + D3DBACKBUFFER_TYPE_LEFT = 1, + D3DBACKBUFFER_TYPE_RIGHT = 2, + + D3DBACKBUFFER_TYPE_FORCE_DWORD = 0x7fffffff +} D3DBACKBUFFER_TYPE; + +typedef enum _D3DBASISTYPE { + D3DBASIS_BEZIER = 0, + D3DBASIS_BSPLINE = 1, + D3DBASIS_INTERPOLATE = 2, + + D3DBASIS_FORCE_DWORD = 0x7fffffff +} D3DBASISTYPE; + +typedef enum _D3DBLEND { + D3DBLEND_ZERO = 1, + D3DBLEND_ONE = 2, + D3DBLEND_SRCCOLOR = 3, + D3DBLEND_INVSRCCOLOR = 4, + D3DBLEND_SRCALPHA = 5, + D3DBLEND_INVSRCALPHA = 6, + D3DBLEND_DESTALPHA = 7, + D3DBLEND_INVDESTALPHA = 8, + D3DBLEND_DESTCOLOR = 9, + D3DBLEND_INVDESTCOLOR = 10, + D3DBLEND_SRCALPHASAT = 11, + D3DBLEND_BOTHSRCALPHA = 12, + D3DBLEND_BOTHINVSRCALPHA = 13, + D3DBLEND_BLENDFACTOR = 14, + D3DBLEND_INVBLENDFACTOR = 15, +#ifndef D3D_DISABLE_9EX + D3DBLEND_SRCCOLOR2 = 16, + D3DBLEND_INVSRCCOLOR2 = 17, +#endif + D3DBLEND_FORCE_DWORD = 0x7fffffff +} D3DBLEND; + +typedef enum _D3DBLENDOP { + D3DBLENDOP_ADD = 1, + D3DBLENDOP_SUBTRACT = 2, + D3DBLENDOP_REVSUBTRACT = 3, + D3DBLENDOP_MIN = 4, + D3DBLENDOP_MAX = 5, + + D3DBLENDOP_FORCE_DWORD = 0x7fffffff +} D3DBLENDOP; + +typedef enum _D3DCMPFUNC { + D3DCMP_NEVER = 1, + D3DCMP_LESS = 2, + D3DCMP_EQUAL = 3, + D3DCMP_LESSEQUAL = 4, + D3DCMP_GREATER = 5, + D3DCMP_NOTEQUAL = 6, + D3DCMP_GREATEREQUAL = 7, + D3DCMP_ALWAYS = 8, + + D3DCMP_FORCE_DWORD = 0x7fffffff +} D3DCMPFUNC; + +typedef enum _D3DCUBEMAP_FACES { + D3DCUBEMAP_FACE_POSITIVE_X = 0, + D3DCUBEMAP_FACE_NEGATIVE_X = 1, + D3DCUBEMAP_FACE_POSITIVE_Y = 2, + D3DCUBEMAP_FACE_NEGATIVE_Y = 3, + D3DCUBEMAP_FACE_POSITIVE_Z = 4, + D3DCUBEMAP_FACE_NEGATIVE_Z = 5, + + D3DCUBEMAP_FACE_FORCE_DWORD = 0xffffffff +} D3DCUBEMAP_FACES; + +typedef enum _D3DCULL { + D3DCULL_NONE = 1, + D3DCULL_CW = 2, + D3DCULL_CCW = 3, + + D3DCULL_FORCE_DWORD = 0x7fffffff +} D3DCULL; + +typedef enum _D3DDEBUGMONITORTOKENS { + D3DDMT_ENABLE = 0, + D3DDMT_DISABLE = 1, + + D3DDMT_FORCE_DWORD = 0x7fffffff +} D3DDEBUGMONITORTOKENS; + +typedef enum _D3DDEGREETYPE { + D3DDEGREE_LINEAR = 1, + D3DDEGREE_QUADRATIC = 2, + D3DDEGREE_CUBIC = 3, + D3DDEGREE_QUINTIC = 5, + + D3DDEGREE_FORCE_DWORD = 0x7fffffff +} D3DDEGREETYPE; + +typedef enum _D3DDEVTYPE { + D3DDEVTYPE_HAL = 1, + D3DDEVTYPE_REF = 2, + D3DDEVTYPE_SW = 3, + D3DDEVTYPE_NULLREF = 4, + + D3DDEVTYPE_FORCE_DWORD = 0xffffffff +} D3DDEVTYPE; + +typedef enum _D3DFILLMODE { + D3DFILL_POINT = 1, + D3DFILL_WIREFRAME = 2, + D3DFILL_SOLID = 3, + + D3DFILL_FORCE_DWORD = 0x7fffffff +} D3DFILLMODE; + +typedef enum _D3DFOGMODE { + D3DFOG_NONE = 0, + D3DFOG_EXP = 1, + D3DFOG_EXP2 = 2, + D3DFOG_LINEAR = 3, + + D3DFOG_FORCE_DWORD = 0x7fffffff +} D3DFOGMODE; + +typedef enum _D3DFORMAT { + D3DFMT_UNKNOWN = 0, + + D3DFMT_R8G8B8 = 20, + D3DFMT_A8R8G8B8 = 21, + D3DFMT_X8R8G8B8 = 22, + D3DFMT_R5G6B5 = 23, + D3DFMT_X1R5G5B5 = 24, + D3DFMT_A1R5G5B5 = 25, + D3DFMT_A4R4G4B4 = 26, + D3DFMT_R3G3B2 = 27, + D3DFMT_A8 = 28, + D3DFMT_A8R3G3B2 = 29, + D3DFMT_X4R4G4B4 = 30, + D3DFMT_A2B10G10R10 = 31, + D3DFMT_A8B8G8R8 = 32, + D3DFMT_X8B8G8R8 = 33, + D3DFMT_G16R16 = 34, + D3DFMT_A2R10G10B10 = 35, + D3DFMT_A16B16G16R16 = 36, + + + D3DFMT_A8P8 = 40, + D3DFMT_P8 = 41, + + D3DFMT_L8 = 50, + D3DFMT_A8L8 = 51, + D3DFMT_A4L4 = 52, + + D3DFMT_V8U8 = 60, + D3DFMT_L6V5U5 = 61, + D3DFMT_X8L8V8U8 = 62, + D3DFMT_Q8W8V8U8 = 63, + D3DFMT_V16U16 = 64, + D3DFMT_A2W10V10U10 = 67, + + D3DFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), + D3DFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'), + D3DFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'), + D3DFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'), + D3DFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'), + D3DFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'), + D3DFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'), + D3DFMT_MULTI2_ARGB8 = MAKEFOURCC('M', 'E', 'T', '1'), + D3DFMT_G8R8_G8B8 = MAKEFOURCC('G', 'R', 'G', 'B'), + D3DFMT_R8G8_B8G8 = MAKEFOURCC('R', 'G', 'B', 'G'), + + D3DFMT_D16_LOCKABLE = 70, + D3DFMT_D32 = 71, + D3DFMT_D15S1 = 73, + D3DFMT_D24S8 = 75, + D3DFMT_D24X8 = 77, + D3DFMT_D24X4S4 = 79, + D3DFMT_D16 = 80, + D3DFMT_L16 = 81, + D3DFMT_D32F_LOCKABLE = 82, + D3DFMT_D24FS8 = 83, +#ifndef D3D_DISABLE_9EX + D3DFMT_D32_LOCKABLE = 84, + D3DFMT_S8_LOCKABLE = 85, +#endif + + D3DFMT_VERTEXDATA = 100, + D3DFMT_INDEX16 = 101, + D3DFMT_INDEX32 = 102, + D3DFMT_Q16W16V16U16 = 110, + /* Floating point formats */ + D3DFMT_R16F = 111, + D3DFMT_G16R16F = 112, + D3DFMT_A16B16G16R16F = 113, + + /* IEEE formats */ + D3DFMT_R32F = 114, + D3DFMT_G32R32F = 115, + D3DFMT_A32B32G32R32F = 116, + + D3DFMT_CxV8U8 = 117, +#ifndef D3D_DISABLE_9EX + D3DFMT_A1 = 118, + D3DFMT_A2B10G10R10_XR_BIAS = 119, + D3DFMT_BINARYBUFFER = 199, +#endif + + D3DFMT_FORCE_DWORD = 0xFFFFFFFF +} D3DFORMAT; + +typedef enum _D3DLIGHTTYPE { + D3DLIGHT_POINT = 1, + D3DLIGHT_SPOT = 2, + D3DLIGHT_DIRECTIONAL = 3, + + D3DLIGHT_FORCE_DWORD = 0x7fffffff +} D3DLIGHTTYPE; + +typedef enum _D3DMATERIALCOLORSOURCE { + D3DMCS_MATERIAL = 0, + D3DMCS_COLOR1 = 1, + D3DMCS_COLOR2 = 2, + + D3DMCS_FORCE_DWORD = 0x7fffffff +} D3DMATERIALCOLORSOURCE; + +typedef enum _D3DMULTISAMPLE_TYPE { + D3DMULTISAMPLE_NONE = 0, + D3DMULTISAMPLE_NONMASKABLE = 1, + D3DMULTISAMPLE_2_SAMPLES = 2, + D3DMULTISAMPLE_3_SAMPLES = 3, + D3DMULTISAMPLE_4_SAMPLES = 4, + D3DMULTISAMPLE_5_SAMPLES = 5, + D3DMULTISAMPLE_6_SAMPLES = 6, + D3DMULTISAMPLE_7_SAMPLES = 7, + D3DMULTISAMPLE_8_SAMPLES = 8, + D3DMULTISAMPLE_9_SAMPLES = 9, + D3DMULTISAMPLE_10_SAMPLES = 10, + D3DMULTISAMPLE_11_SAMPLES = 11, + D3DMULTISAMPLE_12_SAMPLES = 12, + D3DMULTISAMPLE_13_SAMPLES = 13, + D3DMULTISAMPLE_14_SAMPLES = 14, + D3DMULTISAMPLE_15_SAMPLES = 15, + D3DMULTISAMPLE_16_SAMPLES = 16, + + D3DMULTISAMPLE_FORCE_DWORD = 0x7fffffff +} D3DMULTISAMPLE_TYPE; + +#if 0 +typedef enum _D3DORDERTYPE { + D3DORDER_LINEAR = 1, + D3DORDER_QUADRATIC = 2, + D3DORDER_CUBIC = 3, + D3DORDER_QUINTIC = 5, + + D3DORDER_FORCE_DWORD = 0x7fffffff +} D3DORDERTYPE; +#endif +typedef enum _D3DPATCHEDGESTYLE { + D3DPATCHEDGE_DISCRETE = 0, + D3DPATCHEDGE_CONTINUOUS = 1, + + D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff, +} D3DPATCHEDGESTYLE; + +typedef enum _D3DPOOL { + D3DPOOL_DEFAULT = 0, + D3DPOOL_MANAGED = 1, + D3DPOOL_SYSTEMMEM = 2, + D3DPOOL_SCRATCH = 3, + + D3DPOOL_FORCE_DWORD = 0x7fffffff +} D3DPOOL; + +typedef enum _D3DPRIMITIVETYPE { + D3DPT_POINTLIST = 1, + D3DPT_LINELIST = 2, + D3DPT_LINESTRIP = 3, + D3DPT_TRIANGLELIST = 4, + D3DPT_TRIANGLESTRIP = 5, + D3DPT_TRIANGLEFAN = 6, + + D3DPT_FORCE_DWORD = 0x7fffffff +} D3DPRIMITIVETYPE; + +typedef enum _D3DRENDERSTATETYPE { + D3DRS_ZENABLE = 7, + D3DRS_FILLMODE = 8, + D3DRS_SHADEMODE = 9, + D3DRS_ZWRITEENABLE = 14, + D3DRS_ALPHATESTENABLE = 15, + D3DRS_LASTPIXEL = 16, + D3DRS_SRCBLEND = 19, + D3DRS_DESTBLEND = 20, + D3DRS_CULLMODE = 22, + D3DRS_ZFUNC = 23, + D3DRS_ALPHAREF = 24, + D3DRS_ALPHAFUNC = 25, + D3DRS_DITHERENABLE = 26, + D3DRS_ALPHABLENDENABLE = 27, + D3DRS_FOGENABLE = 28, + D3DRS_SPECULARENABLE = 29, + D3DRS_FOGCOLOR = 34, + D3DRS_FOGTABLEMODE = 35, + D3DRS_FOGSTART = 36, + D3DRS_FOGEND = 37, + D3DRS_FOGDENSITY = 38, + D3DRS_RANGEFOGENABLE = 48, + D3DRS_STENCILENABLE = 52, + D3DRS_STENCILFAIL = 53, + D3DRS_STENCILZFAIL = 54, + D3DRS_STENCILPASS = 55, + D3DRS_STENCILFUNC = 56, + D3DRS_STENCILREF = 57, + D3DRS_STENCILMASK = 58, + D3DRS_STENCILWRITEMASK = 59, + D3DRS_TEXTUREFACTOR = 60, + D3DRS_WRAP0 = 128, + D3DRS_WRAP1 = 129, + D3DRS_WRAP2 = 130, + D3DRS_WRAP3 = 131, + D3DRS_WRAP4 = 132, + D3DRS_WRAP5 = 133, + D3DRS_WRAP6 = 134, + D3DRS_WRAP7 = 135, + D3DRS_CLIPPING = 136, + D3DRS_LIGHTING = 137, + D3DRS_AMBIENT = 139, + D3DRS_FOGVERTEXMODE = 140, + D3DRS_COLORVERTEX = 141, + D3DRS_LOCALVIEWER = 142, + D3DRS_NORMALIZENORMALS = 143, + D3DRS_DIFFUSEMATERIALSOURCE = 145, + D3DRS_SPECULARMATERIALSOURCE = 146, + D3DRS_AMBIENTMATERIALSOURCE = 147, + D3DRS_EMISSIVEMATERIALSOURCE = 148, + D3DRS_VERTEXBLEND = 151, + D3DRS_CLIPPLANEENABLE = 152, + D3DRS_POINTSIZE = 154, + D3DRS_POINTSIZE_MIN = 155, + D3DRS_POINTSPRITEENABLE = 156, + D3DRS_POINTSCALEENABLE = 157, + D3DRS_POINTSCALE_A = 158, + D3DRS_POINTSCALE_B = 159, + D3DRS_POINTSCALE_C = 160, + D3DRS_MULTISAMPLEANTIALIAS = 161, + D3DRS_MULTISAMPLEMASK = 162, + D3DRS_PATCHEDGESTYLE = 163, + D3DRS_DEBUGMONITORTOKEN = 165, + D3DRS_POINTSIZE_MAX = 166, + D3DRS_INDEXEDVERTEXBLENDENABLE = 167, + D3DRS_COLORWRITEENABLE = 168, + D3DRS_TWEENFACTOR = 170, + D3DRS_BLENDOP = 171, + D3DRS_POSITIONDEGREE = 172, + D3DRS_NORMALDEGREE = 173, + D3DRS_SCISSORTESTENABLE = 174, + D3DRS_SLOPESCALEDEPTHBIAS = 175, + D3DRS_ANTIALIASEDLINEENABLE = 176, + D3DRS_MINTESSELLATIONLEVEL = 178, + D3DRS_MAXTESSELLATIONLEVEL = 179, + D3DRS_ADAPTIVETESS_X = 180, + D3DRS_ADAPTIVETESS_Y = 181, + D3DRS_ADAPTIVETESS_Z = 182, + D3DRS_ADAPTIVETESS_W = 183, + D3DRS_ENABLEADAPTIVETESSELLATION= 184, + D3DRS_TWOSIDEDSTENCILMODE = 185, + D3DRS_CCW_STENCILFAIL = 186, + D3DRS_CCW_STENCILZFAIL = 187, + D3DRS_CCW_STENCILPASS = 188, + D3DRS_CCW_STENCILFUNC = 189, + D3DRS_COLORWRITEENABLE1 = 190, + D3DRS_COLORWRITEENABLE2 = 191, + D3DRS_COLORWRITEENABLE3 = 192, + D3DRS_BLENDFACTOR = 193, + D3DRS_SRGBWRITEENABLE = 194, + D3DRS_DEPTHBIAS = 195, + D3DRS_WRAP8 = 198, + D3DRS_WRAP9 = 199, + D3DRS_WRAP10 = 200, + D3DRS_WRAP11 = 201, + D3DRS_WRAP12 = 202, + D3DRS_WRAP13 = 203, + D3DRS_WRAP14 = 204, + D3DRS_WRAP15 = 205, + D3DRS_SEPARATEALPHABLENDENABLE = 206, + D3DRS_SRCBLENDALPHA = 207, + D3DRS_DESTBLENDALPHA = 208, + D3DRS_BLENDOPALPHA = 209, + + D3DRS_FORCE_DWORD = 0x7fffffff +} D3DRENDERSTATETYPE; + +typedef enum _D3DRESOURCETYPE { + D3DRTYPE_SURFACE = 1, + D3DRTYPE_VOLUME = 2, + D3DRTYPE_TEXTURE = 3, + D3DRTYPE_VOLUMETEXTURE = 4, + D3DRTYPE_CUBETEXTURE = 5, + D3DRTYPE_VERTEXBUFFER = 6, + D3DRTYPE_INDEXBUFFER = 7, + + D3DRTYPE_FORCE_DWORD = 0x7fffffff +} D3DRESOURCETYPE; + +#define D3DRTYPECOUNT (D3DRTYPE_INDEXBUFFER+1) + +typedef enum _D3DSHADEMODE { + D3DSHADE_FLAT = 1, + D3DSHADE_GOURAUD = 2, + D3DSHADE_PHONG = 3, + + D3DSHADE_FORCE_DWORD = 0x7fffffff +} D3DSHADEMODE; + +typedef enum _D3DSTATEBLOCKTYPE { + D3DSBT_ALL = 1, + D3DSBT_PIXELSTATE = 2, + D3DSBT_VERTEXSTATE = 3, + + D3DSBT_FORCE_DWORD = 0xffffffff +} D3DSTATEBLOCKTYPE; + +typedef enum _D3DSTENCILOP { + D3DSTENCILOP_KEEP = 1, + D3DSTENCILOP_ZERO = 2, + D3DSTENCILOP_REPLACE = 3, + D3DSTENCILOP_INCRSAT = 4, + D3DSTENCILOP_DECRSAT = 5, + D3DSTENCILOP_INVERT = 6, + D3DSTENCILOP_INCR = 7, + D3DSTENCILOP_DECR = 8, + + D3DSTENCILOP_FORCE_DWORD = 0x7fffffff +} D3DSTENCILOP; + +typedef enum _D3DSWAPEFFECT { + D3DSWAPEFFECT_DISCARD = 1, + D3DSWAPEFFECT_FLIP = 2, + D3DSWAPEFFECT_COPY = 3, +#ifndef D3D_DISABLE_9EX + D3DSWAPEFFECT_OVERLAY = 4, + D3DSWAPEFFECT_FLIPEX = 5, +#endif + D3DSWAPEFFECT_FORCE_DWORD = 0xFFFFFFFF +} D3DSWAPEFFECT; + +typedef enum _D3DTEXTUREADDRESS { + D3DTADDRESS_WRAP = 1, + D3DTADDRESS_MIRROR = 2, + D3DTADDRESS_CLAMP = 3, + D3DTADDRESS_BORDER = 4, + D3DTADDRESS_MIRRORONCE = 5, + + D3DTADDRESS_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREADDRESS; + +typedef enum _D3DTEXTUREFILTERTYPE { + D3DTEXF_NONE = 0, + D3DTEXF_POINT = 1, + D3DTEXF_LINEAR = 2, + D3DTEXF_ANISOTROPIC = 3, + D3DTEXF_FLATCUBIC = 4, + D3DTEXF_GAUSSIANCUBIC = 5, + D3DTEXF_PYRAMIDALQUAD = 6, + D3DTEXF_GAUSSIANQUAD = 7, +#ifndef D3D_DISABLE_9EX + D3DTEXF_CONVOLUTIONMONO = 8, +#endif + D3DTEXF_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREFILTERTYPE; + +typedef enum _D3DTEXTUREOP { + D3DTOP_DISABLE = 1, + D3DTOP_SELECTARG1 = 2, + D3DTOP_SELECTARG2 = 3, + D3DTOP_MODULATE = 4, + D3DTOP_MODULATE2X = 5, + D3DTOP_MODULATE4X = 6, + D3DTOP_ADD = 7, + D3DTOP_ADDSIGNED = 8, + D3DTOP_ADDSIGNED2X = 9, + D3DTOP_SUBTRACT = 10, + D3DTOP_ADDSMOOTH = 11, + D3DTOP_BLENDDIFFUSEALPHA = 12, + D3DTOP_BLENDTEXTUREALPHA = 13, + D3DTOP_BLENDFACTORALPHA = 14, + D3DTOP_BLENDTEXTUREALPHAPM = 15, + D3DTOP_BLENDCURRENTALPHA = 16, + D3DTOP_PREMODULATE = 17, + D3DTOP_MODULATEALPHA_ADDCOLOR = 18, + D3DTOP_MODULATECOLOR_ADDALPHA = 19, + D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, + D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, + D3DTOP_BUMPENVMAP = 22, + D3DTOP_BUMPENVMAPLUMINANCE = 23, + D3DTOP_DOTPRODUCT3 = 24, + D3DTOP_MULTIPLYADD = 25, + D3DTOP_LERP = 26, + + D3DTOP_FORCE_DWORD = 0x7fffffff, +} D3DTEXTUREOP; + +typedef enum _D3DTEXTURESTAGESTATETYPE { + D3DTSS_COLOROP = 1, + D3DTSS_COLORARG1 = 2, + D3DTSS_COLORARG2 = 3, + D3DTSS_ALPHAOP = 4, + D3DTSS_ALPHAARG1 = 5, + D3DTSS_ALPHAARG2 = 6, + D3DTSS_BUMPENVMAT00 = 7, + D3DTSS_BUMPENVMAT01 = 8, + D3DTSS_BUMPENVMAT10 = 9, + D3DTSS_BUMPENVMAT11 = 10, + D3DTSS_TEXCOORDINDEX = 11, + D3DTSS_BUMPENVLSCALE = 22, + D3DTSS_BUMPENVLOFFSET = 23, + D3DTSS_TEXTURETRANSFORMFLAGS = 24, + D3DTSS_COLORARG0 = 26, + D3DTSS_ALPHAARG0 = 27, + D3DTSS_RESULTARG = 28, + D3DTSS_CONSTANT = 32, + + D3DTSS_FORCE_DWORD = 0x7fffffff +} D3DTEXTURESTAGESTATETYPE; + +typedef enum _D3DTEXTURETRANSFORMFLAGS { + D3DTTFF_DISABLE = 0, + D3DTTFF_COUNT1 = 1, + D3DTTFF_COUNT2 = 2, + D3DTTFF_COUNT3 = 3, + D3DTTFF_COUNT4 = 4, + D3DTTFF_PROJECTED = 256, + + D3DTTFF_FORCE_DWORD = 0x7fffffff +} D3DTEXTURETRANSFORMFLAGS; + +typedef enum _D3DTRANSFORMSTATETYPE { + D3DTS_VIEW = 2, + D3DTS_PROJECTION = 3, + D3DTS_TEXTURE0 = 16, + D3DTS_TEXTURE1 = 17, + D3DTS_TEXTURE2 = 18, + D3DTS_TEXTURE3 = 19, + D3DTS_TEXTURE4 = 20, + D3DTS_TEXTURE5 = 21, + D3DTS_TEXTURE6 = 22, + D3DTS_TEXTURE7 = 23, + + D3DTS_FORCE_DWORD = 0x7fffffff +} D3DTRANSFORMSTATETYPE; + +typedef enum _D3DVERTEXBLENDFLAGS { + D3DVBF_DISABLE = 0, + D3DVBF_1WEIGHTS = 1, + D3DVBF_2WEIGHTS = 2, + D3DVBF_3WEIGHTS = 3, + D3DVBF_TWEENING = 255, + D3DVBF_0WEIGHTS = 256 +} D3DVERTEXBLENDFLAGS; + +typedef enum _D3DZBUFFERTYPE { + D3DZB_FALSE = 0, + D3DZB_TRUE = 1, + D3DZB_USEW = 2, + + D3DZB_FORCE_DWORD = 0x7fffffff +} D3DZBUFFERTYPE; + +typedef enum _D3DSAMPLERSTATETYPE { + D3DSAMP_ADDRESSU = 1, + D3DSAMP_ADDRESSV = 2, + D3DSAMP_ADDRESSW = 3, + D3DSAMP_BORDERCOLOR = 4, + D3DSAMP_MAGFILTER = 5, + D3DSAMP_MINFILTER = 6, + D3DSAMP_MIPFILTER = 7, + D3DSAMP_MIPMAPLODBIAS = 8, + D3DSAMP_MAXMIPLEVEL = 9, + D3DSAMP_MAXANISOTROPY = 10, + D3DSAMP_SRGBTEXTURE = 11, + D3DSAMP_ELEMENTINDEX = 12, + D3DSAMP_DMAPOFFSET = 13, + + D3DSAMP_FORCE_DWORD = 0x7fffffff, +} D3DSAMPLERSTATETYPE; + + +/***************************************************************************** + * Direct 3D v9 typedefs + */ +#ifndef D3DCOLOR_DEFINED +typedef DWORD D3DCOLOR; +#define D3DCOLOR_DEFINED +#endif + +/***************************************************************************** + * Direct 3D v9 structures + */ +typedef struct _D3DADAPTER_IDENTIFIER9 { + char Driver[MAX_DEVICE_IDENTIFIER_STRING]; + char Description[MAX_DEVICE_IDENTIFIER_STRING]; + char DeviceName[32]; + LARGE_INTEGER DriverVersion; + + DWORD VendorId; + DWORD DeviceId; + DWORD SubSysId; + DWORD Revision; + + GUID DeviceIdentifier; + + DWORD WHQLLevel; +} D3DADAPTER_IDENTIFIER9; + +typedef struct _D3DBOX { + UINT Left; + UINT Top; + UINT Right; + UINT Bottom; + UINT Front; + UINT Back; +} D3DBOX; + +typedef struct _D3DCLIPSTATUS9 { + DWORD ClipUnion; + DWORD ClipIntersection; +} D3DCLIPSTATUS9; + +#ifndef D3DCOLORVALUE_DEFINED +typedef struct _D3DCOLORVALUE { + float r; + float g; + float b; + float a; +} D3DCOLORVALUE; +#define D3DCOLORVALUE_DEFINED +#endif + +typedef struct _D3DDEVICE_CREATION_PARAMETERS { + UINT AdapterOrdinal; + D3DDEVTYPE DeviceType; + HWND hFocusWindow; + DWORD BehaviorFlags; +} D3DDEVICE_CREATION_PARAMETERS; + +typedef struct _D3DDEVINFO_D3D9BANDWIDTHTIMINGS { + float MaxBandwidthUtilized; + float FrontEndUploadMemoryUtilizedPercent; + float VertexRateUtilizedPercent; + float TriangleSetupRateUtilizedPercent; + float FillRateUtilizedPercent; +} D3DDEVINFO_D3D9BANDWIDTHTIMINGS; + +typedef struct _D3DDEVINFO_D3D9CACHEUTILIZATION { + float TextureCacheHitRate; + float PostTransformVertexCacheHitRate; +} D3DDEVINFO_D3D9CACHEUTILIZATION; + +typedef struct _D3DDEVINFO_D3D9INTERFACETIMINGS { + float WaitingForGPUToUseApplicationResourceTimePercent; + float WaitingForGPUToAcceptMoreCommandsTimePercent; + float WaitingForGPUToStayWithinLatencyTimePercent; + float WaitingForGPUExclusiveResourceTimePercent; + float WaitingForGPUOtherTimePercent; +} D3DDEVINFO_D3D9INTERFACETIMINGS; + +typedef struct _D3DDEVINFO_D3D9PIPELINETIMINGS { + float VertexProcessingTimePercent; + float PixelProcessingTimePercent; + float OtherGPUProcessingTimePercent; + float GPUIdleTimePercent; +} D3DDEVINFO_D3D9PIPELINETIMINGS; + +typedef struct _D3DDEVINFO_D3D9STAGETIMINGS { + float MemoryProcessingPercent; + float ComputationProcessingPercent; +} D3DDEVINFO_D3D9STAGETIMINGS; + + +/* Vertex cache optimization hints. */ +typedef struct D3DDEVINFO_VCACHE { + /* Must be a 4 char code FOURCC (e.g. CACH) */ + DWORD Pattern; + /* 0 to get the longest strips, 1 vertex cache */ + DWORD OptMethod; + /* Cache size to use (only valid if OptMethod==1) */ + DWORD CacheSize; + /* internal for deciding when to restart strips, non user modifiable (only valid if OptMethod==1) */ + DWORD MagicNumber; +} D3DDEVINFO_VCACHE; + +typedef struct D3DRESOURCESTATS { + BOOL bThrashing; + DWORD ApproxBytesDownloaded; + DWORD NumEvicts; + DWORD NumVidCreates; + DWORD LastPri; + DWORD NumUsed; + DWORD NumUsedInVidMem; + DWORD WorkingSet; + DWORD WorkingSetBytes; + DWORD TotalManaged; + DWORD TotalBytes; +} D3DRESOURCESTATS; + +typedef struct _D3DDEVINFO_RESOURCEMANAGER { + D3DRESOURCESTATS stats[D3DRTYPECOUNT]; +} D3DDEVINFO_RESOURCEMANAGER; + +typedef struct _D3DDEVINFO_D3DVERTEXSTATS { + DWORD NumRenderedTriangles; + DWORD NumExtraClippingTriangles; +} D3DDEVINFO_D3DVERTEXSTATS; + +typedef struct _D3DDISPLAYMODE { + UINT Width; + UINT Height; + UINT RefreshRate; + D3DFORMAT Format; +} D3DDISPLAYMODE; + +typedef struct _D3DGAMMARAMP { + WORD red [256]; + WORD green[256]; + WORD blue [256]; +} D3DGAMMARAMP; + +typedef struct _D3DINDEXBUFFER_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + UINT Size; +} D3DINDEXBUFFER_DESC; + +#ifndef D3DVECTOR_DEFINED +typedef struct _D3DVECTOR { + float x; + float y; + float z; +} D3DVECTOR; +#define D3DVECTOR_DEFINED +#endif + +typedef struct _D3DLIGHT9 { + D3DLIGHTTYPE Type; + D3DCOLORVALUE Diffuse; + D3DCOLORVALUE Specular; + D3DCOLORVALUE Ambient; + D3DVECTOR Position; + D3DVECTOR Direction; + float Range; + float Falloff; + float Attenuation0; + float Attenuation1; + float Attenuation2; + float Theta; + float Phi; +} D3DLIGHT9; + +typedef struct _D3DLINEPATTERN { + WORD wRepeatFactor; + WORD wLinePattern; +} D3DLINEPATTERN; + +typedef struct _D3DLOCKED_BOX { + INT RowPitch; + INT SlicePitch; + void* pBits; +} D3DLOCKED_BOX; + +typedef struct _D3DLOCKED_RECT { + INT Pitch; + void* pBits; +} D3DLOCKED_RECT; + +typedef struct _D3DMATERIAL9 { + D3DCOLORVALUE Diffuse; + D3DCOLORVALUE Ambient; + D3DCOLORVALUE Specular; + D3DCOLORVALUE Emissive; + float Power; +} D3DMATERIAL9; + +#ifndef D3DMATRIX_DEFINED +typedef struct _D3DMATRIX { + union { + struct { + float _11, _12, _13, _14; + float _21, _22, _23, _24; + float _31, _32, _33, _34; + float _41, _42, _43, _44; + } DUMMYSTRUCTNAME; + float m[4][4]; + } DUMMYUNIONNAME; +} D3DMATRIX; +#define D3DMATRIX_DEFINED +#endif + +typedef struct _D3DPRESENT_PARAMETERS_ { + UINT BackBufferWidth; + UINT BackBufferHeight; + D3DFORMAT BackBufferFormat; + UINT BackBufferCount; + + D3DMULTISAMPLE_TYPE MultiSampleType; + DWORD MultiSampleQuality; + + D3DSWAPEFFECT SwapEffect; + HWND hDeviceWindow; + BOOL Windowed; + BOOL EnableAutoDepthStencil; + D3DFORMAT AutoDepthStencilFormat; + DWORD Flags; + + UINT FullScreen_RefreshRateInHz; + UINT PresentationInterval; + +} D3DPRESENT_PARAMETERS; + +typedef struct _D3DRANGE { + UINT Offset; + UINT Size; +} D3DRANGE; + +typedef struct _D3DRASTER_STATUS { + BOOL InVBlank; + UINT ScanLine; +} D3DRASTER_STATUS; + +#ifndef D3DRECT_DEFINED +typedef struct _D3DRECT { + LONG x1; + LONG y1; + LONG x2; + LONG y2; +} D3DRECT; +#define D3DRECT_DEFINED +#endif + +typedef struct _D3DRECTPATCH_INFO { + UINT StartVertexOffsetWidth; + UINT StartVertexOffsetHeight; + UINT Width; + UINT Height; + UINT Stride; + D3DBASISTYPE Basis; + D3DDEGREETYPE Degree; +} D3DRECTPATCH_INFO; + +typedef struct _D3DSURFACE_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + D3DMULTISAMPLE_TYPE MultiSampleType; + DWORD MultiSampleQuality; + UINT Width; + UINT Height; +} D3DSURFACE_DESC; + +typedef struct _D3DTRIPATCH_INFO { + UINT StartVertexOffset; + UINT NumVertices; + D3DBASISTYPE Basis; + D3DDEGREETYPE Degree; +} D3DTRIPATCH_INFO; + +typedef struct _D3DVERTEXBUFFER_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + UINT Size; + DWORD FVF; +} D3DVERTEXBUFFER_DESC; + +typedef struct _D3DVIEWPORT9 { + DWORD X; + DWORD Y; + DWORD Width; + DWORD Height; + float MinZ; + float MaxZ; +} D3DVIEWPORT9; + +typedef struct _D3DVOLUME_DESC { + D3DFORMAT Format; + D3DRESOURCETYPE Type; + DWORD Usage; + D3DPOOL Pool; + + UINT Width; + UINT Height; + UINT Depth; +} D3DVOLUME_DESC; + +/* Parts added with d3d9ex */ +#if !defined(D3D_DISABLE_9EX) +typedef enum D3DSCANLINEORDERING +{ + D3DSCANLINEORDERING_UNKNOWN, + D3DSCANLINEORDERING_PROGRESSIVE, + D3DSCANLINEORDERING_INTERLACED, +} D3DSCANLINEORDERING; + + +typedef struct D3DDISPLAYMODEFILTER +{ + UINT Size; + D3DFORMAT Format; + D3DSCANLINEORDERING ScanLineOrdering; +} D3DDISPLAYMODEFILTER; + +typedef struct D3DDISPLAYMODEEX +{ + UINT Size; + UINT Width; + UINT Height; + UINT RefreshRate; + D3DFORMAT Format; + D3DSCANLINEORDERING ScanLineOrdering; +} D3DDISPLAYMODEEX; + +typedef enum D3DDISPLAYROTATION +{ + D3DDISPLAYROTATION_IDENTITY = 1, + D3DDISPLAYROTATION_90, + D3DDISPLAYROTATION_180, + D3DDISPLAYROTATION_270 +} D3DDISPLAYROTATION; + +typedef struct _D3DMEMORYPRESSURE +{ + UINT64 BytesEvictedFromProcess; + UINT64 SizeOfInefficientAllocation; + DWORD LevelOfEfficiency; +} D3DMEMORYPRESSURE; + +typedef enum _D3DCOMPOSERECTSOP{ + D3DCOMPOSERECTS_COPY = 1, + D3DCOMPOSERECTS_OR, + D3DCOMPOSERECTS_AND, + D3DCOMPOSERECTS_NEG, + D3DCOMPOSERECTS_FORCE_DWORD = 0x7fffffff +} D3DCOMPOSERECTSOP; + +typedef struct _D3DPRESENTSTATS +{ + UINT PresentCount; + UINT PresentRefreshCount; + UINT SyncRefreshCount; + LARGE_INTEGER SyncQPCTime; + LARGE_INTEGER SyncGPUTime; +} D3DPRESENTSTATS; + +#endif /* D3D_DISABLE_9EX */ + +typedef enum _D3DSHADER_COMPARISON +{ + D3DSPC_RESERVED0 = 0, + D3DSPC_GT, + D3DSPC_EQ, + D3DSPC_GE, + D3DSPC_LT, + D3DSPC_NE, + D3DSPC_LE, + D3DSPC_RESERVED1, +} D3DSHADER_COMPARISON; + +#ifdef __i386__ +#pragma pack(pop) +#endif + +#endif /* __WINE_D3D9TYPES_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dcaps.h b/WineFix/lib/d2d1/include/windows/d3dcaps.h new file mode 100644 index 0000000..93990a6 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dcaps.h @@ -0,0 +1,439 @@ +/* + * Copyright (C) 2000 Peter Hunnisett + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DCAPS_H +#define __WINE_D3DCAPS_H + +#include + +#ifdef __i386__ +#pragma pack(push,4) +#endif + +typedef struct _D3DTRANSFORMCAPS { + DWORD dwSize; + DWORD dwCaps; +} D3DTRANSFORMCAPS, *LPD3DTRANSFORMCAPS; + +#define D3DTRANSFORMCAPS_CLIP __MSABI_LONG(0x00000001) + +typedef struct _D3DLIGHTINGCAPS { + DWORD dwSize; + DWORD dwCaps; + DWORD dwLightingModel; + DWORD dwNumLights; +} D3DLIGHTINGCAPS, *LPD3DLIGHTINGCAPS; + +#define D3DLIGHTINGMODEL_RGB 0x00000001 +#define D3DLIGHTINGMODEL_MONO 0x00000002 + +#define D3DLIGHTCAPS_POINT 0x00000001 +#define D3DLIGHTCAPS_SPOT 0x00000002 +#define D3DLIGHTCAPS_DIRECTIONAL 0x00000004 +#define D3DLIGHTCAPS_PARALLELPOINT 0x00000008 +#define D3DLIGHTCAPS_GLSPOT 0x00000010 + +typedef struct _D3dPrimCaps { + DWORD dwSize; + DWORD dwMiscCaps; + DWORD dwRasterCaps; + DWORD dwZCmpCaps; + DWORD dwSrcBlendCaps; + DWORD dwDestBlendCaps; + DWORD dwAlphaCmpCaps; + DWORD dwShadeCaps; + DWORD dwTextureCaps; + DWORD dwTextureFilterCaps; + DWORD dwTextureBlendCaps; + DWORD dwTextureAddressCaps; + DWORD dwStippleWidth; + DWORD dwStippleHeight; +} D3DPRIMCAPS, *LPD3DPRIMCAPS; + +#define D3DPMISCCAPS_MASKPLANES 0x00000001 +#define D3DPMISCCAPS_MASKZ 0x00000002 +#define D3DPMISCCAPS_LINEPATTERNREP 0x00000004 +#define D3DPMISCCAPS_CONFORMANT 0x00000008 +#define D3DPMISCCAPS_CULLNONE 0x00000010 +#define D3DPMISCCAPS_CULLCW 0x00000020 +#define D3DPMISCCAPS_CULLCCW 0x00000040 + +#define D3DPRASTERCAPS_DITHER 0x00000001 +#define D3DPRASTERCAPS_ROP2 0x00000002 +#define D3DPRASTERCAPS_XOR 0x00000004 +#define D3DPRASTERCAPS_PAT 0x00000008 +#define D3DPRASTERCAPS_ZTEST 0x00000010 +#define D3DPRASTERCAPS_SUBPIXEL 0x00000020 +#define D3DPRASTERCAPS_SUBPIXELX 0x00000040 +#define D3DPRASTERCAPS_FOGVERTEX 0x00000080 +#define D3DPRASTERCAPS_FOGTABLE 0x00000100 +#define D3DPRASTERCAPS_STIPPLE 0x00000200 +#define D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT 0x00000400 +#define D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT 0x00000800 +#define D3DPRASTERCAPS_ANTIALIASEDGES 0x00001000 +#define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000 +#define D3DPRASTERCAPS_ZBIAS 0x00004000 +#define D3DPRASTERCAPS_ZBUFFERLESSHSR 0x00008000 +#define D3DPRASTERCAPS_FOGRANGE 0x00010000 +#define D3DPRASTERCAPS_ANISOTROPY 0x00020000 +#define D3DPRASTERCAPS_WBUFFER 0x00040000 +#define D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT 0x00080000 +#define D3DPRASTERCAPS_WFOG 0x00100000 +#define D3DPRASTERCAPS_ZFOG 0x00200000 + +#define D3DPCMPCAPS_NEVER 0x00000001 +#define D3DPCMPCAPS_LESS 0x00000002 +#define D3DPCMPCAPS_EQUAL 0x00000004 +#define D3DPCMPCAPS_LESSEQUAL 0x00000008 +#define D3DPCMPCAPS_GREATER 0x00000010 +#define D3DPCMPCAPS_NOTEQUAL 0x00000020 +#define D3DPCMPCAPS_GREATEREQUAL 0x00000040 +#define D3DPCMPCAPS_ALWAYS 0x00000080 + +#define D3DPBLENDCAPS_ZERO 0x00000001 +#define D3DPBLENDCAPS_ONE 0x00000002 +#define D3DPBLENDCAPS_SRCCOLOR 0x00000004 +#define D3DPBLENDCAPS_INVSRCCOLOR 0x00000008 +#define D3DPBLENDCAPS_SRCALPHA 0x00000010 +#define D3DPBLENDCAPS_INVSRCALPHA 0x00000020 +#define D3DPBLENDCAPS_DESTALPHA 0x00000040 +#define D3DPBLENDCAPS_INVDESTALPHA 0x00000080 +#define D3DPBLENDCAPS_DESTCOLOR 0x00000100 +#define D3DPBLENDCAPS_INVDESTCOLOR 0x00000200 +#define D3DPBLENDCAPS_SRCALPHASAT 0x00000400 +#define D3DPBLENDCAPS_BOTHSRCALPHA 0x00000800 +#define D3DPBLENDCAPS_BOTHINVSRCALPHA 0x00001000 + +#define D3DPSHADECAPS_COLORFLATMONO 0x00000001 +#define D3DPSHADECAPS_COLORFLATRGB 0x00000002 +#define D3DPSHADECAPS_COLORGOURAUDMONO 0x00000004 +#define D3DPSHADECAPS_COLORGOURAUDRGB 0x00000008 +#define D3DPSHADECAPS_COLORPHONGMONO 0x00000010 +#define D3DPSHADECAPS_COLORPHONGRGB 0x00000020 + +#define D3DPSHADECAPS_SPECULARFLATMONO 0x00000040 +#define D3DPSHADECAPS_SPECULARFLATRGB 0x00000080 +#define D3DPSHADECAPS_SPECULARGOURAUDMONO 0x00000100 +#define D3DPSHADECAPS_SPECULARGOURAUDRGB 0x00000200 +#define D3DPSHADECAPS_SPECULARPHONGMONO 0x00000400 +#define D3DPSHADECAPS_SPECULARPHONGRGB 0x00000800 + +#define D3DPSHADECAPS_ALPHAFLATBLEND 0x00001000 +#define D3DPSHADECAPS_ALPHAFLATSTIPPLED 0x00002000 +#define D3DPSHADECAPS_ALPHAGOURAUDBLEND 0x00004000 +#define D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED 0x00008000 +#define D3DPSHADECAPS_ALPHAPHONGBLEND 0x00010000 +#define D3DPSHADECAPS_ALPHAPHONGSTIPPLED 0x00020000 + +#define D3DPSHADECAPS_FOGFLAT 0x00040000 +#define D3DPSHADECAPS_FOGGOURAUD 0x00080000 +#define D3DPSHADECAPS_FOGPHONG 0x00100000 + +#define D3DPTEXTURECAPS_PERSPECTIVE 0x00000001 +#define D3DPTEXTURECAPS_POW2 0x00000002 +#define D3DPTEXTURECAPS_ALPHA 0x00000004 +#define D3DPTEXTURECAPS_TRANSPARENCY 0x00000008 +#define D3DPTEXTURECAPS_BORDER 0x00000010 +#define D3DPTEXTURECAPS_SQUAREONLY 0x00000020 +#define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE 0x00000040 +#define D3DPTEXTURECAPS_ALPHAPALETTE 0x00000080 +#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL __MSABI_LONG(0x00000100) +/* yes actually 0x00000200 is unused - or at least unreleased */ +#define D3DPTEXTURECAPS_PROJECTED 0x00000400 +#define D3DPTEXTURECAPS_CUBEMAP 0x00000800 +#define D3DPTEXTURECAPS_COLORKEYBLEND 0x00001000 + +#define D3DPTFILTERCAPS_NEAREST 0x00000001 +#define D3DPTFILTERCAPS_LINEAR 0x00000002 +#define D3DPTFILTERCAPS_MIPNEAREST 0x00000004 +#define D3DPTFILTERCAPS_MIPLINEAR 0x00000008 +#define D3DPTFILTERCAPS_LINEARMIPNEAREST 0x00000010 +#define D3DPTFILTERCAPS_LINEARMIPLINEAR 0x00000020 +/* yes - missing numbers */ +#define D3DPTFILTERCAPS_MINFPOINT 0x00000100 +#define D3DPTFILTERCAPS_MINFLINEAR 0x00000200 +#define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400 +/* yes - missing numbers */ +#define D3DPTFILTERCAPS_MIPFPOINT 0x00010000 +#define D3DPTFILTERCAPS_MIPFLINEAR 0x00020000 +/* yes - missing numbers */ +#define D3DPTFILTERCAPS_MAGFPOINT 0x01000000 +#define D3DPTFILTERCAPS_MAGFLINEAR 0x02000000 +#define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000 +#define D3DPTFILTERCAPS_MAGFAFLATCUBIC 0x08000000 +#define D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC 0x10000000 + +#define D3DPTBLENDCAPS_DECAL 0x00000001 +#define D3DPTBLENDCAPS_MODULATE 0x00000002 +#define D3DPTBLENDCAPS_DECALALPHA 0x00000004 +#define D3DPTBLENDCAPS_MODULATEALPHA 0x00000008 +#define D3DPTBLENDCAPS_DECALMASK 0x00000010 +#define D3DPTBLENDCAPS_MODULATEMASK 0x00000020 +#define D3DPTBLENDCAPS_COPY 0x00000040 +#define D3DPTBLENDCAPS_ADD 0x00000080 + +#define D3DPTADDRESSCAPS_WRAP 0x00000001 +#define D3DPTADDRESSCAPS_MIRROR 0x00000002 +#define D3DPTADDRESSCAPS_CLAMP 0x00000004 +#define D3DPTADDRESSCAPS_BORDER 0x00000008 +#define D3DPTADDRESSCAPS_INDEPENDENTUV 0x00000010 + + +typedef struct _D3DDeviceDesc { + DWORD dwSize; + DWORD dwFlags; + D3DCOLORMODEL dcmColorModel; + DWORD dwDevCaps; + D3DTRANSFORMCAPS dtcTransformCaps; + BOOL bClipping; + D3DLIGHTINGCAPS dlcLightingCaps; + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; + DWORD dwDeviceZBufferBitDepth; + DWORD dwMaxBufferSize; + DWORD dwMaxVertexCount; + + DWORD dwMinTextureWidth,dwMinTextureHeight; + DWORD dwMaxTextureWidth,dwMaxTextureHeight; + DWORD dwMinStippleWidth,dwMaxStippleWidth; + DWORD dwMinStippleHeight,dwMaxStippleHeight; + + DWORD dwMaxTextureRepeat; + DWORD dwMaxTextureAspectRatio; + DWORD dwMaxAnisotropy; + + D3DVALUE dvGuardBandLeft; + D3DVALUE dvGuardBandTop; + D3DVALUE dvGuardBandRight; + D3DVALUE dvGuardBandBottom; + + D3DVALUE dvExtentsAdjust; + DWORD dwStencilCaps; + + DWORD dwFVFCaps; + DWORD dwTextureOpCaps; + WORD wMaxTextureBlendStages; + WORD wMaxSimultaneousTextures; +} D3DDEVICEDESC,*LPD3DDEVICEDESC; +#define D3DDEVICEDESCSIZE (sizeof(D3DDEVICEDESC)) + +typedef struct _D3DDeviceDesc7 { + DWORD dwDevCaps; + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; + DWORD dwDeviceZBufferBitDepth; + + DWORD dwMinTextureWidth, dwMinTextureHeight; + DWORD dwMaxTextureWidth, dwMaxTextureHeight; + + DWORD dwMaxTextureRepeat; + DWORD dwMaxTextureAspectRatio; + DWORD dwMaxAnisotropy; + + D3DVALUE dvGuardBandLeft; + D3DVALUE dvGuardBandTop; + D3DVALUE dvGuardBandRight; + D3DVALUE dvGuardBandBottom; + + D3DVALUE dvExtentsAdjust; + DWORD dwStencilCaps; + DWORD dwFVFCaps; + DWORD dwTextureOpCaps; + WORD wMaxTextureBlendStages; + WORD wMaxSimultaneousTextures; + + DWORD dwMaxActiveLights; + D3DVALUE dvMaxVertexW; + GUID deviceGUID; + + WORD wMaxUserClipPlanes; + WORD wMaxVertexBlendMatrices; + + DWORD dwVertexProcessingCaps; + + DWORD dwReserved1; + DWORD dwReserved2; + DWORD dwReserved3; + DWORD dwReserved4; +} D3DDEVICEDESC7, *LPD3DDEVICEDESC7; +#define D3DDEVICEDESC7SIZE (sizeof(D3DDEVICEDESC7)) + +#define D3DDD_COLORMODEL 0x00000001 +#define D3DDD_DEVCAPS 0x00000002 +#define D3DDD_TRANSFORMCAPS 0x00000004 +#define D3DDD_LIGHTINGCAPS 0x00000008 +#define D3DDD_BCLIPPING 0x00000010 +#define D3DDD_LINECAPS 0x00000020 +#define D3DDD_TRICAPS 0x00000040 +#define D3DDD_DEVICERENDERBITDEPTH 0x00000080 +#define D3DDD_DEVICEZBUFFERBITDEPTH 0x00000100 +#define D3DDD_MAXBUFFERSIZE 0x00000200 +#define D3DDD_MAXVERTEXCOUNT 0x00000400 + +#define D3DDEVCAPS_FLOATTLVERTEX 0x00000001 +#define D3DDEVCAPS_SORTINCREASINGZ 0x00000002 +#define D3DDEVCAPS_SORTDECREASINGZ 0X00000004 +#define D3DDEVCAPS_SORTEXACT 0x00000008 +#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010 +#define D3DDEVCAPS_EXECUTEVIDEOMEMORY 0x00000020 +#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040 +#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x00000080 +#define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x00000100 +#define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x00000200 +#define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x00000400 +#define D3DDEVCAPS_CANRENDERAFTERFLIP 0x00000800 +#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000 +#define D3DDEVCAPS_DRAWPRIMITIVES2 0x00002000 +#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000 +#define D3DDEVCAPS_DRAWPRIMITIVES2EX 0x00008000 +#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000 +#define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x00020000 +#define D3DDEVCAPS_HWRASTERIZATION 0x00080000 + +#define D3DSTENCILCAPS_KEEP 0x00000001 +#define D3DSTENCILCAPS_ZERO 0x00000002 +#define D3DSTENCILCAPS_REPLACE 0x00000004 +#define D3DSTENCILCAPS_INCRSAT 0x00000008 +#define D3DSTENCILCAPS_DECRSAT 0x00000010 +#define D3DSTENCILCAPS_INVERT 0x00000020 +#define D3DSTENCILCAPS_INCR 0x00000040 +#define D3DSTENCILCAPS_DECR 0x00000080 + +#define D3DTEXOPCAPS_DISABLE 0x00000001 +#define D3DTEXOPCAPS_SELECTARG1 0x00000002 +#define D3DTEXOPCAPS_SELECTARG2 0x00000004 +#define D3DTEXOPCAPS_MODULATE 0x00000008 +#define D3DTEXOPCAPS_MODULATE2X 0x00000010 +#define D3DTEXOPCAPS_MODULATE4X 0x00000020 +#define D3DTEXOPCAPS_ADD 0x00000040 +#define D3DTEXOPCAPS_ADDSIGNED 0x00000080 +#define D3DTEXOPCAPS_ADDSIGNED2X 0x00000100 +#define D3DTEXOPCAPS_SUBTRACT 0x00000200 +#define D3DTEXOPCAPS_ADDSMOOTH 0x00000400 +#define D3DTEXOPCAPS_BLENDDIFFUSEALPHA 0x00000800 +#define D3DTEXOPCAPS_BLENDTEXTUREALPHA 0x00001000 +#define D3DTEXOPCAPS_BLENDFACTORALPHA 0x00002000 +#define D3DTEXOPCAPS_BLENDTEXTUREALPHAPM 0x00004000 +#define D3DTEXOPCAPS_BLENDCURRENTALPHA 0x00008000 +#define D3DTEXOPCAPS_PREMODULATE 0x00010000 +#define D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR 0x00020000 +#define D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA 0x00040000 +#define D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR 0x00080000 +#define D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA 0x00100000 +#define D3DTEXOPCAPS_BUMPENVMAP 0x00200000 +#define D3DTEXOPCAPS_BUMPENVMAPLUMINANCE 0x00400000 +#define D3DTEXOPCAPS_DOTPRODUCT3 0x00800000 + +#define D3DFVFCAPS_TEXCOORDCOUNTMASK 0x0000FFFF +#define D3DFVFCAPS_DONOTSTRIPELEMENTS 0x00080000 + +#define D3DVTXPCAPS_TEXGEN 0x00000001 +#define D3DVTXPCAPS_MATERIALSOURCE7 0x00000002 +#define D3DVTXPCAPS_VERTEXFOG 0x00000004 +#define D3DVTXPCAPS_DIRECTIONALLIGHTS 0x00000008 +#define D3DVTXPCAPS_POSITIONALLIGHTS 0x00000010 +#define D3DVTXPCAPS_LOCALVIEWER 0x00000020 + +typedef HRESULT (CALLBACK *LPD3DENUMDEVICESCALLBACK)(GUID *guid, char *description, char *name, + D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc, void *ctx); +typedef HRESULT (CALLBACK *LPD3DENUMDEVICESCALLBACK7)(char *description, char *name, D3DDEVICEDESC7 *desc, void *ctx); + +#define D3DFDS_COLORMODEL 0x00000001 +#define D3DFDS_GUID 0x00000002 +#define D3DFDS_HARDWARE 0x00000004 +#define D3DFDS_TRIANGLES 0x00000008 +#define D3DFDS_LINES 0x00000010 +#define D3DFDS_MISCCAPS 0x00000020 +#define D3DFDS_RASTERCAPS 0x00000040 +#define D3DFDS_ZCMPCAPS 0x00000080 +#define D3DFDS_ALPHACMPCAPS 0x00000100 +#define D3DFDS_SRCBLENDCAPS 0x00000200 +#define D3DFDS_DSTBLENDCAPS 0x00000400 +#define D3DFDS_SHADECAPS 0x00000800 +#define D3DFDS_TEXTURECAPS 0x00001000 +#define D3DFDS_TEXTUREFILTERCAPS 0x00002000 +#define D3DFDS_TEXTUREBLENDCAPS 0x00004000 +#define D3DFDS_TEXTUREADDRESSCAPS 0x00008000 + +typedef struct _D3DFINDDEVICESEARCH { + DWORD dwSize; + DWORD dwFlags; + BOOL bHardware; + D3DCOLORMODEL dcmColorModel; + GUID guid; + DWORD dwCaps; + D3DPRIMCAPS dpcPrimCaps; +} D3DFINDDEVICESEARCH,*LPD3DFINDDEVICESEARCH; + +typedef struct _D3DFINDDEVICERESULT { + DWORD dwSize; + GUID guid; + D3DDEVICEDESC ddHwDesc; + D3DDEVICEDESC ddSwDesc; +} D3DFINDDEVICERESULT,*LPD3DFINDDEVICERESULT; + +typedef struct _D3DExecuteBufferDesc { + DWORD dwSize; + DWORD dwFlags; + DWORD dwCaps; + DWORD dwBufferSize; + void *lpData; +} D3DEXECUTEBUFFERDESC, *LPD3DEXECUTEBUFFERDESC; + +#define D3DDEB_BUFSIZE 0x00000001 +#define D3DDEB_CAPS 0x00000002 +#define D3DDEB_LPDATA 0x00000004 + +#define D3DDEBCAPS_SYSTEMMEMORY 0x00000001 +#define D3DDEBCAPS_VIDEOMEMORY 0x00000002 +#define D3DDEBCAPS_MEM (D3DDEBCAPS_SYSTEMMEMORY|D3DDEBCAPS_VIDEOMEMORY) /* = 0x3 */ + +typedef struct _D3DDEVINFO_TEXTUREMANAGER { + BOOL bThrashing; + DWORD dwApproxBytesDownloaded; + DWORD dwNumEvicts; + DWORD dwNumVidCreates; + DWORD dwNumTexturesUsed; + DWORD dwNumUsedTexInVid; + DWORD dwWorkingSet; + DWORD dwWorkingSetBytes; + DWORD dwTotalManaged; + DWORD dwTotalBytes; + DWORD dwLastPri; +} D3DDEVINFO_TEXTUREMANAGER, *LPD3DDEVINFO_TEXTUREMANAGER; + +typedef struct _D3DDEVINFO_TEXTURING { + DWORD dwNumLoads; + DWORD dwApproxBytesLoaded; + DWORD dwNumPreLoads; + DWORD dwNumSet; + DWORD dwNumCreates; + DWORD dwNumDestroys; + DWORD dwNumSetPriorities; + DWORD dwNumSetLODs; + DWORD dwNumLocks; + DWORD dwNumGetDCs; +} D3DDEVINFO_TEXTURING, *LPD3DDEVINFO_TEXTURING; + +#ifdef __i386__ +#pragma pack(pop) +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dcommon.idl b/WineFix/lib/d2d1/include/windows/d3dcommon.idl new file mode 100644 index 0000000..7d3c486 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dcommon.idl @@ -0,0 +1,749 @@ +/* + * Copyright 2010 Matteo Bruni for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; + +typedef struct _D3D_SHADER_MACRO +{ + const char *Name; + const char *Definition; +} D3D_SHADER_MACRO; + +typedef struct _D3D_SHADER_MACRO* LPD3D_SHADER_MACRO; + +[ + object, + local, + uuid(8ba5fb08-5195-40e2-ac58-0d989c3a0102) +] +interface ID3D10Blob : IUnknown +{ + void *GetBufferPointer(); + SIZE_T GetBufferSize(); +} + +typedef ID3D10Blob* LPD3D10BLOB; +typedef ID3D10Blob ID3DBlob; +typedef ID3DBlob* LPD3DBLOB; +cpp_quote("#define IID_ID3DBlob IID_ID3D10Blob") + +typedef void(__stdcall *PFN_DESTRUCTION_CALLBACK)(void *data); + +[ + object, + local, + uuid(a06eb39a-50da-425b-8c31-4eecd6c270f3), + pointer_default(unique) +] +interface ID3DDestructionNotifier : IUnknown +{ + HRESULT RegisterDestructionCallback( + [in] PFN_DESTRUCTION_CALLBACK callback_func, + [in] void *data, + [out] UINT *callback_id + ); + HRESULT UnregisterDestructionCallback( + [in] UINT callback_id + ); +} + +typedef enum _D3D_INCLUDE_TYPE +{ + D3D_INCLUDE_LOCAL = 0, + D3D_INCLUDE_SYSTEM, + D3D10_INCLUDE_LOCAL = D3D_INCLUDE_LOCAL, + D3D10_INCLUDE_SYSTEM = D3D_INCLUDE_SYSTEM, + D3D_INCLUDE_FORCE_DWORD = 0x7fffffff +} D3D_INCLUDE_TYPE; + +[ + object, + local, +] +interface ID3DInclude +{ + HRESULT Open(D3D_INCLUDE_TYPE include_type, + const char *filename, + const void *parent_data, + const void **data, + UINT *bytes); + HRESULT Close(const void *data); +} + +typedef ID3DInclude* LPD3DINCLUDE; + +typedef enum D3D_DRIVER_TYPE +{ + D3D_DRIVER_TYPE_UNKNOWN, + D3D_DRIVER_TYPE_HARDWARE, + D3D_DRIVER_TYPE_REFERENCE, + D3D_DRIVER_TYPE_NULL, + D3D_DRIVER_TYPE_SOFTWARE, + D3D_DRIVER_TYPE_WARP, +} D3D_DRIVER_TYPE; + +typedef enum D3D_FEATURE_LEVEL +{ + D3D_FEATURE_LEVEL_1_0_CORE = 0x1000, + D3D_FEATURE_LEVEL_9_1 = 0x9100, + D3D_FEATURE_LEVEL_9_2 = 0x9200, + D3D_FEATURE_LEVEL_9_3 = 0x9300, + D3D_FEATURE_LEVEL_10_0 = 0xa000, + D3D_FEATURE_LEVEL_10_1 = 0xa100, + D3D_FEATURE_LEVEL_11_0 = 0xb000, + D3D_FEATURE_LEVEL_11_1 = 0xb100, + D3D_FEATURE_LEVEL_12_0 = 0xc000, + D3D_FEATURE_LEVEL_12_1 = 0xc100, + D3D_FEATURE_LEVEL_12_2 = 0xc200, +} D3D_FEATURE_LEVEL; + +cpp_quote("#define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION 2048") +cpp_quote("#define D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION 4096") +cpp_quote("#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION 2048") +cpp_quote("#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096") +cpp_quote("#define D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION 512") +cpp_quote("#define D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION 4096") +cpp_quote("#define D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION 256") +cpp_quote("#define D3D_FL9_1_DEFAULT_MAX_ANISOTROPY 2") +cpp_quote("#define D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT 65535") +cpp_quote("#define D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT 1048575") +cpp_quote("#define D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT 1") +cpp_quote("#define D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT 4") +cpp_quote("#define D3D_FL9_1_MAX_TEXTURE_REPEAT 128") +cpp_quote("#define D3D_FL9_2_MAX_TEXTURE_REPEAT 2048") +cpp_quote("#define D3D_FL9_3_MAX_TEXTURE_REPEAT 8192") + +typedef enum _D3D_SHADER_VARIABLE_CLASS +{ + D3D_SVC_SCALAR, + D3D_SVC_VECTOR, + D3D_SVC_MATRIX_ROWS, + D3D_SVC_MATRIX_COLUMNS, + D3D_SVC_OBJECT, + D3D_SVC_STRUCT, + D3D_SVC_INTERFACE_CLASS, + D3D_SVC_INTERFACE_POINTER, + D3D10_SVC_SCALAR = 0, + D3D10_SVC_VECTOR, + D3D10_SVC_MATRIX_ROWS, + D3D10_SVC_MATRIX_COLUMNS, + D3D10_SVC_OBJECT, + D3D10_SVC_STRUCT, + D3D11_SVC_INTERFACE_CLASS, + D3D11_SVC_INTERFACE_POINTER, + D3D_SVC_FORCE_DWORD = 0x7fffffff, +} D3D_SHADER_VARIABLE_CLASS; + +typedef enum _D3D_SHADER_VARIABLE_FLAGS +{ + D3D_SVF_USERPACKED = 0x01, + D3D_SVF_USED = 0x02, + D3D_SVF_INTERFACE_POINTER = 0x04, + D3D_SVF_INTERFACE_PARAMETER = 0x08, + D3D10_SVF_USERPACKED = D3D_SVF_USERPACKED, + D3D10_SVF_USED = D3D_SVF_USED, + D3D11_SVF_INTERFACE_POINTER = D3D_SVF_INTERFACE_POINTER, + D3D11_SVF_INTERFACE_PARAMETER = D3D_SVF_INTERFACE_PARAMETER, + D3D_SVF_FORCE_DWORD = 0x7fffffff +} D3D_SHADER_VARIABLE_FLAGS; + +typedef enum _D3D_SHADER_VARIABLE_TYPE +{ + D3D_SVT_VOID, + D3D_SVT_BOOL, + D3D_SVT_INT, + D3D_SVT_FLOAT, + D3D_SVT_STRING, + D3D_SVT_TEXTURE, + D3D_SVT_TEXTURE1D, + D3D_SVT_TEXTURE2D, + D3D_SVT_TEXTURE3D, + D3D_SVT_TEXTURECUBE, + D3D_SVT_SAMPLER, + D3D_SVT_SAMPLER1D, + D3D_SVT_SAMPLER2D, + D3D_SVT_SAMPLER3D, + D3D_SVT_SAMPLERCUBE, + D3D_SVT_PIXELSHADER, + D3D_SVT_VERTEXSHADER, + D3D_SVT_PIXELFRAGMENT, + D3D_SVT_VERTEXFRAGMENT, + D3D_SVT_UINT, + D3D_SVT_UINT8, + D3D_SVT_GEOMETRYSHADER, + D3D_SVT_RASTERIZER, + D3D_SVT_DEPTHSTENCIL, + D3D_SVT_BLEND, + D3D_SVT_BUFFER, + D3D_SVT_CBUFFER, + D3D_SVT_TBUFFER, + D3D_SVT_TEXTURE1DARRAY, + D3D_SVT_TEXTURE2DARRAY, + D3D_SVT_RENDERTARGETVIEW, + D3D_SVT_DEPTHSTENCILVIEW, + D3D_SVT_TEXTURE2DMS, + D3D_SVT_TEXTURE2DMSARRAY, + D3D_SVT_TEXTURECUBEARRAY, + D3D_SVT_HULLSHADER, + D3D_SVT_DOMAINSHADER, + D3D_SVT_INTERFACE_POINTER, + D3D_SVT_COMPUTESHADER, + D3D_SVT_DOUBLE, + D3D_SVT_RWTEXTURE1D, + D3D_SVT_RWTEXTURE1DARRAY, + D3D_SVT_RWTEXTURE2D, + D3D_SVT_RWTEXTURE2DARRAY, + D3D_SVT_RWTEXTURE3D, + D3D_SVT_RWBUFFER, + D3D_SVT_BYTEADDRESS_BUFFER, + D3D_SVT_RWBYTEADDRESS_BUFFER, + D3D_SVT_STRUCTURED_BUFFER, + D3D_SVT_RWSTRUCTURED_BUFFER, + D3D_SVT_APPEND_STRUCTURED_BUFFER, + D3D_SVT_CONSUME_STRUCTURED_BUFFER, + D3D_SVT_MIN8FLOAT, + D3D_SVT_MIN10FLOAT, + D3D_SVT_MIN16FLOAT, + D3D_SVT_MIN12INT, + D3D_SVT_MIN16INT, + D3D_SVT_MIN16UINT, + D3D10_SVT_VOID = 0, + D3D10_SVT_BOOL, + D3D10_SVT_INT, + D3D10_SVT_FLOAT, + D3D10_SVT_STRING, + D3D10_SVT_TEXTURE, + D3D10_SVT_TEXTURE1D, + D3D10_SVT_TEXTURE2D, + D3D10_SVT_TEXTURE3D, + D3D10_SVT_TEXTURECUBE, + D3D10_SVT_SAMPLER, + D3D10_SVT_SAMPLER1D, + D3D10_SVT_SAMPLER2D, + D3D10_SVT_SAMPLER3D, + D3D10_SVT_SAMPLERCUBE, + D3D10_SVT_PIXELSHADER, + D3D10_SVT_VERTEXSHADER, + D3D10_SVT_PIXELFRAGMENT, + D3D10_SVT_VERTEXFRAGMENT, + D3D10_SVT_UINT, + D3D10_SVT_UINT8, + D3D10_SVT_GEOMETRYSHADER, + D3D10_SVT_RASTERIZER, + D3D10_SVT_DEPTHSTENCIL, + D3D10_SVT_BLEND, + D3D10_SVT_BUFFER, + D3D10_SVT_CBUFFER, + D3D10_SVT_TBUFFER, + D3D10_SVT_TEXTURE1DARRAY, + D3D10_SVT_TEXTURE2DARRAY, + D3D10_SVT_RENDERTARGETVIEW, + D3D10_SVT_DEPTHSTENCILVIEW, + D3D10_SVT_TEXTURE2DMS, + D3D10_SVT_TEXTURE2DMSARRAY, + D3D10_SVT_TEXTURECUBEARRAY, + D3D11_SVT_HULLSHADER, + D3D11_SVT_DOMAINSHADER, + D3D11_SVT_INTERFACE_POINTER, + D3D11_SVT_COMPUTESHADER, + D3D11_SVT_DOUBLE, + D3D11_SVT_RWTEXTURE1D, + D3D11_SVT_RWTEXTURE1DARRAY, + D3D11_SVT_RWTEXTURE2D, + D3D11_SVT_RWTEXTURE2DARRAY, + D3D11_SVT_RWTEXTURE3D, + D3D11_SVT_RWBUFFER, + D3D11_SVT_BYTEADDRESS_BUFFER, + D3D11_SVT_RWBYTEADDRESS_BUFFER, + D3D11_SVT_STRUCTURED_BUFFER, + D3D11_SVT_RWSTRUCTURED_BUFFER, + D3D11_SVT_APPEND_STRUCTURED_BUFFER, + D3D11_SVT_CONSUME_STRUCTURED_BUFFER, + D3D_SVT_FORCE_DWORD = 0x7fffffff, +} D3D_SHADER_VARIABLE_TYPE; + +typedef enum _D3D_SHADER_INPUT_FLAGS +{ + D3D_SIF_USERPACKED = 0x01, + D3D_SIF_COMPARISON_SAMPLER = 0x02, + D3D_SIF_TEXTURE_COMPONENT_0 = 0x04, + D3D_SIF_TEXTURE_COMPONENT_1 = 0x08, + D3D_SIF_TEXTURE_COMPONENTS = 0x0C, + D3D_SIF_UNUSED = 0x10, + D3D10_SIF_USERPACKED = D3D_SIF_USERPACKED, + D3D10_SIF_COMPARISON_SAMPLER = D3D_SIF_COMPARISON_SAMPLER, + D3D10_SIF_TEXTURE_COMPONENT_0 = D3D_SIF_TEXTURE_COMPONENT_0, + D3D10_SIF_TEXTURE_COMPONENT_1 = D3D_SIF_TEXTURE_COMPONENT_1, + D3D10_SIF_TEXTURE_COMPONENTS = D3D_SIF_TEXTURE_COMPONENTS, + D3D_SIF_FORCE_DWORD = 0x7fffffff +} D3D_SHADER_INPUT_FLAGS; + +typedef enum D3D_PRIMITIVE +{ + D3D_PRIMITIVE_UNDEFINED, + D3D_PRIMITIVE_POINT, + D3D_PRIMITIVE_LINE, + D3D_PRIMITIVE_TRIANGLE, + D3D_PRIMITIVE_LINE_ADJ = 6, + D3D_PRIMITIVE_TRIANGLE_ADJ, + D3D_PRIMITIVE_1_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_2_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_3_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_4_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_5_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_6_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_7_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_8_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_9_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_10_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_11_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_12_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_13_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_14_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_15_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_16_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_17_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_18_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_19_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_20_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_21_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_22_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_23_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_24_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_25_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_26_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_27_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_28_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_29_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_30_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_31_CONTROL_POINT_PATCH, + D3D_PRIMITIVE_32_CONTROL_POINT_PATCH, + D3D10_PRIMITIVE_UNDEFINED = 0, + D3D10_PRIMITIVE_POINT, + D3D10_PRIMITIVE_LINE, + D3D10_PRIMITIVE_TRIANGLE, + D3D10_PRIMITIVE_LINE_ADJ = 6, + D3D10_PRIMITIVE_TRIANGLE_ADJ, + D3D11_PRIMITIVE_UNDEFINED = 0, + D3D11_PRIMITIVE_POINT, + D3D11_PRIMITIVE_LINE, + D3D11_PRIMITIVE_TRIANGLE, + D3D11_PRIMITIVE_LINE_ADJ = 6, + D3D11_PRIMITIVE_TRIANGLE_ADJ, + D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH, +} D3D_PRIMITIVE; + +typedef enum D3D_PRIMITIVE_TOPOLOGY +{ + D3D_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D_PRIMITIVE_TOPOLOGY_POINTLIST, + D3D_PRIMITIVE_TOPOLOGY_LINELIST, + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, + D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33, + D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST, + D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST, + D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED = 0, + D3D10_PRIMITIVE_TOPOLOGY_POINTLIST, + D3D10_PRIMITIVE_TOPOLOGY_LINELIST, + D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, + D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED = 0, + D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, + D3D11_PRIMITIVE_TOPOLOGY_LINELIST, + D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, + D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33, + D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST, +} D3D_PRIMITIVE_TOPOLOGY; + +typedef enum D3D_TESSELLATOR_DOMAIN +{ + D3D_TESSELLATOR_DOMAIN_UNDEFINED, + D3D_TESSELLATOR_DOMAIN_ISOLINE, + D3D_TESSELLATOR_DOMAIN_TRI, + D3D_TESSELLATOR_DOMAIN_QUAD, + D3D11_TESSELLATOR_DOMAIN_UNDEFINED = 0, + D3D11_TESSELLATOR_DOMAIN_ISOLINE, + D3D11_TESSELLATOR_DOMAIN_TRI, + D3D11_TESSELLATOR_DOMAIN_QUAD, +} D3D_TESSELLATOR_DOMAIN; + +typedef enum D3D_TESSELLATOR_PARTITIONING +{ + D3D_TESSELLATOR_PARTITIONING_UNDEFINED, + D3D_TESSELLATOR_PARTITIONING_INTEGER, + D3D_TESSELLATOR_PARTITIONING_POW2, + D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD, + D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN, + D3D11_TESSELLATOR_PARTITIONING_UNDEFINED = 0, + D3D11_TESSELLATOR_PARTITIONING_INTEGER, + D3D11_TESSELLATOR_PARTITIONING_POW2, + D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD, + D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN, +} D3D_TESSELLATOR_PARTITIONING; + +typedef enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE +{ + D3D_TESSELLATOR_OUTPUT_UNDEFINED, + D3D_TESSELLATOR_OUTPUT_POINT, + D3D_TESSELLATOR_OUTPUT_LINE, + D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW, + D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW, + D3D11_TESSELLATOR_OUTPUT_UNDEFINED = 0, + D3D11_TESSELLATOR_OUTPUT_POINT, + D3D11_TESSELLATOR_OUTPUT_LINE, + D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW, + D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW, +} D3D_TESSELLATOR_OUTPUT_PRIMITIVE; + +typedef enum D3D_MIN_PRECISION +{ + D3D_MIN_PRECISION_DEFAULT = 0, + D3D_MIN_PRECISION_FLOAT_16 = 1, + D3D_MIN_PRECISION_FLOAT_2_8 = 2, + D3D_MIN_PRECISION_RESERVED = 3, + D3D_MIN_PRECISION_SINT_16 = 4, + D3D_MIN_PRECISION_UINT_16 = 5, + D3D_MIN_PRECISION_ANY_16 = 0xf0, + D3D_MIN_PRECISION_ANY_10 = 0xf1, +} D3D_MIN_PRECISION; + +typedef enum D3D_CBUFFER_TYPE +{ + D3D_CT_CBUFFER, + D3D_CT_TBUFFER, + D3D_CT_INTERFACE_POINTERS, + D3D_CT_RESOURCE_BIND_INFO, + D3D10_CT_CBUFFER = 0, + D3D10_CT_TBUFFER, + D3D11_CT_CBUFFER = 0, + D3D11_CT_TBUFFER, + D3D11_CT_INTERFACE_POINTERS, + D3D11_CT_RESOURCE_BIND_INFO, +} D3D_CBUFFER_TYPE; + +typedef enum D3D_SRV_DIMENSION +{ + D3D_SRV_DIMENSION_UNKNOWN, + D3D_SRV_DIMENSION_BUFFER, + D3D_SRV_DIMENSION_TEXTURE1D, + D3D_SRV_DIMENSION_TEXTURE1DARRAY, + D3D_SRV_DIMENSION_TEXTURE2D, + D3D_SRV_DIMENSION_TEXTURE2DARRAY, + D3D_SRV_DIMENSION_TEXTURE2DMS, + D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D_SRV_DIMENSION_TEXTURE3D, + D3D_SRV_DIMENSION_TEXTURECUBE, + D3D_SRV_DIMENSION_TEXTURECUBEARRAY, + D3D_SRV_DIMENSION_BUFFEREX, + D3D10_SRV_DIMENSION_UNKNOWN = 0, + D3D10_SRV_DIMENSION_BUFFER, + D3D10_SRV_DIMENSION_TEXTURE1D, + D3D10_SRV_DIMENSION_TEXTURE1DARRAY, + D3D10_SRV_DIMENSION_TEXTURE2D, + D3D10_SRV_DIMENSION_TEXTURE2DARRAY, + D3D10_SRV_DIMENSION_TEXTURE2DMS, + D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_SRV_DIMENSION_TEXTURE3D, + D3D10_SRV_DIMENSION_TEXTURECUBE, + D3D10_1_SRV_DIMENSION_UNKNOWN = 0, + D3D10_1_SRV_DIMENSION_BUFFER, + D3D10_1_SRV_DIMENSION_TEXTURE1D, + D3D10_1_SRV_DIMENSION_TEXTURE1DARRAY, + D3D10_1_SRV_DIMENSION_TEXTURE2D, + D3D10_1_SRV_DIMENSION_TEXTURE2DARRAY, + D3D10_1_SRV_DIMENSION_TEXTURE2DMS, + D3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_1_SRV_DIMENSION_TEXTURE3D, + D3D10_1_SRV_DIMENSION_TEXTURECUBE, + D3D10_1_SRV_DIMENSION_TEXTURECUBEARRAY, + D3D11_SRV_DIMENSION_UNKNOWN = 0, + D3D11_SRV_DIMENSION_BUFFER, + D3D11_SRV_DIMENSION_TEXTURE1D, + D3D11_SRV_DIMENSION_TEXTURE1DARRAY, + D3D11_SRV_DIMENSION_TEXTURE2D, + D3D11_SRV_DIMENSION_TEXTURE2DARRAY, + D3D11_SRV_DIMENSION_TEXTURE2DMS, + D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D11_SRV_DIMENSION_TEXTURE3D, + D3D11_SRV_DIMENSION_TEXTURECUBE, + D3D11_SRV_DIMENSION_TEXTURECUBEARRAY, + D3D11_SRV_DIMENSION_BUFFEREX, +} D3D_SRV_DIMENSION; + +typedef enum D3D_REGISTER_COMPONENT_TYPE +{ + D3D_REGISTER_COMPONENT_UNKNOWN, + D3D_REGISTER_COMPONENT_UINT32, + D3D_REGISTER_COMPONENT_SINT32, + D3D_REGISTER_COMPONENT_FLOAT32, + D3D10_REGISTER_COMPONENT_UNKNOWN = 0, + D3D10_REGISTER_COMPONENT_UINT32, + D3D10_REGISTER_COMPONENT_SINT32, + D3D10_REGISTER_COMPONENT_FLOAT32, +} D3D_REGISTER_COMPONENT_TYPE; + +typedef enum D3D_RESOURCE_RETURN_TYPE +{ + D3D_RETURN_TYPE_UNORM = 1, + D3D_RETURN_TYPE_SNORM, + D3D_RETURN_TYPE_SINT, + D3D_RETURN_TYPE_UINT, + D3D_RETURN_TYPE_FLOAT, + D3D_RETURN_TYPE_MIXED, + D3D_RETURN_TYPE_DOUBLE, + D3D_RETURN_TYPE_CONTINUED, + D3D10_RETURN_TYPE_UNORM = 1, + D3D10_RETURN_TYPE_SNORM, + D3D10_RETURN_TYPE_SINT, + D3D10_RETURN_TYPE_UINT, + D3D10_RETURN_TYPE_FLOAT, + D3D10_RETURN_TYPE_MIXED, + D3D11_RETURN_TYPE_UNORM = 1, + D3D11_RETURN_TYPE_SNORM, + D3D11_RETURN_TYPE_SINT, + D3D11_RETURN_TYPE_UINT, + D3D11_RETURN_TYPE_FLOAT, + D3D11_RETURN_TYPE_MIXED, + D3D11_RETURN_TYPE_DOUBLE, + D3D11_RETURN_TYPE_CONTINUED, +} D3D_RESOURCE_RETURN_TYPE; + +typedef enum D3D_NAME +{ + D3D_NAME_UNDEFINED, + D3D_NAME_POSITION, + D3D_NAME_CLIP_DISTANCE, + D3D_NAME_CULL_DISTANCE, + D3D_NAME_RENDER_TARGET_ARRAY_INDEX, + D3D_NAME_VIEWPORT_ARRAY_INDEX, + D3D_NAME_VERTEX_ID, + D3D_NAME_PRIMITIVE_ID, + D3D_NAME_INSTANCE_ID, + D3D_NAME_IS_FRONT_FACE, + D3D_NAME_SAMPLE_INDEX, + D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR, + D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR, + D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR, + D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR, + D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR, + D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR, + D3D_NAME_BARYCENTRICS = 23, + D3D_NAME_SHADINGRATE, + D3D_NAME_CULLPRIMITIVE, + D3D_NAME_TARGET = 64, + D3D_NAME_DEPTH, + D3D_NAME_COVERAGE, + D3D_NAME_DEPTH_GREATER_EQUAL, + D3D_NAME_DEPTH_LESS_EQUAL, + D3D_NAME_STENCIL_REF, + D3D_NAME_INNER_COVERAGE, + D3D10_NAME_UNDEFINED = 0, + D3D10_NAME_POSITION, + D3D10_NAME_CLIP_DISTANCE, + D3D10_NAME_CULL_DISTANCE, + D3D10_NAME_RENDER_TARGET_ARRAY_INDEX, + D3D10_NAME_VIEWPORT_ARRAY_INDEX, + D3D10_NAME_VERTEX_ID, + D3D10_NAME_PRIMITIVE_ID, + D3D10_NAME_INSTANCE_ID, + D3D10_NAME_IS_FRONT_FACE, + D3D10_NAME_SAMPLE_INDEX, + D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR, + D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR, + D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR, + D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR, + D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR, + D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR, + D3D10_NAME_TARGET = 64, + D3D10_NAME_DEPTH, + D3D10_NAME_COVERAGE, + D3D11_NAME_DEPTH_GREATER_EQUAL, + D3D11_NAME_DEPTH_LESS_EQUAL, + D3D11_NAME_STENCIL_REF, + D3D11_NAME_INNER_COVERAGE, + D3D12_NAME_BARYCENTRICS = 23, + D3D12_NAME_SHADINGRATE, + D3D12_NAME_CULLPRIMITIVE, +} D3D_NAME; + +typedef enum _D3D_SHADER_INPUT_TYPE +{ + D3D_SIT_CBUFFER, + D3D_SIT_TBUFFER, + D3D_SIT_TEXTURE, + D3D_SIT_SAMPLER, + D3D_SIT_UAV_RWTYPED, + D3D_SIT_STRUCTURED, + D3D_SIT_UAV_RWSTRUCTURED, + D3D_SIT_BYTEADDRESS, + D3D_SIT_UAV_RWBYTEADDRESS, + D3D_SIT_UAV_APPEND_STRUCTURED, + D3D_SIT_UAV_CONSUME_STRUCTURED, + D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER, + D3D_SIT_RTACCELERATIONSTRUCTURE, + D3D_SIT_UAV_FEEDBACKTEXTURE, + D3D10_SIT_CBUFFER = 0, + D3D10_SIT_TBUFFER, + D3D10_SIT_TEXTURE, + D3D10_SIT_SAMPLER, + D3D11_SIT_UAV_RWTYPED, + D3D11_SIT_STRUCTURED, + D3D11_SIT_UAV_RWSTRUCTURED, + D3D11_SIT_BYTEADDRESS, + D3D11_SIT_UAV_RWBYTEADDRESS, + D3D11_SIT_UAV_APPEND_STRUCTURED, + D3D11_SIT_UAV_CONSUME_STRUCTURED, + D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER, +} D3D_SHADER_INPUT_TYPE; + +typedef enum _D3D_SHADER_CBUFFER_FLAGS +{ + D3D_CBF_USERPACKED = 0x01, + D3D10_CBF_USERPACKED = D3D_CBF_USERPACKED, + D3D_CBF_FORCE_DWORD = 0x7fffffff +} D3D_SHADER_CBUFFER_FLAGS; + +typedef enum _D3D_PARAMETER_FLAGS +{ + D3D_PF_NONE, + D3D_PF_IN, + D3D_PF_OUT, + D3D_PF_FORCE_DWORD = 0x7fffffff +} D3D_PARAMETER_FLAGS; + +typedef enum _D3D_INTERPOLATION_MODE +{ + D3D_INTERPOLATION_UNDEFINED, + D3D_INTERPOLATION_CONSTANT, + D3D_INTERPOLATION_LINEAR, + D3D_INTERPOLATION_LINEAR_CENTROID, + D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE, + D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID, + D3D_INTERPOLATION_LINEAR_SAMPLE, + D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE, +} D3D_INTERPOLATION_MODE; + +cpp_quote("DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);") diff --git a/WineFix/lib/d2d1/include/windows/d3dcompiler.h b/WineFix/lib/d2d1/include/windows/d3dcompiler.h new file mode 100644 index 0000000..14e5990 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dcompiler.h @@ -0,0 +1,164 @@ +/* + * Copyright 2010 Matteo Bruni for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DCOMPILER_H__ +#define __D3DCOMPILER_H__ + +#include "d3d11shader.h" +#include "d3d12shader.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_MSC_VER) || defined(__MINGW32__) +#define D3DCOMPILER_DLL_W L"d3dcompiler_47.dll" +#else +static const WCHAR D3DCOMPILER_DLL_W[] = {'d','3','d','c','o','m','p','i','l','e','r','_','4','7','.','d','l','l',0}; +#endif + +#define D3DCOMPILER_DLL_A "d3dcompiler_47.dll" +#define D3DCOMPILER_DLL WINELIB_NAME_AW(D3DCOMPILER_DLL_) + +#ifndef D3D_COMPILER_VERSION +#define D3D_COMPILER_VERSION 47 +#endif + +#define D3DCOMPILE_DEBUG 0x00000001 +#define D3DCOMPILE_SKIP_VALIDATION 0x00000002 +#define D3DCOMPILE_SKIP_OPTIMIZATION 0x00000004 +#define D3DCOMPILE_PACK_MATRIX_ROW_MAJOR 0x00000008 +#define D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR 0x00000010 +#define D3DCOMPILE_PARTIAL_PRECISION 0x00000020 +#define D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT 0x00000040 +#define D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT 0x00000080 +#define D3DCOMPILE_NO_PRESHADER 0x00000100 +#define D3DCOMPILE_AVOID_FLOW_CONTROL 0x00000200 +#define D3DCOMPILE_PREFER_FLOW_CONTROL 0x00000400 +#define D3DCOMPILE_ENABLE_STRICTNESS 0x00000800 +#define D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY 0x00001000 +#define D3DCOMPILE_IEEE_STRICTNESS 0x00002000 +#define D3DCOMPILE_OPTIMIZATION_LEVEL0 0x00004000 +#define D3DCOMPILE_OPTIMIZATION_LEVEL1 0x00000000 +#define D3DCOMPILE_OPTIMIZATION_LEVEL2 0x0000c000 +#define D3DCOMPILE_OPTIMIZATION_LEVEL3 0x00008000 +#define D3DCOMPILE_RESERVED16 0x00010000 +#define D3DCOMPILE_RESERVED17 0x00020000 +#define D3DCOMPILE_WARNINGS_ARE_ERRORS 0x00040000 +#define D3DCOMPILE_RESOURCES_MAY_ALIAS 0x00080000 +#define D3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES 0x00100000 +#define D3DCOMPILE_ALL_RESOURCES_BOUND 0x00200000 +#define D3DCOMPILE_DEBUG_NAME_FOR_SOURCE 0x00400000 +#define D3DCOMPILE_DEBUG_NAME_FOR_BINARY 0x00800000 + +#define D3DCOMPILE_EFFECT_CHILD_EFFECT 0x00000001 +#define D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS 0x00000002 + +#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST 0x00000000 +#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_0 0x00000010 +#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_1 0x00000020 + +#define D3D_DISASM_ENABLE_COLOR_CODE 0x00000001 +#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS 0x00000002 +#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING 0x00000004 +#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE 0x00000008 +#define D3D_DISASM_DISABLE_DEBUG_INFO 0x00000010 +#define D3D_DISASM_ENABLE_INSTRUCTION_OFFSET 0x00000020 +#define D3D_DISASM_INSTRUCTION_ONLY 0x00000040 +#define D3D_DISASM_PRINT_HEX_LITERALS 0x00000080 + +#define D3D_COMPILE_STANDARD_FILE_INCLUDE ((ID3DInclude *)(UINT_PTR)1) + +HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, + const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages); +typedef HRESULT (WINAPI *pD3DCompile)(const void *data, SIZE_T data_size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, + const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages); +HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, + const char *target, UINT sflags, UINT eflags, UINT secondary_flags, + const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader, + ID3DBlob **error_messages); + +typedef enum D3DCOMPILER_STRIP_FLAGS +{ + D3DCOMPILER_STRIP_REFLECTION_DATA = 0x1, + D3DCOMPILER_STRIP_DEBUG_INFO = 0x2, + D3DCOMPILER_STRIP_TEST_BLOBS = 0x4, + D3DCOMPILER_STRIP_PRIVATE_DATA = 0x8, + D3DCOMPILER_STRIP_ROOT_SIGNATURE = 0x10, + D3DCOMPILER_STRIP_FORCE_DWORD = 0x7fffffff +} D3DCOMPILER_STRIP_FLAGS; + +HRESULT WINAPI D3DStripShader(const void *data, SIZE_T data_size, UINT flags, ID3DBlob **blob); + +typedef enum D3D_BLOB_PART +{ + D3D_BLOB_INPUT_SIGNATURE_BLOB, + D3D_BLOB_OUTPUT_SIGNATURE_BLOB, + D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB, + D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB, + D3D_BLOB_ALL_SIGNATURE_BLOB, + D3D_BLOB_DEBUG_INFO, + D3D_BLOB_LEGACY_SHADER, + D3D_BLOB_XNA_PREPASS_SHADER, + D3D_BLOB_XNA_SHADER, + D3D_BLOB_PDB, + D3D_BLOB_PRIVATE_DATA, + D3D_BLOB_ROOT_SIGNATURE, + D3D_BLOB_DEBUG_NAME, + D3D_BLOB_TEST_ALTERNATE_SHADER = 0x8000, + D3D_BLOB_TEST_COMPILE_DETAILS, + D3D_BLOB_TEST_COMPILE_PERF, + D3D_BLOB_TEST_COMPILE_REPORT +} D3D_BLOB_PART; + +HRESULT WINAPI D3DDisassemble(const void *data, SIZE_T data_size, + UINT flags, const char *comments, ID3DBlob **disassembly); +typedef HRESULT (WINAPI *pD3DDisassemble)(const void *data, SIZE_T data_size, + UINT flags, const char *comments, ID3DBlob **disassembly); +HRESULT WINAPI D3DCompileFromFile(const WCHAR *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *includes, + const char *entrypoint, const char *target, UINT flags1, UINT flags2, ID3DBlob **code, ID3DBlob **errors); +HRESULT WINAPI D3DGetBlobPart(const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob); +HRESULT WINAPI D3DGetInputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); +HRESULT WINAPI D3DGetOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); +HRESULT WINAPI D3DGetInputAndOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); +HRESULT WINAPI D3DGetDebugInfo(const void *data, SIZE_T data_size, ID3DBlob **blob); +HRESULT WINAPI D3DReadFileToBlob(const WCHAR *filename, ID3DBlob **contents); +HRESULT WINAPI D3DWriteBlobToFile(ID3DBlob *blob, const WCHAR *filename, BOOL overwrite); +HRESULT WINAPI D3DReflect(const void *data, SIZE_T data_size, REFIID riid, void **reflector); + +HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3DBlob **blob); + +HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, + ID3DBlob **shader, ID3DBlob **error_messages); +typedef HRESULT (WINAPI *pD3DPreprocess)(const void *data, SIZE_T size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, + ID3DBlob **shader, ID3DBlob **error_messages); + +HRESULT WINAPI D3DCreateFunctionLinkingGraph(UINT flags, ID3D11FunctionLinkingGraph **graph); +HRESULT WINAPI D3DCreateLinker(ID3D11Linker **linker); +HRESULT WINAPI D3DLoadModule(const void *data, SIZE_T size, ID3D11Module **module); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dhal.h b/WineFix/lib/d2d1/include/windows/d3dhal.h new file mode 100644 index 0000000..409cbfd --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dhal.h @@ -0,0 +1,589 @@ +/* + * Direct3D driver interface + * (DirectX 7 version) + * + * Copyright (C) 2001 Ove Kaaven + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DHAL_H +#define __WINE_D3DHAL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/***************************************************************************** + * device info structures + */ +typedef struct _D3DDeviceDesc_V1 { + DWORD dwSize; + DWORD dwFlags; + D3DCOLORMODEL dcmColorModel; + DWORD dwDevCaps; + D3DTRANSFORMCAPS dtcTransformCaps; + BOOL bClipping; + D3DLIGHTINGCAPS dlcLightingCaps; + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; + DWORD dwDeviceZBufferBitDepth; + DWORD dwMaxBufferSize; + DWORD dwMaxVertexCount; +} D3DDEVICEDESC_V1,*LPD3DDEVICEDESC_V1; + +typedef struct _D3DDeviceDesc_V2 +{ + DWORD dwSize; + DWORD dwFlags; + D3DCOLORMODEL dcmColorModel; + DWORD dwDevCaps; + D3DTRANSFORMCAPS dtcTransformCaps; + BOOL bClipping; + D3DLIGHTINGCAPS dlcLightingCaps; + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; + DWORD dwDeviceZBufferBitDepth; + DWORD dwMaxBufferSize; + DWORD dwMaxVertexCount; + + /* DirectX 5 */ + DWORD dwMinTextureWidth; + DWORD dwMinTextureHeight; + DWORD dwMaxTextureWidth; + DWORD dwMaxTextureHeight; + DWORD dwMinStippleWidth; + DWORD dwMaxStippleWidth; + DWORD dwMinStippleHeight; + DWORD dwMaxStippleHeight; +} D3DDEVICEDESC_V2, *LPD3DDEVICEDESC_V2; + +typedef struct _D3DDeviceDesc_V3 +{ + DWORD dwSize; + DWORD dwFlags; + D3DCOLORMODEL dcmColorModel; + DWORD dwDevCaps; + D3DTRANSFORMCAPS dtcTransformCaps; + BOOL bClipping; + D3DLIGHTINGCAPS dlcLightingCaps; + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; + DWORD dwDeviceZBufferBitDepth; + DWORD dwMaxBufferSize; + DWORD dwMaxVertexCount; + + /* DirectX 5 */ + DWORD dwMinTextureWidth; + DWORD dwMinTextureHeight; + DWORD dwMaxTextureWidth; + DWORD dwMaxTextureHeight; + DWORD dwMinStippleWidth; + DWORD dwMaxStippleWidth; + DWORD dwMinStippleHeight; + DWORD dwMaxStippleHeight; + + /* DirectX 6 */ + DWORD dwMaxTextureRepeat; + DWORD dwMaxTextureAspectRatio; + DWORD dwMaxAnisotropy; + D3DVALUE dvGuardBandLeft; + D3DVALUE dvGuardBandTop; + D3DVALUE dvGuardBandRight; + D3DVALUE dvGuardBandBottom; + D3DVALUE dvExtentsAdjust; + DWORD dwStencilCaps; + DWORD dwFVFCaps; + DWORD dwTextureOpCaps; + WORD wMaxTextureBlendStages; + WORD wMaxSimultaneousTextures; +} D3DDEVICEDESC_V3, *LPD3DDEVICEDESC_V3; + +typedef struct _D3DHAL_GLOBALDRIVERDATA { + DWORD dwSize; + D3DDEVICEDESC_V1 hwCaps; + DWORD dwNumVertices; + DWORD dwNumClipVertices; + DWORD dwNumTextureFormats; + LPDDSURFACEDESC lpTextureFormats; +} D3DHAL_GLOBALDRIVERDATA,*LPD3DHAL_GLOBALDRIVERDATA; + +typedef struct _D3DHAL_D3DEXTENDEDCAPS { + DWORD dwSize; + /* DirectX 5 */ + DWORD dwMinTextureWidth, dwMaxTextureWidth; + DWORD dwMinTextureHeight, dwMaxTextureHeight; + DWORD dwMinStippleWidth, dwMaxStippleWidth; + DWORD dwMinStippleHeight, dwMaxStippleHeight; + /* DirectX 6 */ + DWORD dwMaxTextureRepeat; + DWORD dwMaxTextureAspectRatio; + DWORD dwMaxAnisotropy; + D3DVALUE dvGuardBandLeft; + D3DVALUE dvGuardBandTop; + D3DVALUE dvGuardBandRight; + D3DVALUE dvGuardBandBottom; + D3DVALUE dvExtentsAdjust; + DWORD dwStencilCaps; + DWORD dwFVFCaps; + DWORD dwTextureOpCaps; + WORD wMaxTextureBlendStages; + WORD wMaxSimultaneousTextures; + /* DirectX 7 */ + DWORD dwMaxActiveLights; + D3DVALUE dvMaxVertexW; + WORD wMaxUserClipPlanes; + WORD wMaxVertexBlendMatrices; + DWORD dwVertexProcessingCaps; + DWORD dwReserved1; + DWORD dwReserved2; + DWORD dwReserved3; + DWORD dwReserved4; +} D3DHAL_D3DEXTENDEDCAPS,*LPD3DHAL_D3DEXTENDEDCAPS; + +/***************************************************************************** + * d3d->driver callbacks + */ +typedef struct _D3DHAL_CONTEXTCREATEDATA *LPD3DHAL_CONTEXTCREATEDATA; +typedef struct _D3DHAL_CONTEXTDESTROYDATA *LPD3DHAL_CONTEXTDESTROYDATA; +typedef struct _D3DHAL_CONTEXTDESTROYALLDATA *LPD3DHAL_CONTEXTDESTROYALLDATA; +typedef struct _D3DHAL_SCENECAPTUREDATA *LPD3DHAL_SCENECAPTUREDATA; +typedef struct _D3DHAL_RENDERSTATEDATA *LPD3DHAL_RENDERSTATEDATA; +typedef struct _D3DHAL_RENDERPRIMITIVEDATA *LPD3DHAL_RENDERPRIMITIVEDATA; +typedef struct _D3DHAL_TEXTURECREATEDATA *LPD3DHAL_TEXTURECREATEDATA; +typedef struct _D3DHAL_TEXTUREDESTROYDATA *LPD3DHAL_TEXTUREDESTROYDATA; +typedef struct _D3DHAL_TEXTURESWAPDATA *LPD3DHAL_TEXTURESWAPDATA; +typedef struct _D3DHAL_TEXTUREGETSURFDATA *LPD3DHAL_TEXTUREGETSURFDATA; +typedef struct _D3DHAL_GETSTATEDATA *LPD3DHAL_GETSTATEDATA; + +typedef DWORD (PASCAL *LPD3DHAL_CONTEXTCREATECB) (LPD3DHAL_CONTEXTCREATEDATA); +typedef DWORD (PASCAL *LPD3DHAL_CONTEXTDESTROYCB) (LPD3DHAL_CONTEXTDESTROYDATA); +typedef DWORD (PASCAL *LPD3DHAL_CONTEXTDESTROYALLCB)(LPD3DHAL_CONTEXTDESTROYALLDATA); +typedef DWORD (PASCAL *LPD3DHAL_SCENECAPTURECB) (LPD3DHAL_SCENECAPTUREDATA); +typedef DWORD (PASCAL *LPD3DHAL_RENDERSTATECB) (LPD3DHAL_RENDERSTATEDATA); +typedef DWORD (PASCAL *LPD3DHAL_RENDERPRIMITIVECB) (LPD3DHAL_RENDERPRIMITIVEDATA); +typedef DWORD (PASCAL *LPD3DHAL_TEXTURECREATECB) (LPD3DHAL_TEXTURECREATEDATA); +typedef DWORD (PASCAL *LPD3DHAL_TEXTUREDESTROYCB) (LPD3DHAL_TEXTUREDESTROYDATA); +typedef DWORD (PASCAL *LPD3DHAL_TEXTURESWAPCB) (LPD3DHAL_TEXTURESWAPDATA); +typedef DWORD (PASCAL *LPD3DHAL_TEXTUREGETSURFCB) (LPD3DHAL_TEXTUREGETSURFDATA); +typedef DWORD (PASCAL *LPD3DHAL_GETSTATECB) (LPD3DHAL_GETSTATEDATA); + +typedef struct _D3DHAL_CALLBACKS { + DWORD dwSize; + LPD3DHAL_CONTEXTCREATECB ContextCreate; + LPD3DHAL_CONTEXTDESTROYCB ContextDestroy; + LPD3DHAL_CONTEXTDESTROYALLCB ContextDestroyAll; + LPD3DHAL_SCENECAPTURECB SceneCapture; + LPVOID lpReserved10; + LPVOID lpReserved11; + LPD3DHAL_RENDERSTATECB RenderState; + LPD3DHAL_RENDERPRIMITIVECB RenderPrimitive; + DWORD dwReserved; + LPD3DHAL_TEXTURECREATECB TextureCreate; + LPD3DHAL_TEXTUREDESTROYCB TextureDestroy; + LPD3DHAL_TEXTURESWAPCB TextureSwap; + LPD3DHAL_TEXTUREGETSURFCB TextureGetSurf; + /* now why did MS create CALLBACKS2 and CALLBACKS3 structures if + * all these reserved fields were available? we may never know */ + LPVOID lpReserved12; + LPVOID lpReserved13; + LPVOID lpReserved14; + LPVOID lpReserved15; + LPVOID lpReserved16; + LPVOID lpReserved17; + LPVOID lpReserved18; + LPVOID lpReserved19; + LPVOID lpReserved20; + LPVOID lpReserved21; + LPD3DHAL_GETSTATECB GetState; + DWORD dwReserved0; + DWORD dwReserved1; + DWORD dwReserved2; + DWORD dwReserved3; + DWORD dwReserved4; + DWORD dwReserved5; + DWORD dwReserved6; + DWORD dwReserved7; + DWORD dwReserved8; + DWORD dwReserved9; +} D3DHAL_CALLBACKS,*LPD3DHAL_CALLBACKS; + +typedef struct _D3DHAL_SETRENDERTARGETDATA *LPD3DHAL_SETRENDERTARGETDATA; +typedef struct _D3DHAL_CLEARDATA *LPD3DHAL_CLEARDATA; +typedef struct _D3DHAL_DRAWONEPRIMITIVEDATA *LPD3DHAL_DRAWONEPRIMITIVEDATA; +typedef struct _D3DHAL_DRAWONEINDEXEDPRIMITIVEDATA *LPD3DHAL_DRAWONEINDEXEDPRIMITIVEDATA; +typedef struct _D3DHAL_DRAWPRIMITIVESDATA *LPD3DHAL_DRAWPRIMITIVESDATA; + +typedef DWORD (PASCAL *LPD3DHAL_SETRENDERTARGETCB) (LPD3DHAL_SETRENDERTARGETDATA); +typedef DWORD (PASCAL *LPD3DHAL_CLEARCB) (LPD3DHAL_CLEARDATA); +typedef DWORD (PASCAL *LPD3DHAL_DRAWONEPRIMITIVECB) (LPD3DHAL_DRAWONEPRIMITIVEDATA); +typedef DWORD (PASCAL *LPD3DHAL_DRAWONEINDEXEDPRIMITIVECB)(LPD3DHAL_DRAWONEINDEXEDPRIMITIVEDATA); +typedef DWORD (PASCAL *LPD3DHAL_DRAWPRIMITIVESCB) (LPD3DHAL_DRAWPRIMITIVESDATA); + +typedef struct _D3DHAL_CALLBACKS2 { + DWORD dwSize; + DWORD dwFlags; + LPD3DHAL_SETRENDERTARGETCB SetRenderTarget; + LPD3DHAL_CLEARCB Clear; + LPD3DHAL_DRAWONEPRIMITIVECB DrawOnePrimitive; + LPD3DHAL_DRAWONEINDEXEDPRIMITIVECB DrawOneIndexedPrimitive; + LPD3DHAL_DRAWPRIMITIVESCB DrawPrimitives; +} D3DHAL_CALLBACKS2,*LPD3DHAL_CALLBACKS2; + +typedef struct _D3DHAL_CLEAR2DATA *LPD3DHAL_CLEAR2DATA; +typedef struct _D3DHAL_VALIDATETEXTURESTAGESTATEDATA *LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA; +typedef struct _D3DHAL_DRAWPRIMITIVES2DATA *LPD3DHAL_DRAWPRIMITIVES2DATA; + +typedef DWORD (PASCAL *LPD3DHAL_CLEAR2CB) (LPD3DHAL_CLEAR2DATA); +typedef DWORD (PASCAL *LPD3DHAL_VALIDATETEXTURESTAGESTATECB)(LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA); +typedef DWORD (PASCAL *LPD3DHAL_DRAWPRIMITIVES2CB) (LPD3DHAL_DRAWPRIMITIVES2DATA); + +typedef struct _D3DHAL_CALLBACKS3 { + DWORD dwSize; + DWORD dwFlags; + LPD3DHAL_CLEAR2CB Clear2; + LPVOID lpvReserved; + LPD3DHAL_VALIDATETEXTURESTAGESTATECB ValidateTextureStageState; + LPD3DHAL_DRAWPRIMITIVES2CB DrawPrimitives2; +} D3DHAL_CALLBACKS3,*LPD3DHAL_CALLBACKS3; + +/***************************************************************************** + * parameter structures + */ +typedef struct _D3DHAL_CONTEXTCREATEDATA { + union { + LPDDRAWI_DIRECTDRAW_GBL lpDDGbl; /* pre-DirectX 7 */ + LPDDRAWI_DIRECTDRAW_LCL lpDDLcl; /* DirectX 7 */ + } DUMMYUNIONNAME1; + union { + LPDIRECTDRAWSURFACE lpDDS; + LPDDRAWI_DDRAWSURFACE_LCL lpDDSLcl; /* DirectX 7 */ + } DUMMYUNIONNAME2; + union { + LPDIRECTDRAWSURFACE lpDDSZ; + LPDDRAWI_DDRAWSURFACE_LCL lpDDSZLcl; /* DirectX 7 */ + } DUMMYUNIONNAME3; + union { + DWORD dwPID; + ULONG_PTR dwrstates; + } DUMMYUNIONNAME4; + ULONG_PTR dwhContext; + HRESULT ddrval; +} D3DHAL_CONTEXTCREATEDATA; + +typedef struct _D3DHAL_CONTEXTDESTROYDATA { + ULONG_PTR dwhContext; + HRESULT ddrval; +} D3DHAL_CONTEXTDESTROYDATA; + +typedef struct _D3DHAL_CONTEXTDESTROYALLDATA { + DWORD dwPID; + HRESULT ddrval; +} D3DHAL_CONTEXTDESTROYALLDATA; + +typedef struct _D3DHAL_SCENECAPTUREDATA { + ULONG_PTR dwhContext; + DWORD dwFlag; + HRESULT ddrval; +} D3DHAL_SCENECAPTUREDATA; + +#define D3DHAL_SCENE_CAPTURE_START 0x00000000 +#define D3DHAL_SCENE_CAPTURE_END 0x00000001 + +typedef struct _D3DHAL_SETRENDERTARGETDATA { + ULONG_PTR dwhContext; + union { + LPDIRECTDRAWSURFACE lpDDS; + LPDDRAWI_DDRAWSURFACE_LCL lpDDSLcl; + } DUMMYUNIONNAME1; + union { + LPDIRECTDRAWSURFACE lpDDSZ; + LPDDRAWI_DDRAWSURFACE_LCL lpDDSZLcl; + } DUMMYUNIONNAME2; + HRESULT ddrval; +} D3DHAL_SETRENDERTARGETDATA; + +typedef struct _D3DHAL_DRAWPRIMITIVES2DATA { + ULONG_PTR dwhContext; + DWORD dwFlags; + DWORD dwVertexType; + LPDDRAWI_DDRAWSURFACE_LCL lpDDCommands; + DWORD dwCommandOffset; + DWORD dwCommandLength; + union { + LPDDRAWI_DDRAWSURFACE_LCL lpDDVertex; + LPVOID lpVertices; + } DUMMYUNIONNAME1; + DWORD dwVertexOffset; + DWORD dwVertexLength; + DWORD dwReqVertexBufSize; + DWORD dwReqCommandBufSize; + LPDWORD lpdwRStates; + union { + DWORD dwVertexSize; + HRESULT ddrval; + } DUMMYUNIONNAME2; + DWORD dwErrorOffset; +} D3DHAL_DRAWPRIMITIVES2DATA; + +#define D3DHALDP2_USERMEMVERTICES 0x00000001 +#define D3DHALDP2_EXECUTEBUFFER 0x00000002 +#define D3DHALDP2_SWAPVERTEXBUFFER 0x00000004 +#define D3DHALDP2_SWAPCOMMANDBUFFER 0x00000008 +#define D3DHALDP2_REQVERTEXBUFSIZE 0x00000010 +#define D3DHALDP2_REQCOMMANDBUFSIZE 0x00000020 +#define D3DHALDP2_VIDMEMVERTEXBUF 0x00000040 +#define D3DHALDP2_VIDMEMCOMMANDBUF 0x00000080 + +/***************************************************************************** + * DrawPrimitives2 command structures + */ +typedef struct _D3DHAL_DP2COMMAND { + BYTE bCommand; + BYTE bReserved; + union { + WORD wPrimitiveCount; + WORD wStateCount; + } DUMMYUNIONNAME; +} D3DHAL_DP2COMMAND,*LPD3DHAL_DP2COMMAND; + +typedef enum _D3DHAL_DP2OPERATION { + D3DDP2OP_POINTS = 1, + D3DDP2OP_INDEXEDLINELIST = 2, + D3DDP2OP_INDEXEDTRIANGLELIST = 3, + D3DDP2OP_RENDERSTATE = 8, + D3DDP2OP_LINELIST = 15, + D3DDP2OP_LINESTRIP = 16, + D3DDP2OP_INDEXEDLINESTRIP = 17, + D3DDP2OP_TRIANGLELIST = 18, + D3DDP2OP_TRIANGLESTRIP = 19, + D3DDP2OP_INDEXEDTRIANGLESTRIP = 20, + D3DDP2OP_TRIANGLEFAN = 21, + D3DDP2OP_INDEXEDTRIANGLEFAN = 22, + D3DDP2OP_TRIANGLEFAN_IMM = 23, + D3DDP2OP_LINELIST_IMM = 24, + D3DDP2OP_TEXTURESTAGESTATE = 25, + D3DDP2OP_INDEXEDTRIANGLELIST2 = 26, + D3DDP2OP_INDEXEDLINELIST2 = 27, + D3DDP2OP_VIEWPORTINFO = 28, + D3DDP2OP_WINFO = 29, + /* pre-DirectX 7 interfaces */ + D3DDP2OP_SETPALETTE = 30, + D3DDP2OP_UPDATEPALETTE = 31, + /* DirectX 7 interfaces */ + D3DDP2OP_ZRANGE = 32, + D3DDP2OP_SETMATERIAL = 33, + D3DDP2OP_SETLIGHT = 34, + D3DDP2OP_CREATELIGHT = 35, + D3DDP2OP_SETTRANSFORM = 36, + D3DDP2OP_TEXBLT = 38, + D3DDP2OP_STATESET = 39, + D3DDP2OP_SETPRIORITY = 40, + /* all interfaces */ + D3DDP2OP_SETRENDERTARGET = 41, + D3DDP2OP_CLEAR = 42, + /* DirectX 7 interfaces */ + D3DDP2OP_SETTEXLOD = 43, + D3DPP2OP_SETCLIPPLANE = 44 +} D3DHAL_DP2OPERATION; + +/* point primitives */ + +typedef struct _D3DHAL_POINTS { + WORD wCount; + WORD wVStart; +} D3DHAL_DP2POINTS,*LPD3DHAL_DP2POINTS; + +/* line primitives */ + +typedef struct _D3DHAL_DP2STARTVERTEX { + WORD wVStart; +} D3DHAL_DP2STARTVERTEX,*LPD3DHAL_DP2STARTVERTEX; + +typedef struct _D3DHAL_DP2LINELIST { + WORD wVStart; +} D3DHAL_DP2LINELIST,*LPD3DHAL_DP2LINELIST; + +typedef struct _D3DHAL_DP2INDEXEDLINELIST { + WORD wV1; + WORD wV2; +} D3DHAL_DP2INDEXEDLINELIST,*LPD3DHAL_DP2INDEXEDLINELIST; + +typedef struct _D3DHAL_DP2LINESTRIP { + WORD wVStart; +} D3DHAL_DP2LINESTRIP,*LPD3DHAL_DP2LINESTRIP; + +typedef struct _D3DHAL_DP2INDEXEDLINESTRIP { + WORD wV[2]; +} D3DHAL_DP2INDEXEDLINESTRIP,*LPD3DHAL_DP2INDEXEDLINESTRIP; + +/* triangle primitives */ + +typedef struct _D3DHAL_DP2TRIANGLELIST { + WORD wVStart; +} D3DHAL_DP2TRIANGLELIST,*LPD3DHAL_DP2TRIANGLELIST; + +typedef struct _D3DHAL_DP2INDEXEDTRIANGLELIST { + WORD wV1; + WORD wV2; + WORD wV3; + WORD wFlags; +} D3DHAL_DP2INDEXEDTRIANGLELIST,*LPD3DHAL_DP2INDEXEDTRIANGLELIST; + +typedef struct _D3DHAL_DP2INDEXEDTRIANGLELIST2 { + WORD wV1; + WORD wV2; + WORD wV3; +} D3DHAL_DP2INDEXEDTRIANGLELIST2,*LPD3DHAL_DP2INDEXEDTRIANGLELIST2; + +typedef struct _D3DHAL_DP2TRIANGLESTRIP { + WORD wVStart; +} D3DHAL_DP2TRIANGLESTRIP,*LPD3DHAL_DP2TRIANGLESTRIP; + +typedef struct _D3DHAL_DP2INDEXEDTRIANGLESTRIP { + WORD wV[3]; +} D3DHAL_DP2INDEXEDTRIANGLESTRIP,*LPD3DHAL_DP2INDEXEDTRIANGLESTRIP; + +typedef struct _D3DHAL_DP2TRIANGLEFAN { + WORD wVStart; +} D3DHAL_DP2TRIANGLEFAN,*LPD3DHAL_DP2TRIANGLEFAN; + +typedef struct _D3DHAL_DP2INDEXEDTRIANGLEFAN { + WORD wV[3]; +} D3DHAL_DP2INDEXEDTRIANGLEFAN,*LPD3DHAL_DP2INDEXEDTRIANGLEFAN; + +typedef struct _D3DHAL_DP2TRIANGLEFAN_IMM { + DWORD dwEdgeFlags; +} D3DHAL_DP2TRIANGLEFAN_IMM,*LPD3DHAL_DP2TRIANGLEFAN_IMM; + +/* render states */ +typedef struct _D3DHAL_DP2RENDERSTATE { + D3DRENDERSTATETYPE RenderState; + union { + D3DVALUE dvState; + DWORD dwState; + } DUMMYUNIONNAME; +} D3DHAL_DP2RENDERSTATE,*LPD3DHAL_DP2RENDERSTATE; + +typedef struct _D3DHAL_DP2TEXTURESTAGESTATE { + WORD wStage; + WORD TSState; + DWORD dwValue; +} D3DHAL_DP2TEXTURESTAGESTATE,*LPD3DHAL_DP2TEXTURESTAGESTATE; + +#define D3DTSS_TEXTUREMAP 0 + +typedef struct _D3DHAL_DP2VIEWPORTINFO { + DWORD dwX; + DWORD dwY; + DWORD dwWidth; + DWORD dwHeight; +} D3DHAL_DP2VIEWPORTINFO,*LPD3DHAL_DP2VIEWPORTINFO; + +typedef struct _D3DHAL_DP2WINFO { + D3DVALUE dwWNear; + D3DVALUE dwWFar; +} D3DHAL_DP2WINFO,*LPD3DHAL_DP2WINFO; + +typedef struct _D3DHAL_DP2SETPALETTE { + DWORD dwPaletteHandle; + DWORD dwPaletteFlags; + DWORD dwSurfaceHandle; +} D3DHAL_DP2SETPALETTE,*LPD3DHAL_DP2SETPALETTE; + +typedef struct _D3DHAL_DP2UPDATEPALETTE { + DWORD dwPaletteHandle; + WORD wStartIndex; + WORD wNumEntries; +} D3DHAL_DP2UPDATEPALETTE,*LPD3DHAL_DP2UPDATEPALETTE; + +typedef struct _D3DHAL_DP2ZRANGE { + D3DVALUE dvMinZ; + D3DVALUE dvMaxZ; +} D3DHAL_DP2ZRANGE,*LPD3DHAL_DP2ZRANGE; + +typedef D3DMATERIAL7 D3DHAL_DP2SETMATERIAL,*LPD3DHAL_DP2SETMATERIAL; + +typedef struct _D3DHAL_DP2SETLIGHT { + DWORD dwIndex; + DWORD dwDataType; +} D3DHAL_DP2SETLIGHT,*LPD3DHAL_DP2SETLIGHT; + +#define D3DHAL_SETLIGHT_ENABLE 0 +#define D3DHAL_SETLIGHT_DISABLE 1 +#define D3DHAL_SETLIGHT_DATA 2 + +typedef struct _D3DHAL_DP2CREATELIGHT { + DWORD dwIndex; +} D3DHAL_DP2CREATELIGHT,*LPD3DHAL_DP2CREATELIGHT; + +typedef struct _D3DHAL_DP2SETTRANSFORM { + D3DTRANSFORMSTATETYPE xfrmType; + D3DMATRIX matrix; +} D3DHAL_DP2SETTRANSFORM,*LPD3DHAL_DP2SETTRANSFORM; + +typedef struct _D3DHAL_DP2TEXBLT { + DWORD dwDDDestSurface; + DWORD dwDDSrcSurface; + POINT pDest; + RECTL rSrc; + DWORD dwFlags; +} D3DHAL_DP2TEXBLT,*LPD3DHAL_DP2TEXBLT; + +typedef struct _D3DHAL_DP2STATESET { + DWORD dwOperation; + DWORD dwParam; + D3DSTATEBLOCKTYPE sbType; +} D3DHAL_DP2STATESET,*LPD3DHAL_DP2STATESET; + +#define D3DHAL_STATESETBEGIN 0 +#define D3DHAL_STATESETEND 1 +#define D3DHAL_STATESETDELETE 2 +#define D3DHAL_STATESETEXECUTE 3 +#define D3DHAL_STATESETCAPTURE 4 + +typedef struct _D3DHAL_DP2SETPRIORITY { + DWORD dwDDSurface; + DWORD dwPriority; +} D3DHAL_DP2SETPRIORITY,*LPD3DHAL_DP2SETPRIORITY; + +typedef struct _D3DHAL_DP2SETRENDERTARGET { + DWORD hRenderTarget; + DWORD hZBuffer; +} D3DHAL_DP2SETRENDERTARGET,*LPD3DHAL_DP2SETRENDERTARGET; + +typedef struct _D3DHAL_DP2CLEAR { + DWORD dwFlags; + DWORD dwFillColor; + D3DVALUE dvFillDepth; + DWORD dwFillStencil; + RECT Rects[1]; +} D3DHAL_DP2CLEAR,*LPD3DHAL_DP2CLEAR; + +typedef struct _D3DHAL_DP2SETTEXLOD { + DWORD dwDDSurface; + DWORD dwLOD; +} D3DHAL_DP2SETTEXLOD,*LPD3DHAL_DP2SETTEXLOD; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* __WINE_D3DHAL_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dkmdt.h b/WineFix/lib/d2d1/include/windows/d3dkmdt.h new file mode 100644 index 0000000..9d163ec --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dkmdt.h @@ -0,0 +1,208 @@ +/* + * Copyright 2020 Brendan Shanks for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DKMDT_H +#define __WINE_D3DKMDT_H + +#define DXGK_FEATURE_SUPPORT_ALWAYS_OFF ((UINT)0) +#define DXGK_FEATURE_SUPPORT_EXPERIMENTAL ((UINT)1) +#define DXGK_FEATURE_SUPPORT_STABLE ((UINT)2) +#define DXGK_FEATURE_SUPPORT_ALWAYS_ON ((UINT)3) + +typedef enum _D3DKMDT_VIDEO_SIGNAL_STANDARD +{ + D3DKMDT_VSS_UNINITIALIZED = 0, + D3DKMDT_VSS_VESA_DMT = 1, + D3DKMDT_VSS_VESA_GTF = 2, + D3DKMDT_VSS_VESA_CVT = 3, + D3DKMDT_VSS_IBM = 4, + D3DKMDT_VSS_APPLE = 5, + D3DKMDT_VSS_NTSC_M = 6, + D3DKMDT_VSS_NTSC_J = 7, + D3DKMDT_VSS_NTSC_443 = 8, + D3DKMDT_VSS_PAL_B = 9, + D3DKMDT_VSS_PAL_B1 = 10, + D3DKMDT_VSS_PAL_G = 11, + D3DKMDT_VSS_PAL_H = 12, + D3DKMDT_VSS_PAL_I = 13, + D3DKMDT_VSS_PAL_D = 14, + D3DKMDT_VSS_PAL_N = 15, + D3DKMDT_VSS_PAL_NC = 16, + D3DKMDT_VSS_SECAM_B = 17, + D3DKMDT_VSS_SECAM_D = 18, + D3DKMDT_VSS_SECAM_G = 19, + D3DKMDT_VSS_SECAM_H = 20, + D3DKMDT_VSS_SECAM_K = 21, + D3DKMDT_VSS_SECAM_K1 = 22, + D3DKMDT_VSS_SECAM_L = 23, + D3DKMDT_VSS_SECAM_L1 = 24, + D3DKMDT_VSS_EIA_861 = 25, + D3DKMDT_VSS_EIA_861A = 26, + D3DKMDT_VSS_EIA_861B = 27, + D3DKMDT_VSS_PAL_K = 28, + D3DKMDT_VSS_PAL_K1 = 29, + D3DKMDT_VSS_PAL_L = 30, + D3DKMDT_VSS_PAL_M = 31, + D3DKMDT_VSS_OTHER = 255 +} D3DKMDT_VIDEO_SIGNAL_STANDARD; + +typedef enum _D3DKMDT_GRAPHICS_PREEMPTION_GRANULARITY +{ + D3DKMDT_GRAPHICS_PREEMPTION_NONE = 0, + D3DKMDT_GRAPHICS_PREEMPTION_DMA_BUFFER_BOUNDARY = 100, + D3DKMDT_GRAPHICS_PREEMPTION_PRIMITIVE_BOUNDARY = 200, + D3DKMDT_GRAPHICS_PREEMPTION_TRIANGLE_BOUNDARY = 300, + D3DKMDT_GRAPHICS_PREEMPTION_PIXEL_BOUNDARY = 400, + D3DKMDT_GRAPHICS_PREEMPTION_SHADER_BOUNDARY = 500, +} D3DKMDT_GRAPHICS_PREEMPTION_GRANULARITY; + +typedef enum _D3DKMDT_COMPUTE_PREEMPTION_GRANULARITY +{ + D3DKMDT_COMPUTE_PREEMPTION_NONE = 0, + D3DKMDT_COMPUTE_PREEMPTION_DMA_BUFFER_BOUNDARY = 100, + D3DKMDT_COMPUTE_PREEMPTION_DISPATCH_BOUNDARY = 200, + D3DKMDT_COMPUTE_PREEMPTION_THREAD_GROUP_BOUNDARY = 300, + D3DKMDT_COMPUTE_PREEMPTION_THREAD_BOUNDARY = 400, + D3DKMDT_COMPUTE_PREEMPTION_SHADER_BOUNDARY = 500, +} D3DKMDT_COMPUTE_PREEMPTION_GRANULARITY; + +typedef struct _D3DKMDT_PREEMPTION_CAPS +{ + D3DKMDT_GRAPHICS_PREEMPTION_GRANULARITY GraphicsPreemptionGranularity; + D3DKMDT_COMPUTE_PREEMPTION_GRANULARITY ComputePreemptionGranularity; +} D3DKMDT_PREEMPTION_CAPS; + +typedef struct _D3DKMT_WDDM_1_2_CAPS +{ + D3DKMDT_PREEMPTION_CAPS PreemptionCaps; + union + { + struct + { + UINT SupportNonVGA : 1; + UINT SupportSmoothRotation : 1; + UINT SupportPerEngineTDR : 1; + UINT SupportKernelModeCommandBuffer : 1; + UINT SupportCCD : 1; + UINT SupportSoftwareDeviceBitmaps : 1; + UINT SupportGammaRamp : 1; + UINT SupportHWCursor : 1; + UINT SupportHWVSync : 1; + UINT SupportSurpriseRemovalInHibernation : 1; + UINT Reserved : 22; + }; + UINT Value; + }; +} D3DKMT_WDDM_1_2_CAPS; + +typedef struct _D3DKMT_WDDM_1_3_CAPS +{ + union + { + struct + { + UINT SupportMiracast : 1; + UINT IsHybridIntegratedGPU : 1; + UINT IsHybridDiscreteGPU : 1; + UINT SupportPowerManagementPStates : 1; + UINT SupportVirtualModes : 1; + UINT SupportCrossAdapterResource : 1; + UINT Reserved : 26; + }; + UINT Value; + }; +} D3DKMT_WDDM_1_3_CAPS; + +typedef struct _D3DKMT_WDDM_2_0_CAPS +{ + union + { + struct + { + UINT Support64BitAtomics : 1; + UINT GpuMmuSupported : 1; + UINT IoMmuSupported : 1; + UINT FlipOverwriteSupported : 1; + UINT SupportContextlessPresent : 1; + UINT SupportSurpriseRemoval : 1; + UINT Reserved : 26; + }; + UINT Value; + }; +} D3DKMT_WDDM_2_0_CAPS; + +typedef struct _D3DKMT_WDDM_2_7_CAPS +{ + union + { + struct + { + UINT HwSchSupported : 1; + UINT HwSchEnabled : 1; + UINT HwSchEnabledByDefault : 1; + UINT IndependentVidPnVSyncControl : 1; + UINT Reserved : 28; + }; + UINT Value; + }; +} D3DKMT_WDDM_2_7_CAPS; + +typedef struct _D3DKMT_WDDM_2_9_CAPS +{ + union + { + struct + { + UINT HwSchSupportState : 2; + UINT HwSchEnabled : 1; + UINT SelfRefreshMemorySupported : 1; + UINT Reserved : 28; + }; + UINT Value; + }; +} D3DKMT_WDDM_2_9_CAPS; + +typedef struct _D3DKMT_WDDM_3_0_CAPS +{ + union + { + struct + { + UINT HwFlipQueueSupportState : 2; + UINT HwFlipQueueEnabled : 1; + UINT DisplayableSupported : 1; + UINT Reserved : 28; + }; + UINT Value; + }; +} D3DKMT_WDDM_3_0_CAPS; + +typedef struct _D3DKMT_WDDM_3_1_CAPS +{ + union + { + struct + { + UINT NativeGpuFenceSupported : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} D3DKMT_WDDM_3_1_CAPS; + +#endif /* __WINE_D3DKMDT_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3drm.h b/WineFix/lib/d2d1/include/windows/d3drm.h new file mode 100644 index 0000000..c10b9ed --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3drm.h @@ -0,0 +1,524 @@ +/* + * Copyright (C) 2005 Peter Berg Larsen + * Copyright (C) 2010 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DRM_H__ +#define __D3DRM_H__ + +#include + +typedef struct IDirect3DRM *LPDIRECT3DRM, **LPLPDIRECT3DRM; + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Direct3DRM Object CLSID */ +DEFINE_GUID(CLSID_CDirect3DRM, 0x4516ec41, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); + +/* Direct3DRM Interface GUIDs */ +DEFINE_GUID(IID_IDirect3DRM, 0x2bc49361, 0x8327, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRM2, 0x4516ecc8, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRM3, 0x4516ec83, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); + +typedef struct IDirect3DRM2 *LPDIRECT3DRM2, **LPLPDIRECT3DRM2; +typedef struct IDirect3DRM3 *LPDIRECT3DRM3, **LPLPDIRECT3DRM3; + +HRESULT WINAPI Direct3DRMCreate(struct IDirect3DRM **d3drm); + +/***************************************************************************** + * IDirect3DRMObject interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRM +DECLARE_INTERFACE_(IDirect3DRM,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRM methods ***/ + STDMETHOD(CreateObject)(THIS_ REFCLSID clsid, IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(CreateFrame)(THIS_ IDirect3DRMFrame *parent, IDirect3DRMFrame **frame) PURE; + STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE; + STDMETHOD(CreateMeshBuilder)(THIS_ IDirect3DRMMeshBuilder **mesh_builder) PURE; + STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace **face) PURE; + STDMETHOD(CreateAnimation)(THIS_ IDirect3DRMAnimation **animation) PURE; + STDMETHOD(CreateAnimationSet)(THIS_ IDirect3DRMAnimationSet **set) PURE; + STDMETHOD(CreateTexture)(THIS_ D3DRMIMAGE *image, IDirect3DRMTexture **texture) PURE; + STDMETHOD(CreateLight)(THIS_ D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light) PURE; + STDMETHOD(CreateLightRGB)(THIS_ D3DRMLIGHTTYPE type, D3DVALUE r, D3DVALUE g, D3DVALUE b, + IDirect3DRMLight **light) PURE; + STDMETHOD(CreateMaterial)(THIS_ D3DVALUE power, IDirect3DRMMaterial **material) PURE; + STDMETHOD(CreateDevice)(THIS_ DWORD width, DWORD height, IDirect3DRMDevice **device) PURE; + STDMETHOD(CreateDeviceFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw, + IDirectDrawSurface *surface, IDirect3DRMDevice **device) PURE; + STDMETHOD(CreateDeviceFromD3D)(THIS_ IDirect3D *d3d, IDirect3DDevice *d3d_device, + IDirect3DRMDevice **device) PURE; + STDMETHOD(CreateDeviceFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid, + int width, int height, IDirect3DRMDevice **device) PURE; + STDMETHOD(CreateTextureFromSurface)(THIS_ IDirectDrawSurface *surface, + IDirect3DRMTexture **texture) PURE; + STDMETHOD(CreateShadow)(THIS_ IDirect3DRMVisual *visual, IDirect3DRMLight *light, + D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, + IDirect3DRMVisual **shadow) PURE; + STDMETHOD(CreateViewport)(THIS_ IDirect3DRMDevice *device, IDirect3DRMFrame *camera, + DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport) PURE; + STDMETHOD(CreateWrap)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame *reference, D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, + D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, + D3DVALUE su, D3DVALUE sv, IDirect3DRMWrap **wrap) PURE; + STDMETHOD(CreateUserVisual)(THIS_ D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual) PURE; + STDMETHOD(LoadTexture)(THIS_ const char *filename, IDirect3DRMTexture **texture) PURE; + STDMETHOD(LoadTextureFromResource)(THIS_ HRSRC resource, IDirect3DRMTexture **texture) PURE; + STDMETHOD(SetSearchPath)(THIS_ const char *path) PURE; + STDMETHOD(AddSearchPath)(THIS_ const char *path) PURE; + STDMETHOD(GetSearchPath)(THIS_ DWORD *size, char *path) PURE; + STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE; + STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE; + STDMETHOD(GetDevices)(THIS_ IDirect3DRMDeviceArray **array) PURE; + STDMETHOD(GetNamedObject)(THIS_ const char *name, IDirect3DRMObject **object) PURE; + STDMETHOD(EnumerateObjects)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(Load)(THIS_ void *source, void *object_id, IID **iids, DWORD iid_count, D3DRMLOADOPTIONS flags, + D3DRMLOADCALLBACK load_cb, void *load_ctx, D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, + IDirect3DRMFrame *parent_frame) PURE; + STDMETHOD(Tick)(THIS_ D3DVALUE) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRM_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRM_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRM_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRM methods ***/ +#define IDirect3DRM_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,c,d) +#define IDirect3DRM_CreateFrame(p,a,b) (p)->lpVtbl->CreateFrame(p,a,b) +#define IDirect3DRM_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +#define IDirect3DRM_CreateMeshBuilder(p,a) (p)->lpVtbl->CreateMeshBuilder(p,a) +#define IDirect3DRM_CreateFace(p,a) (p)->lpVtbl->CreateFace(p,a) +#define IDirect3DRM_CreateAnimation(p,a) (p)->lpVtbl->CreateAnimation(p,a) +#define IDirect3DRM_CreateAnimationSet(p,a) (p)->lpVtbl->CreateAnimationSet(p,a) +#define IDirect3DRM_CreateTexture(p,a,b) (p)->lpVtbl->CreateTexture(p,a,b) +#define IDirect3DRM_CreateLight(p,a,b,c) (p)->lpVtbl->CreateLight(p,a,b,c) +#define IDirect3DRM_CreateLightRGB(p,a,b,c,d,e) (p)->lpVtbl->CreateLightRGB(p,a,b,c,d,e) +#define IDirect3DRM_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3DRM_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirect3DRM_CreateDeviceFromSurface(p,a,b,c,d) (p)->lpVtbl->CreateDeviceFromSurface(p,a,b,c,d) +#define IDirect3DRM_CreateDeviceFromD3D(p,a,b,c) (p)->lpVtbl->CreateDeviceFromD3D(p,a,b,c) +#define IDirect3DRM_CreateDeviceFromClipper(p,a,b,c,d,e) (p)->lpVtbl->CreateDeviceFromClipper(p,a,b,c,d,e) +#define IDirect3DRM_CreateTextureFromSurface(p,a,b) (p)->lpVtbl->CreateTextureFromSurface(p,a,b) +#define IDirect3DRM_CreateShadow(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateShadow(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DRM_CreateViewport(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateViewport(p,a,b,c,d,e,f,g) +#define IDirect3DRM_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->lpVtbl->CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) +#define IDirect3DRM_CreateUserVisual(p,a,b,c) (p)->lpVtbl->CreateUserVisual(p,a,b,c) +#define IDirect3DRM_LoadTexture(p,a,b) (p)->lpVtbl->LoadTexture(p,a,b) +#define IDirect3DRM_LoadTextureFromResource(p,a,b) (p)->lpVtbl->LoadTextureFromResource(p,a,b) +#define IDirect3DRM_SetSearchPath(p,a) (p)->lpVtbl->SetSearchPath(p,a) +#define IDirect3DRM_AddSearchPath(p,a) (p)->lpVtbl->AddSearchPath(p,a) +#define IDirect3DRM_GetSearchPath(p,a,b) (p)->lpVtbl->GetSearchPath(p,a,b) +#define IDirect3DRM_SetDefaultTextureColors(p,a) (p)->lpVtbl->SetDefaultTextureColors(p,a) +#define IDirect3DRM_SetDefaultTextureShades(p,a) (p)->lpVtbl->SetDefaultTextureShades(p,a) +#define IDirect3DRM_GetDevices(p,a) (p)->lpVtbl->GetDevices(p,a) +#define IDirect3DRM_GetNamedObject(p,a,b) (p)->lpVtbl->GetNamedObject(p,a,b) +#define IDirect3DRM_EnumerateObjects(p,a,b) (p)->lpVtbl->EnumerateObjects(p,a,b) +#define IDirect3DRM_Load(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Load(p,a,b,c,d,e,f,g,h,i,j) +#define IDirect3DRM_Tick(p,a) (p)->lpVtbl->Tick(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRM_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRM_AddRef(p) (p)->AddRef() +#define IDirect3DRM_Release(p) (p)->Release() +/*** IDirect3DRM methods ***/ +#define IDirect3DRM_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,c,d) +#define IDirect3DRM_CreateFrame(p,a,b) (p)->CreateFrame(a,b) +#define IDirect3DRM_CreateMesh(p,a) (p)->CreateMesh(a) +#define IDirect3DRM_CreateMeshBuilder(p,a) (p)->CreateMeshBuilder(a) +#define IDirect3DRM_CreateFace(p,a) (p)->CreateFace(a) +#define IDirect3DRM_CreateAnimation(p,a) (p)->CreateAnimation(a) +#define IDirect3DRM_CreateAnimationSet(p,a) (p)->CreateAnimationSet(a) +#define IDirect3DRM_CreateTexture(p,a,b) (p)->CreateTexture(a,b) +#define IDirect3DRM_CreateLight(p,a,b,c) (p)->CreateLight(a,b,c) +#define IDirect3DRM_CreateLightRGB(p,a,b,c,d,e) (p)->CreateLightRGB(a,b,c,d,e) +#define IDirect3DRM_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3DRM_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirect3DRM_CreateDeviceFromSurface(p,a,b,c,d) (p)->CreateDeviceFromSurface(a,b,c,d) +#define IDirect3DRM_CreateDeviceFromD3D(p,a,b,c) (p)->CreateDeviceFromD3D(a,b,c) +#define IDirect3DRM_CreateDeviceFromClipper(p,a,b,c,d,e) (p)->CreateDeviceFromClipper(a,b,c,d,e) +#define IDirect3DRM_CreateTextureFromSurface(p,a,b) (p)->CreateTextureFromSurface(a,b) +#define IDirect3DRM_CreateShadow(p,a,b,c,d,e,f,g,h,i) (p)->CreateShadow(a,b,c,d,e,f,g,h,i) +#define IDirect3DRM_CreateViewport(p,a,b,c,d,e,f,g) (p)->CreateViewport(a,b,c,d,e,f,g) +#define IDirect3DRM_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->CreateWrap(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) +#define IDirect3DRM_CreateUserVisual(p,a,b,c) (p)->CreateUserVisual(a,b,c) +#define IDirect3DRM_LoadTexture(p,a,b) (p)->LoadTexture(a,b) +#define IDirect3DRM_LoadTextureFromResource(p,a,b) (p)->LoadTextureFromResource(a,b) +#define IDirect3DRM_SetSearchPath(p,a) (p)->SetSearchPath(a) +#define IDirect3DRM_AddSearchPath(p,a) (p)->AddSearchPath(a) +#define IDirect3DRM_GetSearchPath(p,a,b) (p)->GetSearchPath(a,b) +#define IDirect3DRM_SetDefaultTextureColors(p,a) (p)->SetDefaultTextureColors(a) +#define IDirect3DRM_SetDefaultTextureShades(p,a) (p)->SetDefaultTextureShades(a) +#define IDirect3DRM_GetDevices(p,a) (p)->GetDevices(a) +#define IDirect3DRM_GetNamedObject(p,a,b) (p)->GetNamedObject(a,b) +#define IDirect3DRM_EnumerateObjects(p,a,b) (p)->EnumerateObjects(a,b) +#define IDirect3DRM_Load(p,a,b,c,d,e,f,g,h,i,j) (p)->Load(a,b,c,d,e,f,g,h,i,j) +#define IDirect3DRM_Tick(p,a) (p)->Tick(a) +#endif + +/***************************************************************************** + * IDirect3DRM2 interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRM2 +DECLARE_INTERFACE_(IDirect3DRM2,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRM2 methods ***/ + STDMETHOD(CreateObject)(THIS_ REFCLSID clsid, IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(CreateFrame)(THIS_ IDirect3DRMFrame *parent, IDirect3DRMFrame2 **frame) PURE; + STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE; + STDMETHOD(CreateMeshBuilder)(THIS_ IDirect3DRMMeshBuilder2 **mesh_builder) PURE; + STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace **face) PURE; + STDMETHOD(CreateAnimation)(THIS_ IDirect3DRMAnimation **animation) PURE; + STDMETHOD(CreateAnimationSet)(THIS_ IDirect3DRMAnimationSet **set) PURE; + STDMETHOD(CreateTexture)(THIS_ D3DRMIMAGE *image, IDirect3DRMTexture2 **texture) PURE; + STDMETHOD(CreateLight)(THIS_ D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light) PURE; + STDMETHOD(CreateLightRGB)(THIS_ D3DRMLIGHTTYPE type, D3DVALUE r, D3DVALUE g, D3DVALUE b, + IDirect3DRMLight **light) PURE; + STDMETHOD(CreateMaterial)(THIS_ D3DVALUE power, IDirect3DRMMaterial **material) PURE; + STDMETHOD(CreateDevice)(THIS_ DWORD width, DWORD height, IDirect3DRMDevice2 **device) PURE; + STDMETHOD(CreateDeviceFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw, + IDirectDrawSurface *surface, IDirect3DRMDevice2 **device) PURE; + STDMETHOD(CreateDeviceFromD3D)(THIS_ IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device, + IDirect3DRMDevice2 **device) PURE; + STDMETHOD(CreateDeviceFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid, + int width, int height, IDirect3DRMDevice2 **device) PURE; + STDMETHOD(CreateTextureFromSurface)(THIS_ IDirectDrawSurface *surface, + IDirect3DRMTexture2 **texture) PURE; + STDMETHOD(CreateShadow)(THIS_ IDirect3DRMVisual *visual, IDirect3DRMLight *light, + D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, + IDirect3DRMVisual **shadow) PURE; + STDMETHOD(CreateViewport)(THIS_ IDirect3DRMDevice *device, IDirect3DRMFrame *camera, + DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport) PURE; + STDMETHOD(CreateWrap)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame *reference, D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, + D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, + D3DVALUE su, D3DVALUE sv, IDirect3DRMWrap **wrap) PURE; + STDMETHOD(CreateUserVisual)(THIS_ D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual) PURE; + STDMETHOD(LoadTexture)(THIS_ const char *filename, IDirect3DRMTexture2 **texture) PURE; + STDMETHOD(LoadTextureFromResource)(THIS_ HMODULE module, const char *resource_name, + const char *resource_type, IDirect3DRMTexture2 **texture) PURE; + STDMETHOD(SetSearchPath)(THIS_ const char *path) PURE; + STDMETHOD(AddSearchPath)(THIS_ const char *path) PURE; + STDMETHOD(GetSearchPath)(THIS_ DWORD *size, char *path) PURE; + STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE; + STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE; + STDMETHOD(GetDevices)(THIS_ IDirect3DRMDeviceArray **array) PURE; + STDMETHOD(GetNamedObject)(THIS_ const char *name, IDirect3DRMObject **object) PURE; + STDMETHOD(EnumerateObjects)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(Load)(THIS_ void *source, void *object_id, IID **iids, DWORD iid_count, D3DRMLOADOPTIONS flags, + D3DRMLOADCALLBACK load_cb, void *load_ctx, D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, + IDirect3DRMFrame *parent_frame) PURE; + STDMETHOD(Tick)(THIS_ D3DVALUE) PURE; + STDMETHOD(CreateProgressiveMesh)(THIS_ IDirect3DRMProgressiveMesh **mesh) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRM2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRM2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRM2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRM2 methods ***/ +#define IDirect3DRM2_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,c,d) +#define IDirect3DRM2_CreateFrame(p,a,b) (p)->lpVtbl->CreateFrame(p,a,b) +#define IDirect3DRM2_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +#define IDirect3DRM2_CreateMeshBuilder(p,a) (p)->lpVtbl->CreateMeshBuilder(p,a) +#define IDirect3DRM2_CreateFace(p,a) (p)->lpVtbl->CreateFace(p,a) +#define IDirect3DRM2_CreateAnimation(p,a) (p)->lpVtbl->CreateAnimation(p,a) +#define IDirect3DRM2_CreateAnimationSet(p,a) (p)->lpVtbl->CreateAnimationSet(p,a) +#define IDirect3DRM2_CreateTexture(p,a,b) (p)->lpVtbl->CreateTexture(p,a,b) +#define IDirect3DRM2_CreateLight(p,a,b,c) (p)->lpVtbl->CreateLight(p,a,b,c) +#define IDirect3DRM2_CreateLightRGB(p,a,b,c,d,e) (p)->lpVtbl->CreateLightRGB(p,a,b,c,d,e) +#define IDirect3DRM2_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3DRM2_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirect3DRM2_CreateDeviceFromSurface(p,a,b,c,d) (p)->lpVtbl->CreateDeviceFromSurface(p,a,b,c,d) +#define IDirect3DRM2_CreateDeviceFromD3D(p,a,b,c) (p)->lpVtbl->CreateDeviceFromD3D(p,a,b,c) +#define IDirect3DRM2_CreateDeviceFromClipper(p,a,b,c,d,e) (p)->lpVtbl->CreateDeviceFromClipper(p,a,b,c,d,e) +#define IDirect3DRM2_CreateTextureFromSurface(p,a,b) (p)->lpVtbl->CreateTextureFromSurface(p,a,b) +#define IDirect3DRM2_CreateShadow(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateShadow(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DRM2_CreateViewport(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateViewport(p,a,b,c,d,e,f,g) +#define IDirect3DRM2_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->lpVtbl->CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) +#define IDirect3DRM2_CreateUserVisual(p,a,b,c) (p)->lpVtbl->CreateUserVisual(p,a,b,c) +#define IDirect3DRM2_LoadTexture(p,a,b) (p)->lpVtbl->LoadTexture(p,a,b) +#define IDirect3DRM2_LoadTextureFromResource(p,a,b,c,d) (p)->lpVtbl->LoadTextureFromResource(p,a,b,c,d) +#define IDirect3DRM2_SetSearchPath(p,a) (p)->lpVtbl->SetSearchPath(p,a) +#define IDirect3DRM2_AddSearchPath(p,a) (p)->lpVtbl->AddSearchPath(p,a) +#define IDirect3DRM2_GetSearchPath(p,a,b) (p)->lpVtbl->GetSearchPath(p,a,b) +#define IDirect3DRM2_SetDefaultTextureColors(p,a) (p)->lpVtbl->SetDefaultTextureColors(p,a) +#define IDirect3DRM2_SetDefaultTextureShades(p,a) (p)->lpVtbl->SetDefaultTextureShades(p,a) +#define IDirect3DRM2_GetDevices(p,a) (p)->lpVtbl->GetDevices(p,a) +#define IDirect3DRM2_GetNamedObject(p,a,b) (p)->lpVtbl->GetNamedObject(p,a,b) +#define IDirect3DRM2_EnumerateObjects(p,a,b) (p)->lpVtbl->EnumerateObjects(p,a,b) +#define IDirect3DRM2_Load(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Load(p,a,b,c,d,e,f,g,h,i,j) +#define IDirect3DRM2_Tick(p,a) (p)->lpVtbl->Tick(p,a) +#define IDirect3DRM2_CreateProgressiveMesh(p,a) (p)->lpVtbl->CreateProgressiveMesh(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRM2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRM2_AddRef(p) (p)->AddRef() +#define IDirect3DRM2_Release(p) (p)->Release() +/*** IDirect3DRM2 methods ***/ +#define IDirect3DRM2_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,c,d) +#define IDirect3DRM2_CreateFrame(p,a,b) (p)->CreateFrame(a,b) +#define IDirect3DRM2_CreateMesh(p,a) (p)->CreateMesh(a) +#define IDirect3DRM2_CreateMeshBuilder(p,a) (p)->CreateMeshBuilder(a) +#define IDirect3DRM2_CreateFace(p,a) (p)->CreateFace(a) +#define IDirect3DRM2_CreateAnimation(p,a) (p)->CreateAnimation(a) +#define IDirect3DRM2_CreateAnimationSet(p,a) (p)->CreateAnimationSet(a) +#define IDirect3DRM2_CreateTexture(p,a,b) (p)->CreateTexture(a,b) +#define IDirect3DRM2_CreateLight(p,a,b,c) (p)->CreateLight(a,b,c) +#define IDirect3DRM2_CreateLightRGB(p,a,b,c,d,e) (p)->CreateLightRGB(a,b,c,d,e) +#define IDirect3DRM2_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3DRM2_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirect3DRM2_CreateDeviceFromSurface(p,a,b,c,d) (p)->CreateDeviceFromSurface(a,b,c,d) +#define IDirect3DRM2_CreateDeviceFromD3D(p,a,b,c) (p)->CreateDeviceFromD3D(a,b,c) +#define IDirect3DRM2_CreateDeviceFromClipper(p,a,b,c,d,e) (p)->CreateDeviceFromClipper(a,b,c,d,e) +#define IDirect3DRM2_CreateTextureFromSurface(p,a,b) (p)->CreateTextureFromSurface(a,b) +#define IDirect3DRM2_CreateShadow(p,a,b,c,d,e,f,g,h,i) (p)->CreateShadow(a,b,c,d,e,f,g,h,i) +#define IDirect3DRM2_CreateViewport(p,a,b,c,d,e,f,g) (p)->CreateViewport(a,b,c,d,e,f,g) +#define IDirect3DRM2_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->CreateWrap(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) +#define IDirect3DRM2_CreateUserVisual(p,a,b,c) (p)->CreateUserVisual(a,b,c) +#define IDirect3DRM2_LoadTexture(p,a,b) (p)->LoadTexture(a,b) +#define IDirect3DRM2_LoadTextureFromResource(p,a,b,c,d) (p)->LoadTextureFromResource(a,b,c,d) +#define IDirect3DRM2_SetSearchPath(p,a) (p)->SetSearchPath(a) +#define IDirect3DRM2_AddSearchPath(p,a) (p)->AddSearchPath(a) +#define IDirect3DRM2_GetSearchPath(p,a,b) (p)->GetSearchPath(a,b) +#define IDirect3DRM2_SetDefaultTextureColors(p,a) (p)->SetDefaultTextureColors(a) +#define IDirect3DRM2_SetDefaultTextureShades(p,a) (p)->SetDefaultTextureShades(a) +#define IDirect3DRM2_GetDevices(p,a) (p)->GetDevices(a) +#define IDirect3DRM2_GetNamedObject(p,a,b) (p)->GetNamedObject(a,b) +#define IDirect3DRM2_EnumerateObjects(p,a,b) (p)->EnumerateObjects(a,b) +#define IDirect3DRM2_Load(p,a,b,c,d,e,f,g,h,i,j) (p)->Load(a,b,c,d,e,f,g,h,i,j) +#define IDirect3DRM2_Tick(p,a) (p)->Tick(a) +#define IDirect3DRM2_CreateProgressiveMesh(p,a) (p)->CreateProgressiveMesh(a) +#endif + +/***************************************************************************** + * IDirect3DRM3 interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRM3 +DECLARE_INTERFACE_(IDirect3DRM3,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRM2 methods ***/ + STDMETHOD(CreateObject)(THIS_ REFCLSID clsid, IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(CreateFrame)(THIS_ IDirect3DRMFrame3 *parent, IDirect3DRMFrame3 **frame) PURE; + STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE; + STDMETHOD(CreateMeshBuilder)(THIS_ IDirect3DRMMeshBuilder3 **mesh_builder) PURE; + STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace2 **face) PURE; + STDMETHOD(CreateAnimation)(THIS_ IDirect3DRMAnimation2 **animation) PURE; + STDMETHOD(CreateAnimationSet)(THIS_ IDirect3DRMAnimationSet2 **set) PURE; + STDMETHOD(CreateTexture)(THIS_ D3DRMIMAGE *image, IDirect3DRMTexture3 **texture) PURE; + STDMETHOD(CreateLight)(THIS_ D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light) PURE; + STDMETHOD(CreateLightRGB)(THIS_ D3DRMLIGHTTYPE type, D3DVALUE r, D3DVALUE g, D3DVALUE b, + IDirect3DRMLight **light) PURE; + STDMETHOD(CreateMaterial)(THIS_ D3DVALUE, IDirect3DRMMaterial2 **material) PURE; + STDMETHOD(CreateDevice)(THIS_ DWORD width, DWORD height, IDirect3DRMDevice3 **device) PURE; + STDMETHOD(CreateDeviceFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw, + IDirectDrawSurface *surface, DWORD flags, IDirect3DRMDevice3 **device) PURE; + STDMETHOD(CreateDeviceFromD3D)(THIS_ IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device, + IDirect3DRMDevice3 **device) PURE; + STDMETHOD(CreateDeviceFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid, + int width, int height, IDirect3DRMDevice3 **device) PURE; + STDMETHOD(CreateTextureFromSurface)(THIS_ IDirectDrawSurface *surface, + IDirect3DRMTexture3 **texture) PURE; + STDMETHOD(CreateShadow)(THIS_ IUnknown *object, IDirect3DRMLight *light, D3DVALUE px, D3DVALUE py, D3DVALUE pz, + D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, IDirect3DRMShadow2 **shadow) PURE; + STDMETHOD(CreateViewport)(THIS_ IDirect3DRMDevice3 *device, IDirect3DRMFrame3 *camera, + DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport2 **viewport) PURE; + STDMETHOD(CreateWrap)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame3 *reference, + D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, + D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv, + IDirect3DRMWrap **wrap) PURE; + STDMETHOD(CreateUserVisual)(THIS_ D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual) PURE; + STDMETHOD(LoadTexture)(THIS_ const char *filename, IDirect3DRMTexture3 **texture) PURE; + STDMETHOD(LoadTextureFromResource)(THIS_ HMODULE module, const char *resource_name, + const char *resource_type, IDirect3DRMTexture3 **texture) PURE; + STDMETHOD(SetSearchPath)(THIS_ const char *path) PURE; + STDMETHOD(AddSearchPath)(THIS_ const char *path) PURE; + STDMETHOD(GetSearchPath)(THIS_ DWORD *size, char *path) PURE; + STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE; + STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE; + STDMETHOD(GetDevices)(THIS_ IDirect3DRMDeviceArray **array) PURE; + STDMETHOD(GetNamedObject)(THIS_ const char *name, IDirect3DRMObject **object) PURE; + STDMETHOD(EnumerateObjects)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(Load)(THIS_ void *source, void *object_id, IID **iids, DWORD iid_count, D3DRMLOADOPTIONS flags, + D3DRMLOADCALLBACK load_cb, void *load_ctx, D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, + IDirect3DRMFrame3 *parent_frame) PURE; + STDMETHOD(Tick)(THIS_ D3DVALUE) PURE; + STDMETHOD(CreateProgressiveMesh)(THIS_ IDirect3DRMProgressiveMesh **mesh) PURE; + STDMETHOD(RegisterClient)(THIS_ REFGUID guid, DWORD *id) PURE; + STDMETHOD(UnregisterClient)(THIS_ REFGUID rguid) PURE; + STDMETHOD(CreateClippedVisual)(THIS_ IDirect3DRMVisual *visual, IDirect3DRMClippedVisual **clipped_visual) PURE; + STDMETHOD(SetOptions)(THIS_ DWORD) PURE; + STDMETHOD(GetOptions)(THIS_ DWORD *flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRM3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRM3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRM3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRM3 methods ***/ +#define IDirect3DRM3_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,c,d) +#define IDirect3DRM3_CreateFrame(p,a,b) (p)->lpVtbl->CreateFrame(p,a,b) +#define IDirect3DRM3_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +#define IDirect3DRM3_CreateMeshBuilder(p,a) (p)->lpVtbl->CreateMeshBuilder(p,a) +#define IDirect3DRM3_CreateFace(p,a) (p)->lpVtbl->CreateFace(p,a) +#define IDirect3DRM3_CreateAnimation(p,a) (p)->lpVtbl->CreateAnimation(p,a) +#define IDirect3DRM3_CreateAnimationSet(p,a) (p)->lpVtbl->CreateAnimationSet(p,a) +#define IDirect3DRM3_CreateTexture(p,a,b) (p)->lpVtbl->CreateTexture(p,a,b) +#define IDirect3DRM3_CreateLight(p,a,b,c) (p)->lpVtbl->CreateLight(p,a,b,c) +#define IDirect3DRM3_CreateLightRGB(p,a,b,c,d,e) (p)->lpVtbl->CreateLightRGB(p,a,b,c,d,e) +#define IDirect3DRM3_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3DRM3_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirect3DRM3_CreateDeviceFromSurface(p,a,b,c,d,e) (p)->lpVtbl->CreateDeviceFromSurface(p,a,b,c,d,e) +#define IDirect3DRM3_CreateDeviceFromD3D(p,a,b,c) (p)->lpVtbl->CreateDeviceFromD3D(p,a,b,c) +#define IDirect3DRM3_CreateDeviceFromClipper(p,a,b,c,d,e) (p)->lpVtbl->CreateDeviceFromClipper(p,a,b,c,d,e) +#define IDirect3DRM3_CreateTextureFromSurface(p,a,b) (p)->lpVtbl->CreateTextureFromSurface(p,a,b) +#define IDirect3DRM3_CreateShadow(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->CreateShadow(p,a,b,c,d,e,f,g,h,i) +#define IDirect3DRM3_CreateViewport(p,a,b,c,d,e,f,g) (p)->lpVtbl->CreateViewport(p,a,b,c,d,e,f,g) +#define IDirect3DRM3_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->lpVtbl->CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) +#define IDirect3DRM3_CreateUserVisual(p,a,b,c) (p)->lpVtbl->CreateUserVisual(p,a,b,c) +#define IDirect3DRM3_LoadTexture(p,a,b) (p)->lpVtbl->LoadTexture(p,a,b) +#define IDirect3DRM3_LoadTextureFromResource(p,a,b,c,d) (p)->lpVtbl->LoadTextureFromResource(p,a,b,c,d) +#define IDirect3DRM3_SetSearchPath(p,a) (p)->lpVtbl->SetSearchPath(p,a) +#define IDirect3DRM3_AddSearchPath(p,a) (p)->lpVtbl->AddSearchPath(p,a) +#define IDirect3DRM3_GetSearchPath(p,a,b) (p)->lpVtbl->GetSearchPath(p,a,b) +#define IDirect3DRM3_SetDefaultTextureColors(p,a) (p)->lpVtbl->SetDefaultTextureColors(p,a) +#define IDirect3DRM3_SetDefaultTextureShades(p,a) (p)->lpVtbl->SetDefaultTextureShades(p,a) +#define IDirect3DRM3_GetDevices(p,a) (p)->lpVtbl->GetDevices(p,a) +#define IDirect3DRM3_GetNamedObject(p,a,b) (p)->lpVtbl->GetNamedObject(p,a,b) +#define IDirect3DRM3_EnumerateObjects(p,a,b) (p)->lpVtbl->EnumerateObjects(p,a,b) +#define IDirect3DRM3_Load(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Load(p,a,b,c,d,e,f,g,h,i,j) +#define IDirect3DRM3_Tick(p,a) (p)->lpVtbl->Tick(p,a) +#define IDirect3DRM3_CreateProgressiveMesh(p,a) (p)->lpVtbl->CreateProgressiveMesh(p,a) +#define IDirect3DRM3_RegisterClient(p,a,b) (p)->lpVtbl->RegisterClient(p,a,b) +#define IDirect3DRM3_UnregisterClient(p,a) (p)->lpVtbl->UnregisterClient(p,a) +#define IDirect3DRM3_CreateClippedVisual(p,a,b) (p)->lpVtbl->CreateClippedVisual(p,a,b) +#define IDirect3DRM3_SetOptions(p,a) (p)->lpVtbl->SetOptions(p,a) +#define IDirect3DRM3_GetOptions(p,a) (p)->lpVtbl->GetOptions(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRM3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRM3_AddRef(p) (p)->AddRef() +#define IDirect3DRM3_Release(p) (p)->Release() +/*** IDirect3DRM3 methods ***/ +#define IDirect3DRM3_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,c,d) +#define IDirect3DRM3_CreateFrame(p,a,b) (p)->CreateFrame(a,b) +#define IDirect3DRM3_CreateMesh(p,a) (p)->CreateMesh(a) +#define IDirect3DRM3_CreateMeshBuilder(p,a) (p)->CreateMeshBuilder(a) +#define IDirect3DRM3_CreateFace(p,a) (p)->CreateFace(a) +#define IDirect3DRM3_CreateAnimation(p,a) (p)->CreateAnimation(a) +#define IDirect3DRM3_CreateAnimationSet(p,a) (p)->CreateAnimationSet(a) +#define IDirect3DRM3_CreateTexture(p,a,b) (p)->CreateTexture(a,b) +#define IDirect3DRM3_CreateLight(p,a,b,c) (p)->CreateLight(a,b,c) +#define IDirect3DRM3_CreateLightRGB(p,a,b,c,d,e) (p)->CreateLightRGB(a,b,c,d,e) +#define IDirect3DRM3_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3DRM3_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirect3DRM3_CreateDeviceFromSurface(p,a,b,c,d,e) (p)->CreateDeviceFromSurface(a,b,c,d,e) +#define IDirect3DRM3_CreateDeviceFromD3D(p,a,b,c) (p)->CreateDeviceFromD3D(a,b,c) +#define IDirect3DRM3_CreateDeviceFromClipper(p,a,b,c,d,e) (p)->CreateDeviceFromClipper(a,b,c,d,e) +#define IDirect3DRM3_CreateTextureFromSurface(p,a,b) (p)->CreateTextureFromSurface(a,b) +#define IDirect3DRM3_CreateShadow(p,a,b,c,d,e,f,g,h,i) (p)->CreateShadow(a,b,c,d,e,f,g,h,i) +#define IDirect3DRM3_CreateViewport(p,a,b,c,d,e,f,g) (p)->CreateViewport(a,b,c,d,e,f,g) +#define IDirect3DRM3_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->CreateWrap(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) +#define IDirect3DRM3_CreateUserVisual(p,a,b,c) (p)->CreateUserVisual(a,b,c) +#define IDirect3DRM3_LoadTexture(p,a,b) (p)->LoadTexture(a,b) +#define IDirect3DRM3_LoadTextureFromResource(p,a,b,c,d) (p)->LoadTextureFromResource(a,b,c,d) +#define IDirect3DRM3_SetSearchPath(p,a) (p)->SetSearchPath(a) +#define IDirect3DRM3_AddSearchPath(p,a) (p)->AddSearchPath(a) +#define IDirect3DRM3_GetSearchPath(p,a,b) (p)->GetSearchPath(a,b) +#define IDirect3DRM3_SetDefaultTextureColors(p,a) (p)->SetDefaultTextureColors(a) +#define IDirect3DRM3_SetDefaultTextureShades(p,a) (p)->SetDefaultTextureShades(a) +#define IDirect3DRM3_GetDevices(p,a) (p)->GetDevices(a) +#define IDirect3DRM3_GetNamedObject(p,a,b) (p)->GetNamedObject(a,b) +#define IDirect3DRM3_EnumerateObjects(p,a,b) (p)->EnumerateObjects(a,b) +#define IDirect3DRM3_Load(p,a,b,c,d,e,f,g,h,i,j) (p)->Load(a,b,c,d,e,f,g,h,i,j) +#define IDirect3DRM3_Tick(p,a) (p)->Tick(a) +#define IDirect3DRM3_CreateProgressiveMesh(p,a) (p)->CreateProgressiveMesh(a) +#define IDirect3DRM3_RegisterClient(p,a,b) (p)->RegisterClient(a,b) +#define IDirect3DRM3_UnregisterClient(p,a) (p)->UnregisterClient(a) +#define IDirect3DRM3_CreateClippedVisual(p,a,b) (p)->CreateClippedVisual(a,b) +#define IDirect3DRM3_SetOptions(p,a) (p)->SetOptions(a) +#define IDirect3DRM3_GetOptions(p,a) (p)->GetOptions(a) +#endif + +#define D3DRM_OK DD_OK +#define D3DRMERR_BADOBJECT MAKE_DDHRESULT(781) +#define D3DRMERR_BADTYPE MAKE_DDHRESULT(782) +#define D3DRMERR_BADALLOC MAKE_DDHRESULT(783) +#define D3DRMERR_FACEUSED MAKE_DDHRESULT(784) +#define D3DRMERR_NOTFOUND MAKE_DDHRESULT(785) +#define D3DRMERR_NOTDONEYET MAKE_DDHRESULT(786) +#define D3DRMERR_FILENOTFOUND MAKE_DDHRESULT(787) +#define D3DRMERR_BADFILE MAKE_DDHRESULT(788) +#define D3DRMERR_BADDEVICE MAKE_DDHRESULT(789) +#define D3DRMERR_BADVALUE MAKE_DDHRESULT(790) +#define D3DRMERR_BADMAJORVERSION MAKE_DDHRESULT(791) +#define D3DRMERR_BADMINORVERSION MAKE_DDHRESULT(792) +#define D3DRMERR_UNABLETOEXECUTE MAKE_DDHRESULT(793) +#define D3DRMERR_LIBRARYNOTFOUND MAKE_DDHRESULT(794) +#define D3DRMERR_INVALIDLIBRARY MAKE_DDHRESULT(795) +#define D3DRMERR_PENDING MAKE_DDHRESULT(796) +#define D3DRMERR_NOTENOUGHDATA MAKE_DDHRESULT(797) +#define D3DRMERR_REQUESTTOOLARGE MAKE_DDHRESULT(798) +#define D3DRMERR_REQUESTTOOSMALL MAKE_DDHRESULT(799) +#define D3DRMERR_CONNECTIONLOST MAKE_DDHRESULT(800) +#define D3DRMERR_LOADABORTED MAKE_DDHRESULT(801) +#define D3DRMERR_NOINTERNET MAKE_DDHRESULT(802) +#define D3DRMERR_BADCACHEFILE MAKE_DDHRESULT(803) +#define D3DRMERR_BOXNOTSET MAKE_DDHRESULT(804) +#define D3DRMERR_BADPMDATA MAKE_DDHRESULT(805) +#define D3DRMERR_CLIENTNOTREGISTERED MAKE_DDHRESULT(806) +#define D3DRMERR_NOTCREATEDFROMDDS MAKE_DDHRESULT(807) +#define D3DRMERR_NOSUCHKEY MAKE_DDHRESULT(808) +#define D3DRMERR_INCOMPATABLEKEY MAKE_DDHRESULT(809) +#define D3DRMERR_ELEMENTINUSE MAKE_DDHRESULT(810) +#define D3DRMERR_TEXTUREFORMATNOTFOUND MAKE_DDHRESULT(811) +#define D3DRMERR_NOTAGGREGATED MAKE_DDHRESULT(812) + +#ifdef __cplusplus +} +#endif + +#endif /* __D3DRM_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3drmdef.h b/WineFix/lib/d2d1/include/windows/d3drmdef.h new file mode 100644 index 0000000..aa77c2c --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3drmdef.h @@ -0,0 +1,466 @@ +/* + * Copyright 2007,2010 Vijay Kiran Kamuju + * Copyright 2007 David ADAM + * Copyright 2010 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DRMDEFS_H__ +#define __D3DRMDEFS_H__ + +#include +#include + +#if defined(__cplusplus) +extern "C" { +#endif + +typedef struct _D3DRMVECTOR4D +{ + D3DVALUE x; + D3DVALUE y; + D3DVALUE z; + D3DVALUE w; +} D3DRMVECTOR4D, *LPD3DRMVECTOR4D; + +typedef D3DVALUE D3DRMMATRIX4D[4][4]; + +typedef struct _D3DRMQUATERNION { + D3DVALUE s; + D3DVECTOR v; +} D3DRMQUATERNION, *LPD3DRMQUATERNION; + +typedef struct _D3DRMRAY { + D3DVECTOR dvDir; + D3DVECTOR dvPos; +} D3DRMRAY, *LPD3DRMRAY; + +typedef struct _D3DRMBOX { + D3DVECTOR min; + D3DVECTOR max; +} D3DRMBOX, *LPD3DRMBOX; + +typedef void (*D3DRMWRAPCALLBACK)(D3DVECTOR *vec, int *u, int *v, D3DVECTOR *a, D3DVECTOR *b, void *ctx); + +typedef enum _D3DRMLIGHTTYPE { + D3DRMLIGHT_AMBIENT, + D3DRMLIGHT_POINT, + D3DRMLIGHT_SPOT, + D3DRMLIGHT_DIRECTIONAL, + D3DRMLIGHT_PARALLELPOINT +} D3DRMLIGHTTYPE, *LPD3DRMLIGHTTYPE; + +typedef enum _D3DRMSHADEMODE { + D3DRMSHADE_FLAT = 0, + D3DRMSHADE_GOURAUD = 1, + D3DRMSHADE_PHONG = 2, + D3DRMSHADE_MASK = 7, + D3DRMSHADE_MAX = 8 +} D3DRMSHADEMODE, *LPD3DRMSHADEMODE; + +typedef enum _D3DRMLIGHTMODE { + D3DRMLIGHT_OFF = 0 * D3DRMSHADE_MAX, + D3DRMLIGHT_ON = 1 * D3DRMSHADE_MAX, + D3DRMLIGHT_MASK = 7 * D3DRMSHADE_MAX, + D3DRMLIGHT_MAX = 8 * D3DRMSHADE_MAX +} D3DRMLIGHTMODE, *LPD3DRMLIGHTMODE; + +typedef enum _D3DRMFILLMODE { + D3DRMFILL_POINTS = 0 * D3DRMLIGHT_MAX, + D3DRMFILL_WIREFRAME = 1 * D3DRMLIGHT_MAX, + D3DRMFILL_SOLID = 2 * D3DRMLIGHT_MAX, + D3DRMFILL_MASK = 7 * D3DRMLIGHT_MAX, + D3DRMFILL_MAX = 8 * D3DRMLIGHT_MAX +} D3DRMFILLMODE, *LPD3DRMFILLMODE; + +typedef DWORD D3DRMRENDERQUALITY, *LPD3DRMRENDERQUALITY; + +#define D3DRMRENDER_WIREFRAME (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_WIREFRAME) +#define D3DRMRENDER_UNLITFLAT (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_SOLID) +#define D3DRMRENDER_FLAT (D3DRMSHADE_FLAT+D3DRMLIGHT_ON+D3DRMFILL_SOLID) +#define D3DRMRENDER_GOURAUD (D3DRMSHADE_GOURAUD+D3DRMLIGHT_ON+D3DRMFILL_SOLID) +#define D3DRMRENDER_PHONG (D3DRMSHADE_PHONG+D3DRMLIGHT_ON+D3DRMFILL_SOLID) + +#define D3DRMRENDERMODE_BLENDEDTRANSPARENCY 1 +#define D3DRMRENDERMODE_SORTEDTRANSPARENCY 2 +#define D3DRMRENDERMODE_LIGHTINMODELSPACE 8 +#define D3DRMRENDERMODE_VIEWDEPENDENTSPECULAR 16 +#define D3DRMRENDERMODE_DISABLESORTEDALPHAZWRITE 32 + +typedef enum _D3DRMTEXTUREQUALITY { + D3DRMTEXTURE_NEAREST, + D3DRMTEXTURE_LINEAR, + D3DRMTEXTURE_MIPNEAREST, + D3DRMTEXTURE_MIPLINEAR, + D3DRMTEXTURE_LINEARMIPNEAREST, + D3DRMTEXTURE_LINEARMIPLINEAR +} D3DRMTEXTUREQUALITY, *LPD3DRMTEXTUREQUALITY; + +#define D3DRMTEXTURE_FORCERESIDENT 0x00000001 +#define D3DRMTEXTURE_STATIC 0x00000002 +#define D3DRMTEXTURE_DOWNSAMPLEPOINT 0x00000004 +#define D3DRMTEXTURE_DOWNSAMPLEBILINEAR 0x00000008 +#define D3DRMTEXTURE_DOWNSAMPLEREDUCEDEPTH 0x00000010 +#define D3DRMTEXTURE_DOWNSAMPLENONE 0x00000020 +#define D3DRMTEXTURE_CHANGEDPIXELS 0x00000040 +#define D3DRMTEXTURE_CHANGEDPALETTE 0x00000080 +#define D3DRMTEXTURE_INVALIDATEONLY 0x00000100 + +#define D3DRMSHADOW_TRUEALPHA 0x00000001 + +typedef enum _D3DRMCOMBINETYPE { + D3DRMCOMBINE_REPLACE, + D3DRMCOMBINE_BEFORE, + D3DRMCOMBINE_AFTER +} D3DRMCOMBINETYPE, *LPD3DRMCOMBINETYPE; + +typedef D3DCOLORMODEL D3DRMCOLORMODEL, *LPD3DRMCOLORMODEL; + +typedef enum _D3DRMPALETTEFLAGS +{ + D3DRMPALETTE_FREE, + D3DRMPALETTE_READONLY, + D3DRMPALETTE_RESERVED +} D3DRMPALETTEFLAGS, *LPD3DRMPALETTEFLAGS; + +typedef struct _D3DRMPALETTEENTRY { + unsigned char red; + unsigned char green; + unsigned char blue; + unsigned char flags; +} D3DRMPALETTEENTRY, *LPD3DRMPALETTEENTRY; + +typedef struct _D3DRMIMAGE { + int width; + int height; + int aspectx; + int aspecty; + int depth; + int rgb; + int bytes_per_line; + void* buffer1; + void* buffer2; + ULONG red_mask; + ULONG green_mask; + ULONG blue_mask; + ULONG alpha_mask; + int palette_size; + D3DRMPALETTEENTRY* palette; +} D3DRMIMAGE, *LPD3DRMIMAGE; + +typedef enum _D3DRMWRAPTYPE { + D3DRMWRAP_FLAT, + D3DRMWRAP_CYLINDER, + D3DRMWRAP_SPHERE, + D3DRMWRAP_CHROME, + D3DRMWRAP_SHEET, + D3DRMWRAP_BOX +} D3DRMWRAPTYPE, *LPD3DRMWRAPTYPE; + +#define D3DRMWIREFRAME_CULL 1 +#define D3DRMWIREFRAME_HIDDENLINE 2 + +typedef enum _D3DRMPROJECTIONTYPE +{ + D3DRMPROJECT_PERSPECTIVE, + D3DRMPROJECT_ORTHOGRAPHIC, + D3DRMPROJECT_RIGHTHANDPERSPECTIVE, + D3DRMPROJECT_RIGHTHANDORTHOGRAPHIC +} D3DRMPROJECTIONTYPE, *LPD3DRMPROJECTIONTYPE; + +#define D3DRMOPTIONS_LEFTHANDED 0x00000001 +#define D3DRMOPTIONS_RIGHTHANDED 0x00000002 + +typedef enum _D3DRMXOFFORMAT { + D3DRMXOF_BINARY, + D3DRMXOF_COMPRESSED, + D3DRMXOF_TEXT +} D3DRMXOFFORMAT, *LPD3DRMXOFFORMAT; + +typedef DWORD D3DRMSAVEOPTIONS; +#define D3DRMXOFSAVE_NORMALS 1 +#define D3DRMXOFSAVE_TEXTURECOORDINATES 2 +#define D3DRMXOFSAVE_MATERIALS 4 +#define D3DRMXOFSAVE_TEXTURENAMES 8 +#define D3DRMXOFSAVE_ALL 15 +#define D3DRMXOFSAVE_TEMPLATES 16 +#define D3DRMXOFSAVE_TEXTURETOPOLOGY 32 + +typedef enum _D3DRMCOLORSOURCE { + D3DRMCOLOR_FROMFACE, + D3DRMCOLOR_FROMVERTEX +} D3DRMCOLORSOURCE, *LPD3DRMCOLORSOURCE; + +typedef enum _D3DRMFRAMECONSTRAINT { + D3DRMCONSTRAIN_Z, + D3DRMCONSTRAIN_Y, + D3DRMCONSTRAIN_X +} D3DRMFRAMECONSTRAINT, *LPD3DRMFRAMECONSTRAINT; + +typedef enum _D3DRMMATERIALMODE { + D3DRMMATERIAL_FROMMESH, + D3DRMMATERIAL_FROMPARENT, + D3DRMMATERIAL_FROMFRAME +} D3DRMMATERIALMODE, *LPD3DRMMATERIALMODE; + +typedef enum _D3DRMFOGMODE { + D3DRMFOG_LINEAR, + D3DRMFOG_EXPONENTIAL, + D3DRMFOG_EXPONENTIALSQUARED +} D3DRMFOGMODE, *LPD3DRMFOGMODE; + +typedef enum _D3DRMZBUFFERMODE { + D3DRMZBUFFER_FROMPARENT, + D3DRMZBUFFER_ENABLE, + D3DRMZBUFFER_DISABLE +} D3DRMZBUFFERMODE, *LPD3DRMZBUFFERMODE; + +typedef enum _D3DRMSORTMODE { + D3DRMSORT_FROMPARENT, + D3DRMSORT_NONE, + D3DRMSORT_FRONTTOBACK, + D3DRMSORT_BACKTOFRONT +} D3DRMSORTMODE, *LPD3DRMSORTMODE; + +typedef struct _D3DRMMATERIALOVERRIDE { + DWORD dwSize; + DWORD dwFlags; + D3DCOLORVALUE dcDiffuse; + D3DCOLORVALUE dcAmbient; + D3DCOLORVALUE dcEmissive; + D3DCOLORVALUE dcSpecular; + D3DVALUE dvPower; + IUnknown *lpD3DRMTex; +} D3DRMMATERIALOVERRIDE, *LPD3DRMMATERIALOVERRIDE; + +#define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAONLY 0x00000001 +#define D3DRMMATERIALOVERRIDE_DIFFUSE_RGBONLY 0x00000002 +#define D3DRMMATERIALOVERRIDE_DIFFUSE 0x00000003 +#define D3DRMMATERIALOVERRIDE_AMBIENT 0x00000004 +#define D3DRMMATERIALOVERRIDE_EMISSIVE 0x00000008 +#define D3DRMMATERIALOVERRIDE_SPECULAR 0x00000010 +#define D3DRMMATERIALOVERRIDE_POWER 0x00000020 +#define D3DRMMATERIALOVERRIDE_TEXTURE 0x00000040 +#define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAMULTIPLY 0x00000080 +#define D3DRMMATERIALOVERRIDE_ALL 0x000000FF + +#define D3DRMFPTF_ALPHA 0x00000001 +#define D3DRMFPTF_NOALPHA 0x00000002 +#define D3DRMFPTF_PALETTIZED 0x00000004 +#define D3DRMFPTF_NOTPALETTIZED 0x00000008 + +#define D3DRMSTATECHANGE_UPDATEONLY 0x000000001 +#define D3DRMSTATECHANGE_VOLATILE 0x000000002 +#define D3DRMSTATECHANGE_NONVOLATILE 0x000000004 +#define D3DRMSTATECHANGE_RENDER 0x000000020 +#define D3DRMSTATECHANGE_LIGHT 0x000000040 + +#define D3DRMDEVICE_NOZBUFFER 0x00000001 + +#define D3DRMCALLBACK_PREORDER 0 +#define D3DRMCALLBACK_POSTORDER 1 + +#define D3DRMRAYPICK_ONLYBOUNDINGBOXES 0x01 +#define D3DRMRAYPICK_IGNOREFURTHERPRIMITIVES 0x02 +#define D3DRMRAYPICK_INTERPOLATEUV 0x04 +#define D3DRMRAYPICK_INTERPOLATECOLOR 0x08 +#define D3DRMRAYPICK_INTERPOLATENORMAL 0x10 + +#define D3DRMADDFACES_VERTICESONLY 1 + +#define D3DRMGENERATENORMALS_PRECOMPACT 1 +#define D3DRMGENERATENORMALS_USECREASEANGLE 2 + +#define D3DRMMESHBUILDER_DIRECTPARENT 1 +#define D3DRMMESHBUILDER_ROOTMESH 2 + +#define D3DRMMESHBUILDER_RENDERENABLE 0x00000001 +#define D3DRMMESHBUILDER_PICKENABLE 0x00000002 + +#define D3DRMADDMESHBUILDER_DONTCOPYAPPDATA 1 +#define D3DRMADDMESHBUILDER_FLATTENSUBMESHES 2 +#define D3DRMADDMESHBUILDER_NOSUBMESHES 4 + +#define D3DRMMESHBUILDERAGE_GEOMETRY 0x00000001 +#define D3DRMMESHBUILDERAGE_MATERIALS 0x00000002 +#define D3DRMMESHBUILDERAGE_TEXTURES 0x00000004 + +#define D3DRMFVF_TYPE 0x00000001 +#define D3DRMFVF_NORMAL 0x00000002 +#define D3DRMFVF_COLOR 0x00000004 +#define D3DRMFVF_TEXTURECOORDS 0x00000008 + +#define D3DRMVERTEX_STRIP 0x00000001 +#define D3DRMVERTEX_FAN 0x00000002 +#define D3DRMVERTEX_LIST 0x00000004 + +#define D3DRMCLEAR_TARGET 0x00000001 +#define D3DRMCLEAR_ZBUFFER 0x00000002 +#define D3DRMCLEAR_DIRTYRECTS 0x00000004 +#define D3DRMCLEAR_ALL (D3DRMCLEAR_TARGET | D3DRMCLEAR_ZBUFFER | D3DRMCLEAR_DIRTYRECTS) + +#define D3DRMFOGMETHOD_VERTEX 0x00000001 +#define D3DRMFOGMETHOD_TABLE 0x00000002 +#define D3DRMFOGMETHOD_ANY 0x00000004 + +#define D3DRMFRAME_RENDERENABLE 0x00000001 +#define D3DRMFRAME_PICKENABLE 0x00000002 + +typedef DWORD D3DRMANIMATIONOPTIONS; +#define D3DRMANIMATION_OPEN 0x00000001 +#define D3DRMANIMATION_CLOSED 0x00000002 +#define D3DRMANIMATION_LINEARPOSITION 0x00000004 +#define D3DRMANIMATION_SPLINEPOSITION 0x00000008 +#define D3DRMANIMATION_SCALEANDROTATION 0x00000010 +#define D3DRMANIMATION_POSITION 0x00000020 + +typedef DWORD D3DRMINTERPOLATIONOPTIONS; +#define D3DRMINTERPOLATION_OPEN 0x0001 +#define D3DRMINTERPOLATION_CLOSED 0x0002 +#define D3DRMINTERPOLATION_NEAREST 0x0100 +#define D3DRMINTERPOLATION_LINEAR 0x0004 +#define D3DRMINTERPOLATION_SPLINE 0x0008 +#define D3DRMINTERPOLATION_VERTEXCOLOR 0x0040 +#define D3DRMINTERPOLATION_SLERPNORMALS 0x0080 + +typedef DWORD D3DRMLOADOPTIONS; + +#define D3DRMLOAD_FROMFILE __MSABI_LONG(0x000) +#define D3DRMLOAD_FROMRESOURCE __MSABI_LONG(0x001) +#define D3DRMLOAD_FROMMEMORY __MSABI_LONG(0x002) +#define D3DRMLOAD_FROMSTREAM __MSABI_LONG(0x004) +#define D3DRMLOAD_FROMURL __MSABI_LONG(0x008) + +#define D3DRMLOAD_BYNAME __MSABI_LONG(0x010) +#define D3DRMLOAD_BYPOSITION __MSABI_LONG(0x020) +#define D3DRMLOAD_BYGUID __MSABI_LONG(0x040) +#define D3DRMLOAD_FIRST __MSABI_LONG(0x080) + +#define D3DRMLOAD_INSTANCEBYREFERENCE __MSABI_LONG(0x100) +#define D3DRMLOAD_INSTANCEBYCOPYING __MSABI_LONG(0x200) + +#define D3DRMLOAD_ASYNCHRONOUS __MSABI_LONG(0x400) + +typedef struct _D3DRMLOADRESOURCE +{ + HMODULE hModule; + const char *lpName; + const char *lpType; +} D3DRMLOADRESOURCE, *LPD3DRMLOADRESOURCE; + +typedef struct _D3DRMLOADMEMORY +{ + void *lpMemory; + DWORD dSize; +} D3DRMLOADMEMORY, *LPD3DRMLOADMEMORY; + +#define D3DRMPMESHSTATUS_VALID 0x01 +#define D3DRMPMESHSTATUS_INTERRUPTED 0x02 +#define D3DRMPMESHSTATUS_BASEMESHCOMPLETE 0x04 +#define D3DRMPMESHSTATUS_COMPLETE 0x08 +#define D3DRMPMESHSTATUS_RENDERABLE 0x10 + +#define D3DRMPMESHEVENT_BASEMESH 0x01 +#define D3DRMPMESHEVENT_COMPLETE 0x02 + +typedef struct _D3DRMPMESHLOADSTATUS { + DWORD dwSize; + DWORD dwPMeshSize; + DWORD dwBaseMeshSize; + DWORD dwBytesLoaded; + DWORD dwVerticesLoaded; + DWORD dwFacesLoaded; + HRESULT dwLoadResult; + DWORD dwFlags; +} D3DRMPMESHLOADSTATUS, *LPD3DRMPMESHLOADSTATUS; + +typedef enum _D3DRMUSERVISUALREASON { + D3DRMUSERVISUAL_CANSEE, + D3DRMUSERVISUAL_RENDER +} D3DRMUSERVISUALREASON, *LPD3DRMUSERVISUALREASON; + +typedef struct _D3DRMANIMATIONKEY +{ + DWORD dwSize; + DWORD dwKeyType; + D3DVALUE dvTime; + DWORD dwID; +#if !defined(__cplusplus) || !defined(D3D_OVERLOADS) + union + { + D3DRMQUATERNION dqRotateKey; + D3DVECTOR dvScaleKey; + D3DVECTOR dvPositionKey; + } DUMMYUNIONNAME; +#else + D3DVALUE dvK[4]; +#endif +} D3DRMANIMATIONKEY; +typedef D3DRMANIMATIONKEY *LPD3DRMANIMATIONKEY; + +#define D3DRMANIMATION_ROTATEKEY 0x01 +#define D3DRMANIMATION_SCALEKEY 0x02 +#define D3DRMANIMATION_POSITIONKEY 0x03 + +typedef DWORD D3DRMMAPPING, D3DRMMAPPINGFLAG, *LPD3DRMMAPPING; +static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPU = 1; +static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPV = 2; +static const D3DRMMAPPINGFLAG D3DRMMAP_PERSPCORRECT = 4; + +typedef struct _D3DRMVERTEX { + D3DVECTOR position; + D3DVECTOR normal; + D3DVALUE tu; + D3DVALUE tv; + D3DCOLOR color; +} D3DRMVERTEX, *LPD3DRMVERTEX; + +typedef LONG D3DRMGROUPINDEX; +static const D3DRMGROUPINDEX D3DRMGROUP_ALLGROUPS = -1; + +void WINAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m, D3DRMQUATERNION *q); + +D3DRMQUATERNION * WINAPI D3DRMQuaternionFromRotation(D3DRMQUATERNION *x, D3DVECTOR *axis, D3DVALUE theta); +D3DRMQUATERNION * WINAPI D3DRMQuaternionMultiply(D3DRMQUATERNION *ret, D3DRMQUATERNION *x, D3DRMQUATERNION *y); +D3DRMQUATERNION * WINAPI D3DRMQuaternionSlerp(D3DRMQUATERNION *ret, + D3DRMQUATERNION *x, D3DRMQUATERNION *y, D3DVALUE alpha); + +D3DVECTOR * WINAPI D3DRMVectorAdd(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *y); +D3DVECTOR * WINAPI D3DRMVectorCrossProduct(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *y); +D3DVALUE WINAPI D3DRMVectorDotProduct(D3DVECTOR *x, D3DVECTOR *y); +D3DVECTOR * WINAPI D3DRMVectorNormalize(D3DVECTOR *x); + +#define D3DRMVectorNormalise D3DRMVectorNormalize + +D3DVALUE WINAPI D3DRMVectorModulus(D3DVECTOR *x); +D3DVECTOR * WINAPI D3DRMVectorRandom(D3DVECTOR *ret); +D3DVECTOR * WINAPI D3DRMVectorRotate(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *axis, D3DVALUE theta); +D3DVECTOR * WINAPI D3DRMVectorReflect(D3DVECTOR *ret, D3DVECTOR *ray, D3DVECTOR *normal); +D3DVECTOR * WINAPI D3DRMVectorScale(D3DVECTOR *ret, D3DVECTOR *x, D3DVALUE scale); +D3DVECTOR * WINAPI D3DRMVectorSubtract(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *y); + +D3DCOLOR WINAPI D3DRMCreateColorRGB(D3DVALUE, D3DVALUE, D3DVALUE); +D3DCOLOR WINAPI D3DRMCreateColorRGBA(D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE); +D3DVALUE WINAPI D3DRMColorGetAlpha(D3DCOLOR); +D3DVALUE WINAPI D3DRMColorGetBlue(D3DCOLOR); +D3DVALUE WINAPI D3DRMColorGetGreen(D3DCOLOR); +D3DVALUE WINAPI D3DRMColorGetRed(D3DCOLOR); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3drmobj.h b/WineFix/lib/d2d1/include/windows/d3drmobj.h new file mode 100644 index 0000000..8a23fd9 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3drmobj.h @@ -0,0 +1,4702 @@ +/* + * Copyright (C) 2008 Vijay Kiran Kamuju + * Copyright (C) 2010 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DRMOBJ_H__ +#define __D3DRMOBJ_H__ + +#include +#define VIRTUAL +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Direct3DRM object CLSIDs */ + +DEFINE_GUID(CLSID_CDirect3DRMDevice, 0x4fa3568e, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMViewport, 0x4fa3568f, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMFrame, 0x4fa35690, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMMesh, 0x4fa35691, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMMeshBuilder, 0x4fa35692, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMFace, 0x4fa35693, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMLight, 0x4fa35694, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMTexture, 0x4fa35695, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMWrap, 0x4fa35696, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMMaterial, 0x4fa35697, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMAnimation, 0x4fa35698, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMAnimationSet, 0x4fa35699, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMUserVisual, 0x4fa3569a, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMShadow, 0x4fa3569b, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(CLSID_CDirect3DRMViewportInterpolator, 0xde9eaa1, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMFrameInterpolator, 0xde9eaa2, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMMeshInterpolator, 0xde9eaa3, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMLightInterpolator, 0xde9eaa6, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMMaterialInterpolator, 0xde9eaa7, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMTextureInterpolator, 0xde9eaa8, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMProgressiveMesh, 0x4516ec40, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(CLSID_CDirect3DRMClippedVisual, 0x5434e72d, 0x6d66, 0x11d1, 0xbb, 0xb, 0x0, 0x0, 0xf8, 0x75, 0x86, 0x5a); + +/* Direct3DRM object interface GUIDs */ + +DEFINE_GUID(IID_IDirect3DRMObject, 0xeb16cb00, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMObject2, 0x4516ec7c, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMDevice, 0xe9e19280, 0x6e05, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMDevice2, 0x4516ec78, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMDevice3, 0x549f498b, 0xbfeb, 0x11d1, 0x8e, 0xd8, 0x00, 0xa0, 0xc9, 0x67, 0xa4, 0x82); +DEFINE_GUID(IID_IDirect3DRMViewport, 0xeb16cb02, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMViewport2, 0x4a1b1be6, 0xbfed, 0x11d1, 0x8e, 0xd8, 0x00, 0xa0, 0xc9, 0x67, 0xa4, 0x82); +DEFINE_GUID(IID_IDirect3DRMFrame, 0xeb16cb03, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMFrame2, 0xc3dfbd60, 0x3988, 0x11d0, 0x9e, 0xc2, 0x00, 0x00, 0xc0, 0x29, 0x1a, 0xc3); +DEFINE_GUID(IID_IDirect3DRMFrame3, 0xff6b7f70, 0xa40e, 0x11d1, 0x91, 0xf9, 0x00, 0x00, 0xf8, 0x75, 0x8e, 0x66); +DEFINE_GUID(IID_IDirect3DRMVisual, 0xeb16cb04, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMMesh, 0xa3a80d01, 0x6e12, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMMeshBuilder, 0xa3a80d02, 0x6e12, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMMeshBuilder2, 0x4516ec77, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMMeshBuilder3, 0x4516ec82, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMFace, 0xeb16cb07, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMFace2, 0x4516ec81, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMLight, 0xeb16cb08, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMTexture, 0xeb16cb09, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMTexture2, 0x120f30c0, 0x1629, 0x11d0, 0x94, 0x1c, 0x00, 0x80, 0xc8, 0x0c, 0xfa, 0x7b); +DEFINE_GUID(IID_IDirect3DRMTexture3, 0xff6b7f73, 0xa40e, 0x11d1, 0x91, 0xf9, 0x00, 0x00, 0xf8, 0x75, 0x8e, 0x66); +DEFINE_GUID(IID_IDirect3DRMWrap, 0xeb16cb0a, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMMaterial, 0xeb16cb0b, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMMaterial2, 0xff6b7f75, 0xa40e, 0x11d1, 0x91, 0xf9, 0x00, 0x00, 0xf8, 0x75, 0x8e, 0x66); +DEFINE_GUID(IID_IDirect3DRMAnimation, 0xeb16cb0d, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMAnimation2, 0xff6b7f77, 0xa40e, 0x11d1, 0x91, 0xf9, 0x00, 0x00, 0xf8, 0x75, 0x8e, 0x66); +DEFINE_GUID(IID_IDirect3DRMAnimationSet, 0xeb16cb0e, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMAnimationSet2, 0xff6b7f79, 0xa40e, 0x11d1, 0x91, 0xf9, 0x00, 0x00, 0xf8, 0x75, 0x8e, 0x66); +DEFINE_GUID(IID_IDirect3DRMObjectArray, 0x242f6bc2, 0x3849, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMDeviceArray, 0xeb16cb10, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMViewportArray, 0xeb16cb11, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMFrameArray, 0xeb16cb12, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMVisualArray, 0xeb16cb13, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMLightArray, 0xeb16cb14, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMPickedArray, 0xeb16cb16, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMFaceArray, 0xeb16cb17, 0xd271, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMAnimationArray, 0xd5f1cae0, 0x4bd7, 0x11d1, 0xb9, 0x74, 0x00, 0x60, 0x08, 0x3e, 0x45, 0xf3); +DEFINE_GUID(IID_IDirect3DRMUserVisual, 0x59163de0, 0x6d43, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMShadow, 0xaf359780, 0x6ba3, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); +DEFINE_GUID(IID_IDirect3DRMShadow2, 0x86b44e25, 0x9c82, 0x11d1, 0xbb, 0x0b, 0x00, 0xa0, 0xc9, 0x81, 0xa0, 0xa6); +DEFINE_GUID(IID_IDirect3DRMInterpolator, 0x242f6bc1, 0x3849, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMProgressiveMesh, 0x4516ec79, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMPicked2Array, 0x4516ec7b, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3); +DEFINE_GUID(IID_IDirect3DRMClippedVisual, 0x5434e733, 0x6d66, 0x11d1, 0xbb, 0x0b, 0x00, 0x00, 0xf8, 0x75, 0x86, 0x5a); + +/***************************************************************************** + * Predeclare the interfaces + */ + +typedef struct IDirect3DRMObject *LPDIRECT3DRMOBJECT, **LPLPDIRECT3DRMOBJECT; +typedef struct IDirect3DRMObject2 *LPDIRECT3DRMOBJECT2, **LPLPDIRECT3DRMOBJECT2; +typedef struct IDirect3DRMDevice *LPDIRECT3DRMDEVICE, **LPLPDIRECT3DRMDEVICE; +typedef struct IDirect3DRMDevice2 *LPDIRECT3DRMDEVICE2, **LPLPDIRECT3DRMDEVICE2; +typedef struct IDirect3DRMDevice3 *LPDIRECT3DRMDEVICE3, **LPLPDIRECT3DRMDEVICE3; +typedef struct IDirect3DRMViewport *LPDIRECT3DRMVIEWPORT, **LPLPDIRECT3DRMVIEWPORT; +typedef struct IDirect3DRMViewport2 *LPDIRECT3DRMVIEWPORT2, **LPLPDIRECT3DRMVIEWPORT2; +typedef struct IDirect3DRMFrame *LPDIRECT3DRMFRAME, **LPLPDIRECT3DRMFRAME; +typedef struct IDirect3DRMFrame2 *LPDIRECT3DRMFRAME2, **LPLPDIRECT3DRMFRAME2; +typedef struct IDirect3DRMFrame3 *LPDIRECT3DRMFRAME3, **LPLPDIRECT3DRMFRAME3; +typedef struct IDirect3DRMVisual *LPDIRECT3DRMVISUAL, **LPLPDIRECT3DRMVISUAL; +typedef struct IDirect3DRMMesh *LPDIRECT3DRMMESH, **LPLPDIRECT3DRMMESH; +typedef struct IDirect3DRMMeshBuilder *LPDIRECT3DRMMESHBUILDER, **LPLPDIRECT3DRMMESHBUILDER; +typedef struct IDirect3DRMMeshBuilder2 *LPDIRECT3DRMMESHBUILDER2, **LPLPDIRECT3DRMMESHBUILDER2; +typedef struct IDirect3DRMMeshBuilder3 *LPDIRECT3DRMMESHBUILDER3, **LPLPDIRECT3DRMMESHBUILDER3; +typedef struct IDirect3DRMFace *LPDIRECT3DRMFACE, **LPLPDIRECT3DRMFACE; +typedef struct IDirect3DRMFace2 *LPDIRECT3DRMFACE2, **LPLPDIRECT3DRMFACE2; +typedef struct IDirect3DRMLight *LPDIRECT3DRMLIGHT, **LPLPDIRECT3DRMLIGHT; +typedef struct IDirect3DRMTexture *LPDIRECT3DRMTEXTURE, **LPLPDIRECT3DRMTEXTURE; +typedef struct IDirect3DRMTexture2 *LPDIRECT3DRMTEXTURE2, **LPLPDIRECT3DRMTEXTURE2; +typedef struct IDirect3DRMTexture3 *LPDIRECT3DRMTEXTURE3, **LPLPDIRECT3DRMTEXTURE3; +typedef struct IDirect3DRMWrap *LPDIRECT3DRMWRAP, **LPLPDIRECT3DRMWRAP; +typedef struct IDirect3DRMMaterial *LPDIRECT3DRMMATERIAL, **LPLPDIRECT3DRMMATERIAL; +typedef struct IDirect3DRMMaterial2 *LPDIRECT3DRMMATERIAL2, **LPLPDIRECT3DRMMATERIAL2; +typedef struct IDirect3DRMAnimation *LPDIRECT3DRMANIMATION, **LPLPDIRECT3DRMANIMATION; +typedef struct IDirect3DRMAnimation2 *LPDIRECT3DRMANIMATION2, **LPLPDIRECT3DRMANIMATION2; +typedef struct IDirect3DRMAnimationSet *LPDIRECT3DRMANIMATIONSET, **LPLPDIRECT3DRMANIMATIONSET; +typedef struct IDirect3DRMAnimationSet2 *LPDIRECT3DRMANIMATIONSET2, **LPLPDIRECT3DRMANIMATIONSET2; +typedef struct IDirect3DRMUserVisual *LPDIRECT3DRMUSERVISUAL, **LPLPDIRECT3DRMUSERVISUAL; +typedef struct IDirect3DRMShadow *LPDIRECT3DRMSHADOW, **LPLPDIRECT3DRMSHADOW; +typedef struct IDirect3DRMShadow2 *LPDIRECT3DRMSHADOW2, **LPLPDIRECT3DRMSHADOW2; +typedef struct IDirect3DRMArray *LPDIRECT3DRMARRAY, **LPLPDIRECT3DRMARRAY; +typedef struct IDirect3DRMObjectArray *LPDIRECT3DRMOBJECTARRAY, **LPLPDIRECT3DRMOBJECTARRAY; +typedef struct IDirect3DRMDeviceArray *LPDIRECT3DRMDEVICEARRAY, **LPLPDIRECT3DRMDEVICEARRAY; +typedef struct IDirect3DRMFaceArray *LPDIRECT3DRMFACEARRAY, **LPLPDIRECT3DRMFACEARRAY; +typedef struct IDirect3DRMViewportArray *LPDIRECT3DRMVIEWPORTARRAY, **LPLPDIRECT3DRMVIEWPORTARRAY; +typedef struct IDirect3DRMFrameArray *LPDIRECT3DRMFRAMEARRAY, **LPLPDIRECT3DRMFRAMEARRAY; +typedef struct IDirect3DRMAnimationArray *LPDIRECT3DRMANIMATIONARRAY, **LPLPDIRECT3DRMANIMATIONARRAY; +typedef struct IDirect3DRMVisualArray *LPDIRECT3DRMVISUALARRAY, **LPLPDIRECT3DRMVISUALARRAY; +typedef struct IDirect3DRMPickedArray *LPDIRECT3DRMPICKEDARRAY, **LPLPDIRECT3DRMPICKEDARRAY; +typedef struct IDirect3DRMPicked2Array *LPDIRECT3DRMPICKED2ARRAY, **LPLPDIRECT3DRMPICKED2ARRAY; +typedef struct IDirect3DRMLightArray *LPDIRECT3DRMLIGHTARRAY, **LPLPDIRECT3DRMLIGHTARRAY; +typedef struct IDirect3DRMProgressiveMesh *LPDIRECT3DRMPROGRESSIVEMESH, **LPLPDIRECT3DRMPROGRESSIVEMESH; +typedef struct IDirect3DRMClippedVisual *LPDIRECT3DRMCLIPPEDVISUAL, **LPLPDIRECT3DRMCLIPPEDVISUAL; + +/* ******************************************************************** + Types and structures + ******************************************************************** */ + +typedef void (__cdecl *D3DRMOBJECTCALLBACK)(struct IDirect3DRMObject *obj, void *arg); +typedef void (__cdecl *D3DRMFRAMEMOVECALLBACK)(struct IDirect3DRMFrame *frame, void *ctx, D3DVALUE delta); +typedef void (__cdecl *D3DRMFRAME3MOVECALLBACK)(struct IDirect3DRMFrame3 *frame, void *ctx, D3DVALUE delta); +typedef void (__cdecl *D3DRMUPDATECALLBACK)(struct IDirect3DRMDevice *device, void *ctx, int count, D3DRECT *rects); +typedef void (__cdecl *D3DRMDEVICE3UPDATECALLBACK)(struct IDirect3DRMDevice3 *device, void *ctx, + int count, D3DRECT *rects); +typedef int (__cdecl *D3DRMUSERVISUALCALLBACK)(struct IDirect3DRMUserVisual *visual, void *ctx, + D3DRMUSERVISUALREASON reason, struct IDirect3DRMDevice *device, struct IDirect3DRMViewport *viewport); +typedef HRESULT (__cdecl *D3DRMLOADTEXTURECALLBACK)(char *tex_name, void *arg, struct IDirect3DRMTexture **texture); +typedef HRESULT (__cdecl *D3DRMLOADTEXTURE3CALLBACK)(char *tex_name, void *arg, struct IDirect3DRMTexture3 **texture); +typedef void (__cdecl *D3DRMLOADCALLBACK)(struct IDirect3DRMObject *object, REFIID objectguid, void *arg); +typedef HRESULT (__cdecl *D3DRMDOWNSAMPLECALLBACK)(struct IDirect3DRMTexture3 *texture, void *ctx, + IDirectDrawSurface *src_surface, IDirectDrawSurface *dst_surface); +typedef HRESULT (__cdecl *D3DRMVALIDATIONCALLBACK)(struct IDirect3DRMTexture3 *texture, void *ctx, + DWORD flags, DWORD rect_count, RECT *rects); + +typedef struct _D3DRMPICKDESC +{ + ULONG ulFaceIdx; + LONG lGroupIdx; + D3DVECTOR vPosition; +} D3DRMPICKDESC, *LPD3DRMPICKDESC; + +typedef struct _D3DRMPICKDESC2 +{ + ULONG ulFaceIdx; + LONG lGroupIdx; + D3DVECTOR vPosition; + D3DVALUE tu; + D3DVALUE tv; + D3DVECTOR dvNormal; + D3DCOLOR dcColor; +} D3DRMPICKDESC2, *LPD3DRMPICKDESC2; + +/***************************************************************************** + * IDirect3DRMObject interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRMObject +DECLARE_INTERFACE_(IDirect3DRMObject,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMObject_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMObject_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMObject_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMObject_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMObject_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMObject_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMObject_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMObject_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMObject_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMObject_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMObject_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMObject_AddRef(p) (p)->AddRef() +#define IDirect3DRMObject_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMObject_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMObject_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMObject_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMObject_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMObject_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMObject_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMObject_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMObject_GetClassName(p,a,b) (p)->GetClassName(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMObject2 interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRMObject2 +DECLARE_INTERFACE_(IDirect3DRMObject2,IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject2 methods ***/ + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(GetClientData)(THIS_ DWORD id, void **data) PURE; + STDMETHOD(GetDirect3DRM)(THIS_ struct IDirect3DRM **d3drm) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(SetClientData)(THIS_ DWORD id, void *data, DWORD flags) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetAge)(THIS_ DWORD flags, DWORD *age) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMObject2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMObject2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMObject2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject2 methods ***/ +#define IDirect3DRMObject2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMObject2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMObject2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMObject2_GetClientData(p,a,b) (p)->lpVtbl->GetClientData(p,a,b) +#define IDirect3DRMObject2_GetDirect3DRM(p,a) (p)->lpVtbl->GetDirect3DRM(p,a) +#define IDirect3DRMObject2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMObject2_SetClientData(p,a,b,c) (p)->lpVtbl->SetClientData(p,a,b,c) +#define IDirect3DRMObject2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMObject2_GetAge(p,a,b) (p)->lpVtbl->GetAge(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMObject2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMObject2_AddRef(p) (p)->AddRef() +#define IDirect3DRMObject2_Release(p) (p)->Release() +/*** IDirect3DRMObject2 methods ***/ +#define IDirect3DRMObject2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMObject2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMObject2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMObject2_GetClientData(p,a,b) (p)->GetClientData(a,b) +#define IDirect3DRMObject2_GetDirect3DRM(p,a) (p)->GetDirect3DRM(a) +#define IDirect3DRMObject2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMObject2_SetClientData(p,a,b,c) (p)->SetClientData(a,b,c) +#define IDirect3DRMObject2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMObject2_GetAge(p,a,b) (p)->GetAge(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMVisual interface + */ +#define INTERFACE IDirect3DRMVisual +DECLARE_INTERFACE_(IDirect3DRMVisual,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMVisual_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMVisual_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMVisual_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMVisual_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMVisual_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMVisual_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMVisual_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMVisual_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMVisual_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMVisual_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMVisual_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMVisual_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMVisual_AddRef(p) (p)->AddRef() +#define IDirect3DRMVisual_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMVisual_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMVisual_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMVisual_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMVisual_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMVisual_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMVisual_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMVisual_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMVisual_GetClassName(p,a,b) (p)->GetClassName(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMDevice interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRMDevice +DECLARE_INTERFACE_(IDirect3DRMDevice,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMDevice methods ***/ + STDMETHOD(Init)(THIS_ ULONG width, ULONG height) PURE; + STDMETHOD(InitFromD3D)(THIS_ IDirect3D *d3d, IDirect3DDevice *d3d_device) PURE; + STDMETHOD(InitFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid, int width, int height) PURE; + STDMETHOD(Update)(THIS) PURE; + STDMETHOD(AddUpdateCallback)(THIS_ D3DRMUPDATECALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteUpdateCallback)(THIS_ D3DRMUPDATECALLBACK cb, void *ctx) PURE; + STDMETHOD(SetBufferCount)(THIS_ DWORD) PURE; + STDMETHOD_(DWORD, GetBufferCount)(THIS) PURE; + STDMETHOD(SetDither)(THIS_ BOOL) PURE; + STDMETHOD(SetShades)(THIS_ DWORD) PURE; + STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE; + STDMETHOD(SetTextureQuality)(THIS_ D3DRMTEXTUREQUALITY) PURE; + STDMETHOD(GetViewports)(THIS_ struct IDirect3DRMViewportArray **array) PURE; + STDMETHOD_(BOOL, GetDither)(THIS) PURE; + STDMETHOD_(DWORD, GetShades)(THIS) PURE; + STDMETHOD_(DWORD, GetHeight)(THIS) PURE; + STDMETHOD_(DWORD, GetWidth)(THIS) PURE; + STDMETHOD_(DWORD, GetTrianglesDrawn)(THIS) PURE; + STDMETHOD_(DWORD, GetWireframeOptions)(THIS) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE; + STDMETHOD_(D3DCOLORMODEL, GetColorModel)(THIS) PURE; + STDMETHOD_(D3DRMTEXTUREQUALITY, GetTextureQuality)(THIS) PURE; + STDMETHOD(GetDirect3DDevice)(THIS_ IDirect3DDevice **d3d_device) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMDevice_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMDevice_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMDevice_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMDevice_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMDevice_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMDevice_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMDevice_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMDevice_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMDevice_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMDevice_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMDevice methods ***/ +#define IDirect3DRMDevice_Init(p,a,b) (p)->lpVtbl->Init(p,a,b) +#define IDirect3DRMDevice_InitFromD3D(p,a,b) (p)->lpVtbl->InitFromD3D(p,a,b) +#define IDirect3DRMDevice_InitFromClipper(p,a,b,c,d) (p)->lpVtbl->InitFromClipper(p,a,b,c,d) +#define IDirect3DRMDevice_Update(p) (p)->lpVtbl->Update(p) +#define IDirect3DRMDevice_AddUpdateCallback(p,a,b) (p)->lpVtbl->AddUpdateCallback(p,a,b) +#define IDirect3DRMDevice_DeleteUpdateCallback(p,a,b) (p)->lpVtbl->DeleteUpdateCallback(p,a,b) +#define IDirect3DRMDevice_SetBufferCount(p,a) (p)->lpVtbl->SetBufferCount(p,a) +#define IDirect3DRMDevice_GetBufferCount(p) (p)->lpVtbl->GetBufferCount(p) +#define IDirect3DRMDevice_SetDither(p,a) (p)->lpVtbl->SetDither(p,a) +#define IDirect3DRMDevice_SetShades(p,a) (p)->lpVtbl->SetShades(p,a) +#define IDirect3DRMDevice_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMDevice_SetTextureQuality(p,a) (p)->lpVtbl->SetTextureQuality(p,a) +#define IDirect3DRMDevice_GetViewports(p,a) (p)->lpVtbl->GetViewports(p,a) +#define IDirect3DRMDevice_GetDither(p) (p)->lpVtbl->GetDither(p) +#define IDirect3DRMDevice_GetShades(p) (p)->lpVtbl->GetShades(p) +#define IDirect3DRMDevice_GetHeight(p) (p)->lpVtbl->GetHeight(p) +#define IDirect3DRMDevice_GetWidth(p) (p)->lpVtbl->GetWidth(p) +#define IDirect3DRMDevice_GetTrianglesDrawn(p) (p)->lpVtbl->GetTrianglesDrawn(p) +#define IDirect3DRMDevice_GetWireframeOptions(p) (p)->lpVtbl->GetWireframeOptions(p) +#define IDirect3DRMDevice_GetQuality(p) (p)->lpVtbl->GetQuality(p) +#define IDirect3DRMDevice_GetColorModel(p) (p)->lpVtbl->GetColorModel(p) +#define IDirect3DRMDevice_GetTextureQuality(p) (p)->lpVtbl->GetTextureQuality(p) +#define IDirect3DRMDevice_GetDirect3DDevice(p,a) (p)->lpVtbl->GetDirect3DDevice(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMDevice_AddRef(p) (p)->AddRef() +#define IDirect3DRMDevice_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMDevice_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMDevice_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMDevice_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMDevice_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMDevice_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMDevice_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMDevice_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMDevice_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMDevice methods ***/ +#define IDirect3DRMDevice_Init(p,a,b) (p)->Init(a,b) +#define IDirect3DRMDevice_InitFromD3D(p,a,b) (p)->InitFromD3D(a,b) +#define IDirect3DRMDevice_InitFromClipper(p,a,b,c,d) (p)->InitFromClipper(a,b,c,d) +#define IDirect3DRMDevice_Update(p) (p)->Update() +#define IDirect3DRMDevice_AddUpdateCallback(p,a,b) (p)->AddUpdateCallback(a,b) +#define IDirect3DRMDevice_DeleteUpdateCallback(p,a,b) (p)->DeleteUpdateCallback(a,b) +#define IDirect3DRMDevice_SetBufferCount(p,a) (p)->SetBufferCount(a) +#define IDirect3DRMDevice_GetBufferCount(p) (p)->GetBufferCount() +#define IDirect3DRMDevice_SetDither(p,a) (p)->SetDither(a) +#define IDirect3DRMDevice_SetShades(p,a) (p)->SetShades(a) +#define IDirect3DRMDevice_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMDevice_SetTextureQuality(p,a) (p)->SetTextureQuality(a) +#define IDirect3DRMDevice_GetViewports(p,a) (p)->GetViewports(a) +#define IDirect3DRMDevice_GetDither(p) (p)->GetDither() +#define IDirect3DRMDevice_GetShades(p) (p)->GetShades() +#define IDirect3DRMDevice_GetHeight(p) (p)->GetHeight() +#define IDirect3DRMDevice_GetWidth(p) (p)->GetWidth() +#define IDirect3DRMDevice_GetTrianglesDrawn(p) (p)->GetTrianglesDrawn() +#define IDirect3DRMDevice_GetWireframeOptions(p) (p)->GetWireframeOptions() +#define IDirect3DRMDevice_GetQuality(p) (p)->GetQuality() +#define IDirect3DRMDevice_GetColorModel(p) (p)->GetColorModel() +#define IDirect3DRMDevice_GetTextureQuality(p) (p)->GetTextureQuality() +#define IDirect3DRMDevice_GetDirect3DDevice(p,a) (p)->GetDirect3DDevice(a) +#endif + +/***************************************************************************** + * IDirect3DRMDevice2 interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRMDevice2 +DECLARE_INTERFACE_(IDirect3DRMDevice2,IDirect3DRMDevice) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMDevice methods ***/ + STDMETHOD(Init)(THIS_ ULONG width, ULONG height) PURE; + STDMETHOD(InitFromD3D)(THIS_ IDirect3D *d3d, IDirect3DDevice *d3d_device) PURE; + STDMETHOD(InitFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid, int width, int height) PURE; + STDMETHOD(Update)(THIS) PURE; + STDMETHOD(AddUpdateCallback)(THIS_ D3DRMUPDATECALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteUpdateCallback)(THIS_ D3DRMUPDATECALLBACK cb, void *ctx) PURE; + STDMETHOD(SetBufferCount)(THIS_ DWORD) PURE; + STDMETHOD_(DWORD, GetBufferCount)(THIS) PURE; + STDMETHOD(SetDither)(THIS_ BOOL) PURE; + STDMETHOD(SetShades)(THIS_ DWORD) PURE; + STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE; + STDMETHOD(SetTextureQuality)(THIS_ D3DRMTEXTUREQUALITY) PURE; + STDMETHOD(GetViewports)(THIS_ struct IDirect3DRMViewportArray **array) PURE; + STDMETHOD_(BOOL, GetDither)(THIS) PURE; + STDMETHOD_(DWORD, GetShades)(THIS) PURE; + STDMETHOD_(DWORD, GetHeight)(THIS) PURE; + STDMETHOD_(DWORD, GetWidth)(THIS) PURE; + STDMETHOD_(DWORD, GetTrianglesDrawn)(THIS) PURE; + STDMETHOD_(DWORD, GetWireframeOptions)(THIS) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE; + STDMETHOD_(D3DCOLORMODEL, GetColorModel)(THIS) PURE; + STDMETHOD_(D3DRMTEXTUREQUALITY, GetTextureQuality)(THIS) PURE; + STDMETHOD(GetDirect3DDevice)(THIS_ IDirect3DDevice **d3d_device) PURE; + /*** IDirect3DRMDevice2 methods ***/ + STDMETHOD(InitFromD3D2)(THIS_ IDirect3D2 *d3d, IDirect3DDevice2 *device) PURE; + STDMETHOD(InitFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *surface) PURE; + STDMETHOD(SetRenderMode)(THIS_ DWORD flags) PURE; + STDMETHOD_(DWORD, GetRenderMode)(THIS) PURE; + STDMETHOD(GetDirect3DDevice2)(THIS_ IDirect3DDevice2 **device) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMDevice2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMDevice2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMDevice2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMDevice2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMDevice2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMDevice2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMDevice2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMDevice2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMDevice2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMDevice2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMDevice2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMDevice methods ***/ +#define IDirect3DRMDevice2_Init(p,a,b) (p)->lpVtbl->Init(p,a,b) +#define IDirect3DRMDevice2_InitFromD3D(p,a,b) (p)->lpVtbl->InitFromD3D(p,a,b) +#define IDirect3DRMDevice2_InitFromClipper(p,a,b,c,d) (p)->lpVtbl->InitFromClipper(p,a,b,c,d) +#define IDirect3DRMDevice2_Update(p) (p)->lpVtbl->Update(p) +#define IDirect3DRMDevice2_AddUpdateCallback(p,a,b) (p)->lpVtbl->AddUpdateCallback(p,a,b) +#define IDirect3DRMDevice2_DeleteUpdateCallback(p,a,b) (p)->lpVtbl->DeleteUpdateCallback(p,a,b) +#define IDirect3DRMDevice2_SetBufferCount(p,a) (p)->lpVtbl->SetBufferCount(p,a) +#define IDirect3DRMDevice2_GetBufferCount(p) (p)->lpVtbl->GetBufferCount(p) +#define IDirect3DRMDevice2_SetDither(p,a) (p)->lpVtbl->SetDither(p,a) +#define IDirect3DRMDevice2_SetShades(p,a) (p)->lpVtbl->SetShades(p,a) +#define IDirect3DRMDevice2_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMDevice2_SetTextureQuality(p,a) (p)->lpVtbl->SetTextureQuality(p,a) +#define IDirect3DRMDevice2_GetViewports(p,a) (p)->lpVtbl->GetViewports(p,a) +#define IDirect3DRMDevice2_GetDither(p) (p)->lpVtbl->GetDither(p) +#define IDirect3DRMDevice2_GetShades(p) (p)->lpVtbl->GetShades(p) +#define IDirect3DRMDevice2_GetHeight(p) (p)->lpVtbl->GetHeight(p) +#define IDirect3DRMDevice2_GetWidth(p) (p)->lpVtbl->GetWidth(p) +#define IDirect3DRMDevice2_GetTrianglesDrawn(p) (p)->lpVtbl->GetTrianglesDrawn(p) +#define IDirect3DRMDevice2_GetWireframeOptions(p) (p)->lpVtbl->GetWireframeOptions(p) +#define IDirect3DRMDevice2_GetQuality(p) (p)->lpVtbl->GetQuality(p) +#define IDirect3DRMDevice2_GetColorModel(p) (p)->lpVtbl->GetColorModel(p) +#define IDirect3DRMDevice2_GetTextureQuality(p) (p)->lpVtbl->GetTextureQuality(p) +#define IDirect3DRMDevice2_GetDirect3DDevice(p,a) (p)->lpVtbl->GetDirect3DDevice(p,a) +/*** IDirect3DRMDevice2 methods ***/ +#define IDirect3DRMDevice2_InitFromD3D2(p,a,b) (p)->lpVtbl->InitFromD3D2(p,a,b) +#define IDirect3DRMDevice2_InitFromSurface(p,a,b,c) (p)->lpVtbl->InitFromSurface(p,a,b,c) +#define IDirect3DRMDevice2_SetRenderMode(p,a) (p)->lpVtbl->SetRenderMode(p,a) +#define IDirect3DRMDevice2_GetRenderMode(p) (p)->lpVtbl->GetRenderMode(p) +#define IDirect3DRMDevice2_GetDirect3DDevice2(p,a) (p)->lpVtbl->GetDirect3DDevice2(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMDevice2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMDevice2_AddRef(p) (p)->AddRef() +#define IDirect3DRMDevice2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMDevice2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMDevice2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMDevice2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMDevice2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMDevice2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMDevice2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMDevice2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMDevice2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMDevice methods ***/ +#define IDirect3DRMDevice2_Init(p,a,b) (p)->Init(a,b) +#define IDirect3DRMDevice2_InitFromD3D(p,a,b) (p)->InitFromD3D(a,b) +#define IDirect3DRMDevice2_InitFromClipper(p,a,b,c,d) (p)->InitFromClipper(a,b,c,d) +#define IDirect3DRMDevice2_Update(p) (p)->Update() +#define IDirect3DRMDevice2_AddUpdateCallback(p,a,b) (p)->AddUpdateCallback(a,b) +#define IDirect3DRMDevice2_DeleteUpdateCallback(p,a,b) (p)->DeleteUpdateCallback(a,b) +#define IDirect3DRMDevice2_SetBufferCount(p,a) (p)->SetBufferCount(a) +#define IDirect3DRMDevice2_GetBufferCount(p) (p)->GetBufferCount() +#define IDirect3DRMDevice2_SetDither(p,a) (p)->SetDither(a) +#define IDirect3DRMDevice2_SetShades(p,a) (p)->SetShades(a) +#define IDirect3DRMDevice2_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMDevice2_SetTextureQuality(p,a) (p)->SetTextureQuality(a) +#define IDirect3DRMDevice2_GetViewports(p,a) (p)->GetViewports(a) +#define IDirect3DRMDevice2_GetDither(p) (p)->GetDither() +#define IDirect3DRMDevice2_GetShades(p) (p)->GetShades() +#define IDirect3DRMDevice2_GetHeight(p) (p)->GetHeight() +#define IDirect3DRMDevice2_GetWidth(p) (p)->GetWidth() +#define IDirect3DRMDevice2_GetTrianglesDrawn(p) (p)->GetTrianglesDrawn() +#define IDirect3DRMDevice2_GetWireframeOptions(p) (p)->GetWireframeOptions() +#define IDirect3DRMDevice2_GetQuality(p) (p)->GetQuality() +#define IDirect3DRMDevice2_GetColorModel(p) (p)->GetColorModel() +#define IDirect3DRMDevice2_GetTextureQuality(p) (p)->GetTextureQuality() +#define IDirect3DRMDevice2_GetDirect3DDevice(p,a) (p)->GetDirect3DDevice(a) +/*** IDirect3DRMDevice2 methods ***/ +#define IDirect3DRMDevice2_InitFromD3D2(p,a,b) (p)->InitFromD3D2(a,b) +#define IDirect3DRMDevice2_InitFromSurface(p,a,b,c) (p)->InitFromSurface(a,b,c) +#define IDirect3DRMDevice2_SetRenderMode(p,a) (p)->SetRenderMode(a) +#define IDirect3DRMDevice2_GetRenderMode(p) (p)->GetRenderMode() +#define IDirect3DRMDevice2_GetDirect3DDevice2(p,a) (p)->GetDirect3DDevice2(a) +#endif + +/***************************************************************************** + * IDirect3DRMDevice3 interface + */ +#ifdef WINE_NO_UNICODE_MACROS +#undef GetClassName +#endif +#define INTERFACE IDirect3DRMDevice3 +DECLARE_INTERFACE_(IDirect3DRMDevice3,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMDevice methods ***/ + STDMETHOD(Init)(THIS_ ULONG width, ULONG height) PURE; + STDMETHOD(InitFromD3D)(THIS_ IDirect3D *d3d, IDirect3DDevice *d3d_device) PURE; + STDMETHOD(InitFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid, int width, int height) PURE; + STDMETHOD(Update)(THIS) PURE; + STDMETHOD(AddUpdateCallback)(THIS_ D3DRMUPDATECALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteUpdateCallback)(THIS_ D3DRMUPDATECALLBACK cb, void *ctx) PURE; + STDMETHOD(SetBufferCount)(THIS_ DWORD) PURE; + STDMETHOD_(DWORD, GetBufferCount)(THIS) PURE; + STDMETHOD(SetDither)(THIS_ BOOL) PURE; + STDMETHOD(SetShades)(THIS_ DWORD) PURE; + STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE; + STDMETHOD(SetTextureQuality)(THIS_ D3DRMTEXTUREQUALITY) PURE; + STDMETHOD(GetViewports)(THIS_ struct IDirect3DRMViewportArray **array) PURE; + STDMETHOD_(BOOL, GetDither)(THIS) PURE; + STDMETHOD_(DWORD, GetShades)(THIS) PURE; + STDMETHOD_(DWORD, GetHeight)(THIS) PURE; + STDMETHOD_(DWORD, GetWidth)(THIS) PURE; + STDMETHOD_(DWORD, GetTrianglesDrawn)(THIS) PURE; + STDMETHOD_(DWORD, GetWireframeOptions)(THIS) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE; + STDMETHOD_(D3DCOLORMODEL, GetColorModel)(THIS) PURE; + STDMETHOD_(D3DRMTEXTUREQUALITY, GetTextureQuality)(THIS) PURE; + STDMETHOD(GetDirect3DDevice)(THIS_ IDirect3DDevice **d3d_device) PURE; + /*** IDirect3DRMDevice2 methods ***/ + STDMETHOD(InitFromD3D2)(THIS_ IDirect3D2 *d3d, IDirect3DDevice2 *device) PURE; + STDMETHOD(InitFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *surface) PURE; + STDMETHOD(SetRenderMode)(THIS_ DWORD flags) PURE; + STDMETHOD_(DWORD, GetRenderMode)(THIS) PURE; + STDMETHOD(GetDirect3DDevice2)(THIS_ IDirect3DDevice2 **device) PURE; + /*** IDirect3DRMDevice3 methods ***/ + STDMETHOD(FindPreferredTextureFormat)(THIS_ DWORD BitDepths, DWORD flags, DDPIXELFORMAT *format) PURE; + STDMETHOD(RenderStateChange)(THIS_ D3DRENDERSTATETYPE drsType, DWORD val, DWORD flags) PURE; + STDMETHOD(LightStateChange)(THIS_ D3DLIGHTSTATETYPE drsType, DWORD val, DWORD flags) PURE; + STDMETHOD(GetStateChangeOptions)(THIS_ DWORD state_class, DWORD state_idx, DWORD *flags) PURE; + STDMETHOD(SetStateChangeOptions)(THIS_ DWORD StateClass, DWORD StateNum, DWORD flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMDevice3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMDevice3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMDevice3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMDevice3_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMDevice3_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMDevice3_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMDevice3_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMDevice3_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMDevice3_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMDevice3_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMDevice3_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMDevice methods ***/ +#define IDirect3DRMDevice3_Init(p,a,b) (p)->lpVtbl->Init(p,a,b) +#define IDirect3DRMDevice3_InitFromD3D(p,a,b) (p)->lpVtbl->InitFromD3D(p,a,b) +#define IDirect3DRMDevice3_InitFromClipper(p,a,b,c,d) (p)->lpVtbl->InitFromClipper(p,a,b,c,d) +#define IDirect3DRMDevice3_Update(p) (p)->lpVtbl->Update(p) +#define IDirect3DRMDevice3_AddUpdateCallback(p,a,b) (p)->lpVtbl->AddUpdateCallback(p,a,b) +#define IDirect3DRMDevice3_DeleteUpdateCallback(p,a,b) (p)->lpVtbl->DeleteUpdateCallback(p,a,b) +#define IDirect3DRMDevice3_SetBufferCount(p,a) (p)->lpVtbl->SetBufferCount(p,a) +#define IDirect3DRMDevice3_GetBufferCount(p) (p)->lpVtbl->GetBufferCount(p) +#define IDirect3DRMDevice3_SetDither(p,a) (p)->lpVtbl->SetDither(p,a) +#define IDirect3DRMDevice3_SetShades(p,a) (p)->lpVtbl->SetShades(p,a) +#define IDirect3DRMDevice3_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMDevice3_SetTextureQuality(p,a) (p)->lpVtbl->SetTextureQuality(p,a) +#define IDirect3DRMDevice3_GetViewports(p,a) (p)->lpVtbl->GetViewports(p,a) +#define IDirect3DRMDevice3_GetDither(p) (p)->lpVtbl->GetDither(p) +#define IDirect3DRMDevice3_GetShades(p) (p)->lpVtbl->GetShades(p) +#define IDirect3DRMDevice3_GetHeight(p) (p)->lpVtbl->GetHeight(p) +#define IDirect3DRMDevice3_GetWidth(p) (p)->lpVtbl->GetWidth(p) +#define IDirect3DRMDevice3_GetTrianglesDrawn(p) (p)->lpVtbl->GetTrianglesDrawn(p) +#define IDirect3DRMDevice3_GetWireframeOptions(p) (p)->lpVtbl->GetWireframeOptions(p) +#define IDirect3DRMDevice3_GetQuality(p) (p)->lpVtbl->GetQuality(p) +#define IDirect3DRMDevice3_GetColorModel(p) (p)->lpVtbl->GetColorModel(p) +#define IDirect3DRMDevice3_GetTextureQuality(p) (p)->lpVtbl->GetTextureQuality(p) +#define IDirect3DRMDevice3_GetDirect3DDevice(p,a) (p)->lpVtbl->GetDirect3DDevice(p,a) +/*** IDirect3DRMDevice2 methods ***/ +#define IDirect3DRMDevice3_InitFromD3D2(p,a,b) (p)->lpVtbl->InitFromD3D2(p,a,b) +#define IDirect3DRMDevice3_InitFromSurface(p,a,b,c) (p)->lpVtbl->InitFromSurface(p,a,b,c) +#define IDirect3DRMDevice3_SetRenderMode(p,a) (p)->lpVtbl->SetRenderMode(p,a) +#define IDirect3DRMDevice3_GetRenderMode(p) (p)->lpVtbl->GetRenderMode(p) +#define IDirect3DRMDevice3_GetDirect3DDevice2(p,a) (p)->lpVtbl->GetDirect3DDevice2(p,a) +/*** IDirect3DRMDevice3 methods ***/ +#define IDirect3DRMDevice3_FindPreferredTextureFormat(p,a,b,c) (p)->lpVtbl->FindPreferredTextureFormat(p,a,b,c) +#define IDirect3DRMDevice3_RenderStateChange(p,a,b,c) (p)->lpVtbl->RenderStateChange(p,a,b,c) +#define IDirect3DRMDevice3_LightStateChange(p,a,b,c) (p)->lpVtbl->LightStateChange(p,a,b,c) +#define IDirect3DRMDevice3_GetStateChangeOptions(p,a,b,c) (p)->lpVtbl->GetStateChangeOptions(p,a,b,c) +#define IDirect3DRMDevice3_SetStateChangeOptions(p,a,b,c) (p)->lpVtbl->SetStateChangeOptions(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMDevice3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMDevice3_AddRef(p) (p)->AddRef() +#define IDirect3DRMDevice3_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMDevice3_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMDevice3_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMDevice3_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMDevice3_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMDevice3_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMDevice3_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMDevice3_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMDevice3_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMDevice methods ***/ +#define IDirect3DRMDevice3_Init(p,a,b) (p)->Init(a,b) +#define IDirect3DRMDevice3_InitFromD3D(p,a,b) (p)->InitFromD3D(a,b) +#define IDirect3DRMDevice3_InitFromClipper(p,a,b,c,d) (p)->InitFromClipper(a,b,c,d) +#define IDirect3DRMDevice3_Update(p) (p)->Update() +#define IDirect3DRMDevice3_AddUpdateCallback(p,a,b) (p)->AddUpdateCallback(a,b) +#define IDirect3DRMDevice3_DeleteUpdateCallback(p,a,b) (p)->DeleteUpdateCallback(a,b) +#define IDirect3DRMDevice3_SetBufferCount(p,a) (p)->SetBufferCount(a) +#define IDirect3DRMDevice3_GetBufferCount(p) (p)->GetBufferCount() +#define IDirect3DRMDevice3_SetDither(p,a) (p)->SetDither(a) +#define IDirect3DRMDevice3_SetShades(p,a) (p)->SetShades(a) +#define IDirect3DRMDevice3_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMDevice3_SetTextureQuality(p,a) (p)->SetTextureQuality(a) +#define IDirect3DRMDevice3_GetViewports(p,a) (p)->GetViewports(a) +#define IDirect3DRMDevice3_GetDither(p) (p)->GetDither() +#define IDirect3DRMDevice3_GetShades(p) (p)->GetShades() +#define IDirect3DRMDevice3_GetHeight(p) (p)->GetHeight() +#define IDirect3DRMDevice3_GetWidth(p) (p)->GetWidth() +#define IDirect3DRMDevice3_GetTrianglesDrawn(p) (p)->GetTrianglesDrawn() +#define IDirect3DRMDevice3_GetWireframeOptions(p) (p)->GetWireframeOptions() +#define IDirect3DRMDevice3_GetQuality(p) (p)->GetQuality() +#define IDirect3DRMDevice3_GetColorModel(p) (p)->GetColorModel() +#define IDirect3DRMDevice3_GetTextureQuality(p) (p)->GetTextureQuality() +#define IDirect3DRMDevice3_GetDirect3DDevice(p,a) (p)->GetDirect3DDevice(a) +/*** IDirect3DRMDevice2 methods ***/ +#define IDirect3DRMDevice3_InitFromD3D2(p,a,b) (p)->InitFromD3D2(a,b) +#define IDirect3DRMDevice3_InitFromSurface(p,a,b,c) (p)->InitFromSurface(a,b,c) +#define IDirect3DRMDevice3_SetRenderMode(p,a) (p)->SetRenderMode(a) +#define IDirect3DRMDevice3_GetRenderMode(p) (p)->GetRenderMode() +#define IDirect3DRMDevice3_GetDirect3DDevice2(p,a) (p)->GetDirect3DDevice2(a) +/*** IDirect3DRMDevice3 methods ***/ +#define IDirect3DRMDevice3_FindPreferredTextureFormat(p,a,b,c) (p)->FindPreferredTextureFormat(a,b,c) +#define IDirect3DRMDevice3_RenderStateChange(p,a,b,c) (p)->RenderStateChange(a,b,c) +#define IDirect3DRMDevice3_LightStateChange(p,a,b,c) (p)->LightStateChange(a,b,c) +#define IDirect3DRMDevice3_GetStateChangeOptions(p,a,b,c) (p)->GetStateChangeOptions(a,b,c) +#define IDirect3DRMDevice3_SetStateChangeOptions(p,a,b,c) (p)->SetStateChangeOptions(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DRMViewport interface + */ +#define INTERFACE IDirect3DRMViewport +DECLARE_INTERFACE_(IDirect3DRMViewport,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMViewport methods ***/ + STDMETHOD(Init) (THIS_ IDirect3DRMDevice *device, struct IDirect3DRMFrame *camera, + DWORD x, DWORD y, DWORD width, DWORD height) PURE; + STDMETHOD(Clear)(THIS) PURE; + STDMETHOD(Render)(THIS_ struct IDirect3DRMFrame *frame) PURE; + STDMETHOD(SetFront)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetBack)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetField)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetUniformScaling)(THIS_ BOOL) PURE; + STDMETHOD(SetCamera)(THIS_ struct IDirect3DRMFrame *camera) PURE; + STDMETHOD(SetProjection)(THIS_ D3DRMPROJECTIONTYPE) PURE; + STDMETHOD(Transform)(THIS_ D3DRMVECTOR4D *d, D3DVECTOR *s) PURE; + STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DRMVECTOR4D *s) PURE; + STDMETHOD(Configure)(THIS_ LONG x, LONG y, DWORD width, DWORD height) PURE; + STDMETHOD(ForceUpdate)(THIS_ DWORD x1, DWORD y1, DWORD x2, DWORD y2) PURE; + STDMETHOD(SetPlane)(THIS_ D3DVALUE left, D3DVALUE right, D3DVALUE bottom, D3DVALUE top) PURE; + STDMETHOD(GetCamera)(THIS_ struct IDirect3DRMFrame **camera) PURE; + STDMETHOD(GetDevice)(THIS_ IDirect3DRMDevice **device) PURE; + STDMETHOD(GetPlane)(THIS_ D3DVALUE *left, D3DVALUE *right, D3DVALUE *bottom, D3DVALUE *top) PURE; + STDMETHOD(Pick)(THIS_ LONG x, LONG y, struct IDirect3DRMPickedArray **visuals) PURE; + STDMETHOD_(BOOL, GetUniformScaling)(THIS) PURE; + STDMETHOD_(LONG, GetX)(THIS) PURE; + STDMETHOD_(LONG, GetY)(THIS) PURE; + STDMETHOD_(DWORD, GetWidth)(THIS) PURE; + STDMETHOD_(DWORD, GetHeight)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetField)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetBack)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetFront)(THIS) PURE; + STDMETHOD_(D3DRMPROJECTIONTYPE, GetProjection)(THIS) PURE; + STDMETHOD(GetDirect3DViewport)(THIS_ IDirect3DViewport **viewport) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMViewport_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMViewport_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMViewport_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMViewport_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMViewport_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMViewport_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMViewport_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMViewport_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMViewport_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMViewport_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMViewport_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMViewport methods ***/ +#define IDirect3DRMViewport_Init(p,a,b,c,d,e,f) (p)->lpVtbl->Init(p,a,b,c,d,e,f) +#define IDirect3DRMViewport_Clear(p) (p)->lpVtbl->Clear(p) +#define IDirect3DRMViewport_Render(p,a) (p)->lpVtbl->Render(p,a) +#define IDirect3DRMViewport_SetFront(p,a) (p)->lpVtbl->SetFront(p,a) +#define IDirect3DRMViewport_SetBack(p,a) (p)->lpVtbl->SetBack(p,a) +#define IDirect3DRMViewport_SetField(p,a) (p)->lpVtbl->SetField(p,a) +#define IDirect3DRMViewport_SetUniformScaling(p,a) (p)->lpVtbl->SetUniformScaling(p,a) +#define IDirect3DRMViewport_SetCamera(p,a) (p)->lpVtbl->SetCamera(p,a) +#define IDirect3DRMViewport_SetProjection(p,a) (p)->lpVtbl->SetProjection(p,a) +#define IDirect3DRMViewport_Transform(p,a,b) (p)->lpVtbl->Transform(p,a,b) +#define IDirect3DRMViewport_InverseTransform(p,a,b) (p)->lpVtbl->InverseTransform(p,a,b) +#define IDirect3DRMViewport_Configure(p,a,b,c,d) (p)->lpVtbl->Configure(p,a,b,c,d) +#define IDirect3DRMViewport_ForceUpdate(p,a,b,c,d) (p)->lpVtbl->ForceUpdate(p,a,b,c,d) +#define IDirect3DRMViewport_SetPlane(p,a,b,c,d) (p)->lpVtbl->SetPlane(p,a,b,c,d) +#define IDirect3DRMViewport_GetCamera(p,a) (p)->lpVtbl->GetCamera(p,a) +#define IDirect3DRMViewport_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DRMViewport_GetPlane(p,a,b,c,d) (p)->lpVtbl->GetPlane(p,a,b,c,d) +#define IDirect3DRMViewport_Pick(p,a,b,c) (p)->lpVtbl->Pick(p,a,b,c) +#define IDirect3DRMViewport_GetUniformScaling(p) (p)->lpVtbl->GetUniformScaling(p) +#define IDirect3DRMViewport_GetX(p) (p)->lpVtbl->GetX(p) +#define IDirect3DRMViewport_GetY(p) (p)->lpVtbl->GetY(p) +#define IDirect3DRMViewport_GetWidth(p) (p)->lpVtbl->GetWidth(p) +#define IDirect3DRMViewport_GetHeight(p) (p)->lpVtbl->GetHeight(p) +#define IDirect3DRMViewport_GetField(p) (p)->lpVtbl->GetField(p) +#define IDirect3DRMViewport_GetBack(p) (p)->lpVtbl->GetBack(p) +#define IDirect3DRMViewport_GetFront(p) (p)->lpVtbl->GetFront(p) +#define IDirect3DRMViewport_GetProjection(p) (p)->lpVtbl->GetProjection(p) +#define IDirect3DRMViewport_GetDirect3DViewport(p,a) (p)->lpVtbl->GetDirect3DViewport(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMViewport_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMViewport_AddRef(p) (p)->AddRef() +#define IDirect3DRMViewport_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMViewport_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMViewport_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMViewport_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMViewport_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMViewport_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMViewport_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMViewport_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMViewport_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMViewport methods ***/ +#define IDirect3DRMViewport_Init(p,a,b,c,d,e,f) (p)->Init(a,b,c,d,e,f) +#define IDirect3DRMViewport_Clear(p) (p)->Clear() +#define IDirect3DRMViewport_Render(p,a) (p)->Render(a) +#define IDirect3DRMViewport_SetFront(p,a) (p)->SetFront(a) +#define IDirect3DRMViewport_SetBack(p,a) (p)->SetBack(a) +#define IDirect3DRMViewport_SetField(p,a) (p)->SetField(a) +#define IDirect3DRMViewport_SetUniformScaling(p,a) (p)->SetUniformScaling(a) +#define IDirect3DRMViewport_SetCamera(p,a) (p)->SetCamera(a) +#define IDirect3DRMViewport_SetProjection(p,a) (p)->SetProjection(a) +#define IDirect3DRMViewport_Transform(p,a,b) (p)->Transform(a,b) +#define IDirect3DRMViewport_InverseTransform(p,a,b) (p)->InverseTransform(a,b) +#define IDirect3DRMViewport_Configure(p,a,b,c,d) (p)->Configure(a,b,c,d) +#define IDirect3DRMViewport_ForceUpdate(p,a,b,c,d) (p)->ForceUpdate(a,b,c,d) +#define IDirect3DRMViewport_SetPlane(p,a,b,c,d) (p)->SetPlane(a,b,c,d) +#define IDirect3DRMViewport_GetCamera(p,a) (p)->GetCamera(a) +#define IDirect3DRMViewport_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DRMViewport_GetPlane(p,a,b,c,d) (p)->GetPlane(a,b,c,d) +#define IDirect3DRMViewport_Pick(p,a,b,c) (p)->Pick(a,b,c) +#define IDirect3DRMViewport_GetUniformScaling(p) (p)->GetUniformScaling() +#define IDirect3DRMViewport_GetX(p) (p)->GetX() +#define IDirect3DRMViewport_GetY(p) (p)->GetY() +#define IDirect3DRMViewport_GetWidth(p) (p)->GetWidth() +#define IDirect3DRMViewport_GetHeight(p) (p)->GetHeight() +#define IDirect3DRMViewport_GetField(p) (p)->GetField() +#define IDirect3DRMViewport_GetBack(p) (p)->GetBack() +#define IDirect3DRMViewport_GetFront(p) (p)->GetFront() +#define IDirect3DRMViewport_GetProjection(p) (p)->GetProjection() +#define IDirect3DRMViewport_GetDirect3DViewport(p,a) (p)->GetDirect3DViewport(a) +#endif + +/***************************************************************************** + * IDirect3DRMViewport2 interface + */ +#define INTERFACE IDirect3DRMViewport2 +DECLARE_INTERFACE_(IDirect3DRMViewport2,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMViewport2 methods ***/ + STDMETHOD(Init) (THIS_ IDirect3DRMDevice3 *device, struct IDirect3DRMFrame3 *camera, + DWORD x, DWORD y, DWORD width, DWORD height) PURE; + STDMETHOD(Clear)(THIS_ DWORD flags) PURE; + STDMETHOD(Render)(THIS_ struct IDirect3DRMFrame3 *frame) PURE; + STDMETHOD(SetFront)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetBack)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetField)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetUniformScaling)(THIS_ BOOL) PURE; + STDMETHOD(SetCamera)(THIS_ struct IDirect3DRMFrame3 *camera) PURE; + STDMETHOD(SetProjection)(THIS_ D3DRMPROJECTIONTYPE) PURE; + STDMETHOD(Transform)(THIS_ D3DRMVECTOR4D *d, D3DVECTOR *s) PURE; + STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DRMVECTOR4D *s) PURE; + STDMETHOD(Configure)(THIS_ LONG x, LONG y, DWORD width, DWORD height) PURE; + STDMETHOD(ForceUpdate)(THIS_ DWORD x1, DWORD y1, DWORD x2, DWORD y2) PURE; + STDMETHOD(SetPlane)(THIS_ D3DVALUE left, D3DVALUE right, D3DVALUE bottom, D3DVALUE top) PURE; + STDMETHOD(GetCamera)(THIS_ struct IDirect3DRMFrame3 **camera) PURE; + STDMETHOD(GetDevice)(THIS_ IDirect3DRMDevice3 **device) PURE; + STDMETHOD(GetPlane)(THIS_ D3DVALUE *left, D3DVALUE *right, D3DVALUE *bottom, D3DVALUE *top) PURE; + STDMETHOD(Pick)(THIS_ LONG x, LONG y, struct IDirect3DRMPickedArray **visuals) PURE; + STDMETHOD_(BOOL, GetUniformScaling)(THIS) PURE; + STDMETHOD_(LONG, GetX)(THIS) PURE; + STDMETHOD_(LONG, GetY)(THIS) PURE; + STDMETHOD_(DWORD, GetWidth)(THIS) PURE; + STDMETHOD_(DWORD, GetHeight)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetField)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetBack)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetFront)(THIS) PURE; + STDMETHOD_(D3DRMPROJECTIONTYPE, GetProjection)(THIS) PURE; + STDMETHOD(GetDirect3DViewport)(THIS_ IDirect3DViewport **viewport) PURE; + STDMETHOD(TransformVectors)(THIS_ DWORD vector_count, D3DRMVECTOR4D *dst_vectors, + D3DVECTOR *src_vectors) PURE; + STDMETHOD(InverseTransformVectors)(THIS_ DWORD vector_count, D3DVECTOR *dst_vectors, + D3DRMVECTOR4D *src_vectors) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMViewport2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMViewport2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMViewport2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMViewport2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMViewport2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMViewport2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMViewport2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMViewport2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMViewport2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMViewport2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMViewport2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMViewport2 methods ***/ +#define IDirect3DRMViewport2_Init(p,a,b,c,d,e,f) (p)->lpVtbl->Init(p,a,b,c,d,e,f) +#define IDirect3DRMViewport2_Clear(p,a) (p)->lpVtbl->Clear(p,a) +#define IDirect3DRMViewport2_Render(p,a) (p)->lpVtbl->Render(p,a) +#define IDirect3DRMViewport2_SetFront(p,a) (p)->lpVtbl->SetFront(p,a) +#define IDirect3DRMViewport2_SetBack(p,a) (p)->lpVtbl->SetBack(p,a) +#define IDirect3DRMViewport2_SetField(p,a) (p)->lpVtbl->SetField(p,a) +#define IDirect3DRMViewport2_SetUniformScaling(p,a) (p)->lpVtbl->SetUniformScaling(p,a) +#define IDirect3DRMViewport2_SetCamera(p,a) (p)->lpVtbl->SetCamera(p,a) +#define IDirect3DRMViewport2_SetProjection(p,a) (p)->lpVtbl->SetProjection(p,a) +#define IDirect3DRMViewport2_Transform(p,a,b) (p)->lpVtbl->Transform(p,a,b) +#define IDirect3DRMViewport2_InverseTransform(p,a,b) (p)->lpVtbl->InverseTransform(p,a,b) +#define IDirect3DRMViewport2_Configure(p,a,b,c,d) (p)->lpVtbl->Configure(p,a,b,c,d) +#define IDirect3DRMViewport2_ForceUpdate(p,a,b,c,d) (p)->lpVtbl->ForceUpdate(p,a,b,c,d) +#define IDirect3DRMViewport2_SetPlane(p,a,b,c,d) (p)->lpVtbl->SetPlane(p,a,b,c,d) +#define IDirect3DRMViewport2_GetCamera(p,a) (p)->lpVtbl->GetCamera(p,a) +#define IDirect3DRMViewport2_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DRMViewport2_GetPlane(p,a,b,c,d) (p)->lpVtbl->GetPlane(p,a,b,c,d) +#define IDirect3DRMViewport2_Pick(p,a,b,c) (p)->lpVtbl->Pick(p,a,b,c) +#define IDirect3DRMViewport2_GetUniformScaling(p) (p)->lpVtbl->GetUniformScaling(p) +#define IDirect3DRMViewport2_GetX(p) (p)->lpVtbl->GetX(p) +#define IDirect3DRMViewport2_GetY(p) (p)->lpVtbl->GetY(p) +#define IDirect3DRMViewport2_GetWidth(p) (p)->lpVtbl->GetWidth(p) +#define IDirect3DRMViewport2_GetHeight(p) (p)->lpVtbl->GetHeight(p) +#define IDirect3DRMViewport2_GetField(p) (p)->lpVtbl->GetField(p) +#define IDirect3DRMViewport2_GetBack(p) (p)->lpVtbl->GetBack(p) +#define IDirect3DRMViewport2_GetFront(p) (p)->lpVtbl->GetFront(p) +#define IDirect3DRMViewport2_GetProjection(p) (p)->lpVtbl->GetProjection(p) +#define IDirect3DRMViewport2_GetDirect3DViewport(p,a) (p)->lpVtbl->GetDirect3DViewport(p,a) +#define IDirect3DRMViewport2_TransformVectors(p,a,b,c) (p)->lpVtbl->TransformVectors(p,a,b,c) +#define IDirect3DRMViewport2_InverseTransformVectors(p,a,b,c) (p)->lpVtbl->InverseTransformVectors(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMViewport2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMViewport2_AddRef(p) (p)->AddRef() +#define IDirect3DRMViewport2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMViewport2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMViewport2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMViewport2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMViewport2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMViewport2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMViewport2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMViewport2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMViewport2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMViewport2 methods ***/ +#define IDirect3DRMViewport2_Init(p,a,b,c,d,e,f) (p)->Init(a,b,c,d,e,f) +#define IDirect3DRMViewport2_Clear(p) (p)->Clear() +#define IDirect3DRMViewport2_Render(p,a) (p)->Render(a) +#define IDirect3DRMViewport2_SetFront(p,a) (p)->SetFront(a) +#define IDirect3DRMViewport2_SetBack(p,a) (p)->SetBack(a) +#define IDirect3DRMViewport2_SetField(p,a) (p)->SetField(a) +#define IDirect3DRMViewport2_SetUniformScaling(p,a) (p)->SetUniformScaling(a) +#define IDirect3DRMViewport2_SetCamera(p,a) (p)->SetCamera(a) +#define IDirect3DRMViewport2_SetProjection(p,a) (p)->SetProjection(a) +#define IDirect3DRMViewport2_Transform(p,a,b) (p)->Transform(a,b) +#define IDirect3DRMViewport2_InverseTransform(p,a,b) (p)->InverseTransform(a,b) +#define IDirect3DRMViewport2_Configure(p,a,b,c,d) (p)->Configure(a,b,c,d) +#define IDirect3DRMViewport2_ForceUpdate(p,a,b,c,d) (p)->ForceUpdate(a,b,c,d) +#define IDirect3DRMViewport2_SetPlane(p,a,b,c,d) (p)->SetPlane(a,b,c,d) +#define IDirect3DRMViewport2_GetCamera(p,a) (p)->GetCamera(a) +#define IDirect3DRMViewport2_GetDevice(p,a) (p)->GetDevice(a) +#define IDirect3DRMViewport2_GetPlane(p,a,b,c,d) (p)->GetPlane(a,b,c,d) +#define IDirect3DRMViewport2_Pick(p,a,b,c) (p)->Pick(a,b,c) +#define IDirect3DRMViewport2_GetUniformScaling(p) (p)->GetUniformScaling() +#define IDirect3DRMViewport2_GetX(p) (p)->GetX() +#define IDirect3DRMViewport2_GetY(p) (p)->GetY() +#define IDirect3DRMViewport2_GetWidth(p) (p)->GetWidth() +#define IDirect3DRMViewport2_GetHeight(p) (p)->GetHeight() +#define IDirect3DRMViewport2_GetField(p) (p)->GetField() +#define IDirect3DRMViewport2_GetBack(p) (p)->GetBack() +#define IDirect3DRMViewport2_GetFront(p) (p)->GetFront() +#define IDirect3DRMViewport2_GetProjection(p) (p)->GetProjection() +#define IDirect3DRMViewport2_GetDirect3DViewport(p,a) (p)->GetDirect3DViewport(a) +#define IDirect3DRMViewport2_TransformVectors(p,a,b,c) (p)->TransformVectors(a,b,c) +#define IDirect3DRMViewport2_InverseTransformVectors(p,a,b,c) (p)->InverseTransformVectors(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DRMFrame interface + */ +#define INTERFACE IDirect3DRMFrame +DECLARE_INTERFACE_(IDirect3DRMFrame,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMFrame methods ***/ + STDMETHOD(AddChild)(THIS_ IDirect3DRMFrame *child) PURE; + STDMETHOD(AddLight)(THIS_ struct IDirect3DRMLight *light) PURE; + STDMETHOD(AddMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK cb, void *ctx) PURE; + STDMETHOD(AddTransform)(THIS_ D3DRMCOMBINETYPE, D3DRMMATRIX4D) PURE; + STDMETHOD(AddTranslation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddScale)(THIS_ D3DRMCOMBINETYPE, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(AddRotation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE; + STDMETHOD(AddVisual)(THIS_ IDirect3DRMVisual *visual) PURE; + STDMETHOD(GetChildren)(THIS_ struct IDirect3DRMFrameArray **children) PURE; + STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE; + STDMETHOD(GetLights)(THIS_ struct IDirect3DRMLightArray **lights) PURE; + STDMETHOD_(D3DRMMATERIALMODE, GetMaterialMode)(THIS) PURE; + STDMETHOD(GetParent)(THIS_ IDirect3DRMFrame **parent) PURE; + STDMETHOD(GetPosition)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *return_position) PURE; + STDMETHOD(GetRotation)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *return_theta) PURE; + STDMETHOD(GetScene)(THIS_ IDirect3DRMFrame **scene) PURE; + STDMETHOD_(D3DRMSORTMODE, GetSortMode)(THIS) PURE; + STDMETHOD(GetTexture)(THIS_ struct IDirect3DRMTexture **texture) PURE; + STDMETHOD(GetTransform)(THIS_ D3DRMMATRIX4D return_matrix) PURE; + STDMETHOD(GetVelocity)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *return_velocity, BOOL with_rotation) PURE; + STDMETHOD(GetOrientation)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up) PURE; + STDMETHOD(GetVisuals)(THIS_ struct IDirect3DRMVisualArray **visuals) PURE; + STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE; + STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE; + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURECALLBACK cb, void *ctx)PURE; + STDMETHOD(LookAt)(THIS_ IDirect3DRMFrame *target, IDirect3DRMFrame *reference, + D3DRMFRAMECONSTRAINT constraint) PURE; + STDMETHOD(Move)(THIS_ D3DVALUE delta) PURE; + STDMETHOD(DeleteChild)(THIS_ IDirect3DRMFrame *child) PURE; + STDMETHOD(DeleteLight)(THIS_ struct IDirect3DRMLight *light) PURE; + STDMETHOD(DeleteMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteVisual)(THIS_ IDirect3DRMVisual *visual) PURE; + STDMETHOD_(D3DCOLOR, GetSceneBackground)(THIS) PURE; + STDMETHOD(GetSceneBackgroundDepth)(THIS_ IDirectDrawSurface **surface) PURE; + STDMETHOD_(D3DCOLOR, GetSceneFogColor)(THIS) PURE; + STDMETHOD_(BOOL, GetSceneFogEnable)(THIS) PURE; + STDMETHOD_(D3DRMFOGMODE, GetSceneFogMode)(THIS) PURE; + STDMETHOD(GetSceneFogParams)(THIS_ D3DVALUE *return_start, D3DVALUE *return_end, D3DVALUE *return_density) PURE; + STDMETHOD(SetSceneBackground)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetSceneBackgroundRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetSceneBackgroundDepth)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(SetSceneBackgroundImage)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetSceneFogEnable)(THIS_ BOOL) PURE; + STDMETHOD(SetSceneFogColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetSceneFogMode)(THIS_ D3DRMFOGMODE) PURE; + STDMETHOD(SetSceneFogParams)(THIS_ D3DVALUE start, D3DVALUE end, D3DVALUE density) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD_(D3DRMZBUFFERMODE, GetZbufferMode)(THIS) PURE; + STDMETHOD(SetMaterialMode)(THIS_ D3DRMMATERIALMODE) PURE; + STDMETHOD(SetOrientation)(THIS_ IDirect3DRMFrame *reference, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, + D3DVALUE ux, D3DVALUE uy, D3DVALUE uz) PURE; + STDMETHOD(SetPosition)(THIS_ IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetRotation)(THIS_ IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE; + STDMETHOD(SetSortMode)(THIS_ D3DRMSORTMODE) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(SetVelocity)(THIS_ IDirect3DRMFrame *reference, + D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation) PURE; + STDMETHOD(SetZbufferMode)(THIS_ D3DRMZBUFFERMODE) PURE; + STDMETHOD(Transform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFrame_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFrame_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFrame_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFrame_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMFrame_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMFrame_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMFrame_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMFrame_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMFrame_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMFrame_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMFrame_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMFrame methods ***/ +#define IDirect3DRMFrame_AddChild(p,a) (p)->lpVtbl->AddChild(p,a) +#define IDirect3DRMFrame_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DRMFrame_AddMoveCallback(p,a,b) (p)->lpVtbl->AddMoveCallback(p,a,b) +#define IDirect3DRMFrame_AddTransform(p,a,b) (p)->lpVtbl->AddTransform(p,a,b) +#define IDirect3DRMFrame_AddTranslation(p,a,b,c,d) (p)->lpVtbl->AddTranslation(p,a,b,c,d) +#define IDirect3DRMFrame_AddScale(p,a,b,c,d) (p)->lpVtbl->AddScale(p,a,b,c,d) +#define IDirect3DRMFrame_AddRotation(p,a,b,c,d,e) (p)->lpVtbl->AddRotation(p,a,b,c,d,e) +#define IDirect3DRMFrame_AddVisual(p,a) (p)->lpVtbl->AddVisual(p,a) +#define IDirect3DRMFrame_GetChildren(p,a) (p)->lpVtbl->GetChildren(p,a) +#define IDirect3DRMFrame_GetColor(p) (p)->lpVtbl->GetColor(p) +#define IDirect3DRMFrame_GetLights(p,a) (p)->lpVtbl->GetLights(p,a) +#define IDirect3DRMFrame_GetMaterialMode(p) (p)->lpVtbl->GetMaterialMode(p) +#define IDirect3DRMFrame_GetParent(p,a) (p)->lpVtbl->GetParent(p,a) +#define IDirect3DRMFrame_GetPosition(p,a,b) (p)->lpVtbl->GetPosition(p,a,b) +#define IDirect3DRMFrame_GetRotation(p,a,b,c) (p)->lpVtbl->GetRotation(p,a,b,c) +#define IDirect3DRMFrame_GetScene(p,a) (p)->lpVtbl->GetScene(p,a) +#define IDirect3DRMFrame_GetSortMode(p) (p)->lpVtbl->GetSortMode(p) +#define IDirect3DRMFrame_GetTexture(p,a) (p)->lpVtbl->GetTexture(p,a) +#define IDirect3DRMFrame_GetTransform(p,a) (p)->lpVtbl->GetTransform(p,a) +#define IDirect3DRMFrame_GetVelocity(p,a,b,c) (p)->lpVtbl->GetVelocity(p,a,b,c) +#define IDirect3DRMFrame_GetOrientation(p,a,b,c) (p)->lpVtbl->GetOrientation(p,a,b,c) +#define IDirect3DRMFrame_GetVisuals(p,a) (p)->lpVtbl->GetVisuals(p,a) +#define IDirect3DRMFrame_GetTextureTopology(p,a,b) (p)->lpVtbl->GetTextureTopology(p,a,b) +#define IDirect3DRMFrame_InverseTransform(p,a,b) (p)->lpVtbl->InverseTransform(p,a,b) +#define IDirect3DRMFrame_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMFrame_LookAt(p,a,b,c) (p)->lpVtbl->LookAt(p,a,b,c) +#define IDirect3DRMFrame_Move(p,a) (p)->lpVtbl->Move(p,a) +#define IDirect3DRMFrame_DeleteChild(p,a) (p)->lpVtbl->DeleteChild(p,a) +#define IDirect3DRMFrame_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DRMFrame_DeleteMoveCallback(p,a,b) (p)->lpVtbl->DeleteMoveCallback(p,a,b) +#define IDirect3DRMFrame_DeleteVisual(p,a) (p)->lpVtbl->DeleteVisual(p,a) +#define IDirect3DRMFrame_GetSceneBackground(p) (p)->lpVtbl->GetSceneBackground(p) +#define IDirect3DRMFrame_GetSceneBackgroundDepth(p,a) (p)->lpVtbl->GetSceneBackgroundDepth(p,a) +#define IDirect3DRMFrame_GetSceneFogColor(p) (p)->lpVtbl->GetSceneFogColor(p) +#define IDirect3DRMFrame_GetSceneFogEnable(p) (p)->lpVtbl->GetSceneFogEnable(p) +#define IDirect3DRMFrame_GetSceneFogMode(p) (p)->lpVtbl->GetSceneFogMode(p) +#define IDirect3DRMFrame_GetSceneFogParams(p,a,b,c) (p)->lpVtbl->GetSceneFogParams(p,a,b,c) +#define IDirect3DRMFrame_SetSceneBackground(p,a) (p)->lpVtbl->SetSceneBackground(p,a) +#define IDirect3DRMFrame_SetSceneBackgroundRGB(p,a,b,c) (p)->lpVtbl->SetSceneBackgroundRGB(p,a,b,c) +#define IDirect3DRMFrame_SetSceneBackgroundDepth(p,a) (p)->lpVtbl->SetSceneBackgroundDepth(p,a) +#define IDirect3DRMFrame_SetSceneBackgroundImage(p,a) (p)->lpVtbl->SetSceneBackgroundImage(p,a) +#define IDirect3DRMFrame_SetSceneFogEnable(p,a) (p)->lpVtbl->SetSceneFogEnable(p,a) +#define IDirect3DRMFrame_SetSceneFogColor(p,a) (p)->lpVtbl->SetSceneFogColor(p,a) +#define IDirect3DRMFrame_SetSceneFogMode(p,a) (p)->lpVtbl->SetSceneFogMode(p,a) +#define IDirect3DRMFrame_SetSceneFogParams(p,a,b,c) (p)->lpVtbl->SetSceneFogParams(p,a,b,c) +#define IDirect3DRMFrame_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMFrame_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMFrame_GetZbufferMode(p) (p)->lpVtbl->GetZbufferMode(p) +#define IDirect3DRMFrame_SetMaterialMode(p,a) (p)->lpVtbl->SetMaterialMode(p,a) +#define IDirect3DRMFrame_SetOrientation(p,a,b,c,d,e,f,g) (p)->lpVtbl->SetOrientation(p,a,b,c,d,e,f,g) +#define IDirect3DRMFrame_SetPosition(p,a,b,c,d) (p)->lpVtbl->SetPosition(p,a,b,c,d) +#define IDirect3DRMFrame_SetRotation(p,a,b,c,d,e) (p)->lpVtbl->SetRotation(p,a,b,c,d,e) +#define IDirect3DRMFrame_SetSortMode(p,a) (p)->lpVtbl->SetSortMode(p,a) +#define IDirect3DRMFrame_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMFrame_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMFrame_SetVelocity(p,a,b,c,d,e) (p)->lpVtbl->SetVelocity(p,a,b,c,d,e) +#define IDirect3DRMFrame_SetZbufferMode(p,a) (p)->lpVtbl->SetZbufferMode(p,a) +#define IDirect3DRMFrame_Transform(p,a,b) (p)->lpVtbl->Transform(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFrame_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFrame_AddRef(p) (p)->AddRef() +#define IDirect3DRMFrame_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFrame_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMFrame_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMFrame_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMFrame_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMFrame_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMFrame_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMFrame_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMFrame_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMFrame methods ***/ +#define IDirect3DRMFrame_AddChild(p,a) (p)->AddChild(a) +#define IDirect3DRMFrame_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DRMFrame_AddMoveCallback(p,a,b) (p)->AddMoveCallback(a,b) +#define IDirect3DRMFrame_AddTransform(p,a,b) (p)->AddTransform(a,b) +#define IDirect3DRMFrame_AddTranslation(p,a,b,c,d) (p)->AddTranslation(a,b,c,d) +#define IDirect3DRMFrame_AddScale(p,a,b,c,d) (p)->AddScale(a,b,c,d) +#define IDirect3DRMFrame_AddRotation(p,a,b,c,d,e) (p)->AddRotation(a,b,c,d,e) +#define IDirect3DRMFrame_AddVisual(p,a) (p)->AddVisual(a) +#define IDirect3DRMFrame_GetChildren(p,a) (p)->GetChildren(a) +#define IDirect3DRMFrame_GetColor(p) (p)->GetColor() +#define IDirect3DRMFrame_GetLights(p,a) (p)->GetLights(a) +#define IDirect3DRMFrame_GetMaterialMode(p) (p)->GetMaterialMode() +#define IDirect3DRMFrame_GetParent(p,a) (p)->GetParent(a) +#define IDirect3DRMFrame_GetPosition(p,a,b) (p)->GetPosition(a,b) +#define IDirect3DRMFrame_GetRotation(p,a,b,c) (p)->GetRotation(a,b,c) +#define IDirect3DRMFrame_GetScene(p,a) (p)->GetScene(a) +#define IDirect3DRMFrame_GetSortMode(p) (p)->GetSortMode() +#define IDirect3DRMFrame_GetTexture(p,a) (p)->GetTexture(a) +#define IDirect3DRMFrame_GetTransform(p,a) (p)->GetTransform(a) +#define IDirect3DRMFrame_GetVelocity(p,a,b,c) (p)->GetVelocity(a,b,c) +#define IDirect3DRMFrame_GetOrientation(p,a,b,c) (p)->GetOrientation(a,b,c) +#define IDirect3DRMFrame_GetVisuals(p,a) (p)->GetVisuals(a) +#define IDirect3DRMFrame_GetTextureTopology(p,a,b) (p)->GetTextureTopology(a,b) +#define IDirect3DRMFrame_InverseTransform(p,a,b) (p)->InverseTransform(a,b) +#define IDirect3DRMFrame_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMFrame_LookAt(p,a,b,c) (p)->LookAt(a,b,c) +#define IDirect3DRMFrame_Move(p,a) (p)->Move(a) +#define IDirect3DRMFrame_DeleteChild(p,a) (p)->DeleteChild(a) +#define IDirect3DRMFrame_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DRMFrame_DeleteMoveCallback(p,a,b) (p)->DeleteMoveCallback(a,b) +#define IDirect3DRMFrame_DeleteVisual(p,a) (p)->DeleteVisual(a) +#define IDirect3DRMFrame_GetSceneBackground(p) (p)->GetSceneBackground() +#define IDirect3DRMFrame_GetSceneBackgroundDepth(p,a) (p)->GetSceneBackgroundDepth(a) +#define IDirect3DRMFrame_GetSceneFogColor(p) (p)->GetSceneFogColor() +#define IDirect3DRMFrame_GetSceneFogEnable(p) (p)->GetSceneFogEnable() +#define IDirect3DRMFrame_GetSceneFogMode(p) (p)->GetSceneFogMode() +#define IDirect3DRMFrame_GetSceneFogParams(p,a,b,c) (p)->GetSceneFogParams(a,b,c) +#define IDirect3DRMFrame_SetSceneBackground(p,a) (p)->SetSceneBackground(a) +#define IDirect3DRMFrame_SetSceneBackgroundRGB(p,a,b,c) (p)->SetSceneBackgroundRGB(a,b,c) +#define IDirect3DRMFrame_SetSceneBackgroundDepth(p,a) (p)->SetSceneBackgroundDepth(a) +#define IDirect3DRMFrame_SetSceneBackgroundImage(p,a) (p)->SetSceneBackgroundImage(a) +#define IDirect3DRMFrame_SetSceneFogEnable(p,a) (p)->SetSceneFogEnable(a) +#define IDirect3DRMFrame_SetSceneFogColor(p,a) (p)->SetSceneFogColor(a) +#define IDirect3DRMFrame_SetSceneFogMode(p,a) (p)->SetSceneFogMode(a) +#define IDirect3DRMFrame_SetSceneFogParams(p,a,b,c) (p)->SetSceneFogParams(a,b,c) +#define IDirect3DRMFrame_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMFrame_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMFrame_GetZbufferMode(p) (p)->GetZbufferMode() +#define IDirect3DRMFrame_SetMaterialMode(p,a) (p)->SetMaterialMode(a) +#define IDirect3DRMFrame_SetOrientation(p,a,b,c,d,e,f,g) (p)->SetOrientation(a,b,c,d,e,f,g) +#define IDirect3DRMFrame_SetPosition(p,a,b,c,d) (p)->SetPosition(a,b,c,d) +#define IDirect3DRMFrame_SetRotation(p,a,b,c,d,e) (p)->SetRotation(a,b,c,d,e) +#define IDirect3DRMFrame_SetSortMode(p,a) (p)->SetSortMode(a) +#define IDirect3DRMFrame_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMFrame_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMFrame_SetVelocity(p,a,b,c,d,e) (p)->SetVelocity(a,b,c,d,e) +#define IDirect3DRMFrame_SetZbufferMode(p,a) (p)->SetZbufferMode(a) +#define IDirect3DRMFrame_Transform(p,a,b) (p)->Transform(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMFrame2 interface + */ +#define INTERFACE IDirect3DRMFrame2 +DECLARE_INTERFACE_(IDirect3DRMFrame2,IDirect3DRMFrame) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMFrame methods ***/ + STDMETHOD(AddChild)(THIS_ IDirect3DRMFrame *child) PURE; + STDMETHOD(AddLight)(THIS_ struct IDirect3DRMLight *light) PURE; + STDMETHOD(AddMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK cb, void *ctx) PURE; + STDMETHOD(AddTransform)(THIS_ D3DRMCOMBINETYPE, D3DRMMATRIX4D) PURE; + STDMETHOD(AddTranslation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddScale)(THIS_ D3DRMCOMBINETYPE, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(AddRotation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE; + STDMETHOD(AddVisual)(THIS_ IDirect3DRMVisual *visual) PURE; + STDMETHOD(GetChildren)(THIS_ struct IDirect3DRMFrameArray **children) PURE; + STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE; + STDMETHOD(GetLights)(THIS_ struct IDirect3DRMLightArray **lights) PURE; + STDMETHOD_(D3DRMMATERIALMODE, GetMaterialMode)(THIS) PURE; + STDMETHOD(GetParent)(THIS_ IDirect3DRMFrame **parent) PURE; + STDMETHOD(GetPosition)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *return_position) PURE; + STDMETHOD(GetRotation)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *return_theta) PURE; + STDMETHOD(GetScene)(THIS_ IDirect3DRMFrame **scene) PURE; + STDMETHOD_(D3DRMSORTMODE, GetSortMode)(THIS) PURE; + STDMETHOD(GetTexture)(THIS_ struct IDirect3DRMTexture **texture) PURE; + STDMETHOD(GetTransform)(THIS_ D3DRMMATRIX4D return_matrix) PURE; + STDMETHOD(GetVelocity)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *return_velocity, BOOL with_rotation) PURE; + STDMETHOD(GetOrientation)(THIS_ IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up) PURE; + STDMETHOD(GetVisuals)(THIS_ struct IDirect3DRMVisualArray **visuals) PURE; + STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE; + STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE; + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURECALLBACK cb, void *ctx)PURE; + STDMETHOD(LookAt)(THIS_ IDirect3DRMFrame *target, IDirect3DRMFrame *reference, + D3DRMFRAMECONSTRAINT constraint) PURE; + STDMETHOD(Move)(THIS_ D3DVALUE delta) PURE; + STDMETHOD(DeleteChild)(THIS_ IDirect3DRMFrame *child) PURE; + STDMETHOD(DeleteLight)(THIS_ struct IDirect3DRMLight *light) PURE; + STDMETHOD(DeleteMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteVisual)(THIS_ IDirect3DRMVisual *visual) PURE; + STDMETHOD_(D3DCOLOR, GetSceneBackground)(THIS) PURE; + STDMETHOD(GetSceneBackgroundDepth)(THIS_ IDirectDrawSurface **surface) PURE; + STDMETHOD_(D3DCOLOR, GetSceneFogColor)(THIS) PURE; + STDMETHOD_(BOOL, GetSceneFogEnable)(THIS) PURE; + STDMETHOD_(D3DRMFOGMODE, GetSceneFogMode)(THIS) PURE; + STDMETHOD(GetSceneFogParams)(THIS_ D3DVALUE *return_start, D3DVALUE *return_end, D3DVALUE *return_density) PURE; + STDMETHOD(SetSceneBackground)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetSceneBackgroundRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetSceneBackgroundDepth)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(SetSceneBackgroundImage)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetSceneFogEnable)(THIS_ BOOL) PURE; + STDMETHOD(SetSceneFogColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetSceneFogMode)(THIS_ D3DRMFOGMODE) PURE; + STDMETHOD(SetSceneFogParams)(THIS_ D3DVALUE start, D3DVALUE end, D3DVALUE density) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD_(D3DRMZBUFFERMODE, GetZbufferMode)(THIS) PURE; + STDMETHOD(SetMaterialMode)(THIS_ D3DRMMATERIALMODE) PURE; + STDMETHOD(SetOrientation)(THIS_ IDirect3DRMFrame *reference, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, + D3DVALUE ux, D3DVALUE uy, D3DVALUE uz) PURE; + STDMETHOD(SetPosition)(THIS_ IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetRotation)(THIS_ IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE; + STDMETHOD(SetSortMode)(THIS_ D3DRMSORTMODE) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(SetVelocity)(THIS_ IDirect3DRMFrame *reference, + D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation) PURE; + STDMETHOD(SetZbufferMode)(THIS_ D3DRMZBUFFERMODE) PURE; + STDMETHOD(Transform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE; + /*** IDirect3DRMFrame2 methods ***/ + STDMETHOD(AddMoveCallback2)(THIS_ D3DRMFRAMEMOVECALLBACK cb, void *ctx, DWORD flags) PURE; + STDMETHOD(GetBox)(THIS_ D3DRMBOX *box) PURE; + STDMETHOD_(BOOL, GetBoxEnable)(THIS) PURE; + STDMETHOD(GetAxes)(THIS_ D3DVECTOR *dir, D3DVECTOR *up); + STDMETHOD(GetMaterial)(THIS_ struct IDirect3DRMMaterial **material) PURE; + STDMETHOD_(BOOL, GetInheritAxes)(THIS); + STDMETHOD(GetHierarchyBox)(THIS_ D3DRMBOX *box) PURE; + STDMETHOD(SetBox)(THIS_ D3DRMBOX *box) PURE; + STDMETHOD(SetBoxEnable)(THIS_ BOOL) PURE; + STDMETHOD(SetAxes)(THIS_ D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz); + STDMETHOD(SetInheritAxes)(THIS_ BOOL inherit_from_parent); + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial *material) PURE; + STDMETHOD(SetQuaternion)(THIS_ IDirect3DRMFrame *reference, D3DRMQUATERNION *q) PURE; + STDMETHOD(RayPick)(THIS_ IDirect3DRMFrame *reference, D3DRMRAY *ray, DWORD flags, + struct IDirect3DRMPicked2Array **return_visuals) PURE; + STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags); +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFrame2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFrame2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFrame2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFrame2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMFrame2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMFrame2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMFrame2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMFrame2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMFrame2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMFrame2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMFrame2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMFrame methods ***/ +#define IDirect3DRMFrame2_AddChild(p,a) (p)->lpVtbl->AddChild(p,a) +#define IDirect3DRMFrame2_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DRMFrame2_AddMoveCallback(p,a,b) (p)->lpVtbl->AddMoveCallback(p,a,b) +#define IDirect3DRMFrame2_AddTransform(p,a,b) (p)->lpVtbl->AddTransform(p,a,b) +#define IDirect3DRMFrame2_AddTranslation(p,a,b,c,d) (p)->lpVtbl->AddTranslation(p,a,b,c,d) +#define IDirect3DRMFrame2_AddScale(p,a,b,c,d) (p)->lpVtbl->AddScale(p,a,b,c,d) +#define IDirect3DRMFrame2_AddRotation(p,a,b,c,d,e) (p)->lpVtbl->AddRotation(p,a,b,c,d,e) +#define IDirect3DRMFrame2_AddVisual(p,a) (p)->lpVtbl->AddVisual(p,a) +#define IDirect3DRMFrame2_GetChildren(p,a) (p)->lpVtbl->GetChildren(p,a) +#define IDirect3DRMFrame2_GetColor(p) (p)->lpVtbl->GetColor(p) +#define IDirect3DRMFrame2_GetLights(p,a) (p)->lpVtbl->GetLights(p,a) +#define IDirect3DRMFrame2_GetMaterialMode(p) (p)->lpVtbl->GetMaterialMode(p) +#define IDirect3DRMFrame2_GetParent(p,a) (p)->lpVtbl->GetParent(p,a) +#define IDirect3DRMFrame2_GetPosition(p,a,b) (p)->lpVtbl->GetPosition(p,a,b) +#define IDirect3DRMFrame2_GetRotation(p,a,b,c) (p)->lpVtbl->GetRotation(p,a,b,c) +#define IDirect3DRMFrame2_GetScene(p,a) (p)->lpVtbl->GetScene(p,a) +#define IDirect3DRMFrame2_GetSortMode(p) (p)->lpVtbl->GetSortMode(p) +#define IDirect3DRMFrame2_GetTexture(p,a) (p)->lpVtbl->GetTexture(p,a) +#define IDirect3DRMFrame2_GetTransform(p,a) (p)->lpVtbl->GetTransform(p,a) +#define IDirect3DRMFrame2_GetVelocity(p,a,b,c) (p)->lpVtbl->GetVelocity(p,a,b,c) +#define IDirect3DRMFrame2_GetOrientation(p,a,b,c) (p)->lpVtbl->GetOrientation(p,a,b,c) +#define IDirect3DRMFrame2_GetVisuals(p,a) (p)->lpVtbl->GetVisuals(p,a) +#define IDirect3DRMFrame2_GetTextureTopology(p,a,b) (p)->lpVtbl->GetTextureTopology(p,a,b) +#define IDirect3DRMFrame2_InverseTransform(p,a,b) (p)->lpVtbl->InverseTransform(p,a,b) +#define IDirect3DRMFrame2_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMFrame2_LookAt(p,a,b,c) (p)->lpVtbl->LookAt(p,a,b,c) +#define IDirect3DRMFrame2_Move(p,a) (p)->lpVtbl->Move(p,a) +#define IDirect3DRMFrame2_DeleteChild(p,a) (p)->lpVtbl->DeleteChild(p,a) +#define IDirect3DRMFrame2_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DRMFrame2_DeleteMoveCallback(p,a,b) (p)->lpVtbl->DeleteMoveCallback(p,a,b) +#define IDirect3DRMFrame2_DeleteVisual(p,a) (p)->lpVtbl->DeleteVisual(p,a) +#define IDirect3DRMFrame2_GetSceneBackground(p) (p)->lpVtbl->GetSceneBackground(p) +#define IDirect3DRMFrame2_GetSceneBackgroundDepth(p,a) (p)->lpVtbl->GetSceneBackgroundDepth(p,a) +#define IDirect3DRMFrame2_GetSceneFogColor(p) (p)->lpVtbl->GetSceneFogColor(p) +#define IDirect3DRMFrame2_GetSceneFogEnable(p) (p)->lpVtbl->GetSceneFogEnable(p) +#define IDirect3DRMFrame2_GetSceneFogMode(p) (p)->lpVtbl->GetSceneFogMode(p) +#define IDirect3DRMFrame2_GetSceneFogParams(p,a,b,c) (p)->lpVtbl->GetSceneFogParams(p,a,b,c) +#define IDirect3DRMFrame2_SetSceneBackground(p,a) (p)->lpVtbl->SetSceneBackground(p,a) +#define IDirect3DRMFrame2_SetSceneBackgroundRGB(p,a,b,c) (p)->lpVtbl->SetSceneBackgroundRGB(p,a,b,c) +#define IDirect3DRMFrame2_SetSceneBackgroundDepth(p,a) (p)->lpVtbl->SetSceneBackgroundDepth(p,a) +#define IDirect3DRMFrame2_SetSceneBackgroundImage(p,a) (p)->lpVtbl->SetSceneBackgroundImage(p,a) +#define IDirect3DRMFrame2_SetSceneFogEnable(p,a) (p)->lpVtbl->SetSceneFogEnable(p,a) +#define IDirect3DRMFrame2_SetSceneFogColor(p,a) (p)->lpVtbl->SetSceneFogColor(p,a) +#define IDirect3DRMFrame2_SetSceneFogMode(p,a) (p)->lpVtbl->SetSceneFogMode(p,a) +#define IDirect3DRMFrame2_SetSceneFogParams(p,a,b,c) (p)->lpVtbl->SetSceneFogParams(p,a,b,c) +#define IDirect3DRMFrame2_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMFrame2_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMFrame2_GetZbufferMode(p) (p)->lpVtbl->GetZbufferMode(p) +#define IDirect3DRMFrame2_SetMaterialMode(p,a) (p)->lpVtbl->SetMaterialMode(p,a) +#define IDirect3DRMFrame2_SetOrientation(p,a,b,c,d,e,f,g) (p)->lpVtbl->SetOrientation(p,a,b,c,d,e,f,g) +#define IDirect3DRMFrame2_SetPosition(p,a,b,c,d) (p)->lpVtbl->SetPosition(p,a,b,c,d) +#define IDirect3DRMFrame2_SetRotation(p,a,b,c,d,e) (p)->lpVtbl->SetRotation(p,a,b,c,d,e) +#define IDirect3DRMFrame2_SetSortMode(p,a) (p)->lpVtbl->SetSortMode(p,a) +#define IDirect3DRMFrame2_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMFrame2_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMFrame2_SetVelocity(p,a,b,c,d,e) (p)->lpVtbl->SetVelocity(p,a,b,c,d,e) +#define IDirect3DRMFrame2_SetZbufferMode(p,a) (p)->lpVtbl->SetZbufferMode(p,a) +#define IDirect3DRMFrame2_Transform(p,a,b) (p)->lpVtbl->Transform(p,a,b) +/*** IDirect3DRMFrame2 methods ***/ +#define IDirect3DRMFrame2_AddMoveCallback2(p,a,b,c) (p)->lpVtbl->AddMoveCallback2(p,a,b,c) +#define IDirect3DRMFrame2_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMFrame2_GetBoxEnable(p) (p)->lpVtbl->GetBoxEnable(p) +#define IDirect3DRMFrame2_GetAxes(p,a,b) (p)->lpVtbl->GetAxes(p,a,b) +#define IDirect3DRMFrame2_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DRMFrame2_GetInheritAxes(p,a,b) (p)->lpVtbl->GetInheritAxes(p,a,b) +#define IDirect3DRMFrame2_GetHierarchyBox(p,a) (p)->lpVtbl->GetHierarchyBox(p,a) +#define IDirect3DRMFrame2_SetBox(p,a) (p)->lpVtbl->SetBox(p,a) +#define IDirect3DRMFrame2_SetBoxEnable(p,a) (p)->lpVtbl->SetBoxEnable(p,a) +#define IDirect3DRMFrame2_SetAxes(p,a,b,c,d,e,f) (p)->lpVtbl->SetAxes(p,a,b,c,d,e,f) +#define IDirect3DRMFrame2_SetInheritAxes(p,a) (p)->lpVtbl->SetInheritAxes(p,a) +#define IDirect3DRMFrame2_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMFrame2_SetQuaternion(p,a,b) (p)->lpVtbl->SetQuaternion(p,a,b) +#define IDirect3DRMFrame2_RayPick(p,a,b,c,d) (p)->lpVtbl->RayPick(p,a,b,c,d) +#define IDirect3DRMFrame2_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFrame2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFrame2_AddRef(p) (p)->AddRef() +#define IDirect3DRMFrame2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFrame2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMFrame2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMFrame2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMFrame2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMFrame2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMFrame2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMFrame2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMFrame2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMFrame methods ***/ +#define IDirect3DRMFrame2_AddChild(p,a) (p)->AddChild(a) +#define IDirect3DRMFrame2_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DRMFrame2_AddMoveCallback(p,a,b) (p)->AddMoveCallback(a,b) +#define IDirect3DRMFrame2_AddTransform(p,a,b) (p)->AddTransform(a,b) +#define IDirect3DRMFrame2_AddTranslation(p,a,b,c,d) (p)->AddTranslation(a,b,c,d) +#define IDirect3DRMFrame2_AddScale(p,a,b,c,d) (p)->AddScale(a,b,c,d) +#define IDirect3DRMFrame2_AddRotation(p,a,b,c,d,e) (p)->AddRotation(a,b,c,d,e) +#define IDirect3DRMFrame2_AddVisual(p,a) (p)->AddVisual(a) +#define IDirect3DRMFrame2_GetChildren(p,a) (p)->GetChildren(a) +#define IDirect3DRMFrame2_GetColor(p) (p)->GetColor() +#define IDirect3DRMFrame2_GetLights(p,a) (p)->GetLights(a) +#define IDirect3DRMFrame2_GetMaterialMode(p) (p)->GetMaterialMode() +#define IDirect3DRMFrame2_GetParent(p,a) (p)->GetParent(a) +#define IDirect3DRMFrame2_GetPosition(p,a,b) (p)->GetPosition(a,b) +#define IDirect3DRMFrame2_GetRotation(p,a,b,c) (p)->GetRotation(a,b,c) +#define IDirect3DRMFrame2_GetScene(p,a) (p)->GetScene(a) +#define IDirect3DRMFrame2_GetSortMode(p) (p)->GetSortMode() +#define IDirect3DRMFrame2_GetTexture(p,a) (p)->GetTexture(a) +#define IDirect3DRMFrame2_GetTransform(p,a) (p)->GetTransform(a) +#define IDirect3DRMFrame2_GetVelocity(p,a,b,c) (p)->GetVelocity(a,b,c) +#define IDirect3DRMFrame2_GetOrientation(p,a,b,c) (p)->GetOrientation(a,b,c) +#define IDirect3DRMFrame2_GetVisuals(p,a) (p)->GetVisuals(a) +#define IDirect3DRMFrame2_GetTextureTopology(p,a,b) (p)->GetTextureTopology(a,b) +#define IDirect3DRMFrame2_InverseTransform(p,a,b) (p)->InverseTransform(a,b) +#define IDirect3DRMFrame2_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMFrame2_LookAt(p,a,b,c) (p)->LookAt(a,b,c) +#define IDirect3DRMFrame2_Move(p,a) (p)->Move(a) +#define IDirect3DRMFrame2_DeleteChild(p,a) (p)->DeleteChild(a) +#define IDirect3DRMFrame2_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DRMFrame2_DeleteMoveCallback(p,a,b) (p)->DeleteMoveCallback(a,b) +#define IDirect3DRMFrame2_DeleteVisual(p,a) (p)->DeleteVisual(a) +#define IDirect3DRMFrame2_GetSceneBackground(p) (p)->GetSceneBackground() +#define IDirect3DRMFrame2_GetSceneBackgroundDepth(p,a) (p)->GetSceneBackgroundDepth(a) +#define IDirect3DRMFrame2_GetSceneFogColor(p) (p)->GetSceneFogColor() +#define IDirect3DRMFrame2_GetSceneFogEnable(p) (p)->GetSceneFogEnable() +#define IDirect3DRMFrame2_GetSceneFogMode(p) (p)->GetSceneFogMode() +#define IDirect3DRMFrame2_GetSceneFogParams(p,a,b,c) (p)->GetSceneFogParams(a,b,c) +#define IDirect3DRMFrame2_SetSceneBackground(p,a) (p)->SetSceneBackground(a) +#define IDirect3DRMFrame2_SetSceneBackgroundRGB(p,a,b,c) (p)->SetSceneBackgroundRGB(a,b,c) +#define IDirect3DRMFrame2_SetSceneBackgroundDepth(p,a) (p)->SetSceneBackgroundDepth(a) +#define IDirect3DRMFrame2_SetSceneBackgroundImage(p,a) (p)->SetSceneBackgroundImage(a) +#define IDirect3DRMFrame2_SetSceneFogEnable(p,a) (p)->SetSceneFogEnable(a) +#define IDirect3DRMFrame2_SetSceneFogColor(p,a) (p)->SetSceneFogColor(a) +#define IDirect3DRMFrame2_SetSceneFogMode(p,a) (p)->SetSceneFogMode(a) +#define IDirect3DRMFrame2_SetSceneFogParams(p,a,b,c) (p)->SetSceneFogParams(a,b,c) +#define IDirect3DRMFrame2_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMFrame2_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMFrame2_GetZbufferMode(p) (p)->GetZbufferMode() +#define IDirect3DRMFrame2_SetMaterialMode(p,a) (p)->SetMaterialMode(a) +#define IDirect3DRMFrame2_SetOrientation(p,a,b,c,d,e,f,g) (p)->SetOrientation(a,b,c,d,e,f,g) +#define IDirect3DRMFrame2_SetPosition(p,a,b,c,d) (p)->SetPosition(a,b,c,d) +#define IDirect3DRMFrame2_SetRotation(p,a,b,c,d,e) (p)->SetRotation(a,b,c,d,e) +#define IDirect3DRMFrame2_SetSortMode(p,a) (p)->SetSortMode(a) +#define IDirect3DRMFrame2_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMFrame2_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMFrame2_SetVelocity(p,a,b,c,d,e) (p)->SetVelocity(a,b,c,d,e) +#define IDirect3DRMFrame2_SetZbufferMode(p,a) (p)->SetZbufferMode(a) +#define IDirect3DRMFrame2_Transform(p,a,b) (p)->Transform(a,b) +/*** IDirect3DRMFrame2 methods ***/ +#define IDirect3DRMFrame2_AddMoveCallback2(p,a,b,c) (p)->AddMoveCallback2(a,b,c) +#define IDirect3DRMFrame2_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMFrame2_GetBoxEnable(p) (p)->GetBoxEnable() +#define IDirect3DRMFrame2_GetAxes(p,a,b) (p)->GetAxes(a,b) +#define IDirect3DRMFrame2_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DRMFrame2_GetInheritAxes(p,a,b) (p)->GetInheritAxes(a,b) +#define IDirect3DRMFrame2_GetHierarchyBox(p,a) (p)->GetHierarchyBox(a) +#define IDirect3DRMFrame2_SetBox(p,a) (p)->SetBox(a) +#define IDirect3DRMFrame2_SetBoxEnable(p,a) (p)->SetBoxEnable(a) +#define IDirect3DRMFrame2_SetAxes(p,a,b,c,d,e,f) (p)->SetAxes(a,b,c,d,e,f) +#define IDirect3DRMFrame2_SetInheritAxes(p,a) (p)->SetInheritAxes(a) +#define IDirect3DRMFrame2_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMFrame2_SetQuaternion(p,a,b) (p)->SetQuaternion(a,b) +#define IDirect3DRMFrame2_RayPick(p,a,b,c,d) (p)->RayPick(a,b,c,d) +#define IDirect3DRMFrame2_Save(p,a,b,c) (p)->Save(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DRMFrame3 interface + */ +#define INTERFACE IDirect3DRMFrame3 +DECLARE_INTERFACE_(IDirect3DRMFrame3,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMFrame3 methods ***/ + STDMETHOD(AddChild)(THIS_ IDirect3DRMFrame3 *child) PURE; + STDMETHOD(AddLight)(THIS_ struct IDirect3DRMLight *light) PURE; + STDMETHOD(AddMoveCallback)(THIS_ D3DRMFRAME3MOVECALLBACK cb, void *ctx, DWORD flags) PURE; + STDMETHOD(AddTransform)(THIS_ D3DRMCOMBINETYPE, D3DRMMATRIX4D) PURE; + STDMETHOD(AddTranslation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddScale)(THIS_ D3DRMCOMBINETYPE, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(AddRotation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE; + STDMETHOD(AddVisual)(THIS_ IUnknown *visual) PURE; + STDMETHOD(GetChildren)(THIS_ struct IDirect3DRMFrameArray **children) PURE; + STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE; + STDMETHOD(GetLights)(THIS_ struct IDirect3DRMLightArray **lights) PURE; + STDMETHOD_(D3DRMMATERIALMODE, GetMaterialMode)(THIS) PURE; + STDMETHOD(GetParent)(THIS_ IDirect3DRMFrame3 **parent) PURE; + STDMETHOD(GetPosition)(THIS_ IDirect3DRMFrame3 *reference, D3DVECTOR *return_position) PURE; + STDMETHOD(GetRotation)(THIS_ IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *return_theta) PURE; + STDMETHOD(GetScene)(THIS_ IDirect3DRMFrame3 **scene) PURE; + STDMETHOD_(D3DRMSORTMODE, GetSortMode)(THIS) PURE; + STDMETHOD(GetTexture)(THIS_ struct IDirect3DRMTexture3 **texture) PURE; + STDMETHOD(GetTransform)(THIS_ IDirect3DRMFrame3 *reference, D3DRMMATRIX4D matrix) PURE; + STDMETHOD(GetVelocity)(THIS_ IDirect3DRMFrame3 *reference, D3DVECTOR *return_velocity, BOOL with_rotation) PURE; + STDMETHOD(GetOrientation)(THIS_ IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up) PURE; + STDMETHOD(GetVisuals)(THIS_ DWORD *count, IUnknown **visuals) PURE; + STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE; + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURE3CALLBACK cb, void *ctx) PURE; + STDMETHOD(LookAt)(THIS_ IDirect3DRMFrame3 *target, IDirect3DRMFrame3 *reference, + D3DRMFRAMECONSTRAINT constraint) PURE; + STDMETHOD(Move)(THIS_ D3DVALUE delta) PURE; + STDMETHOD(DeleteChild)(THIS_ IDirect3DRMFrame3 *child) PURE; + STDMETHOD(DeleteLight)(THIS_ struct IDirect3DRMLight *light) PURE; + STDMETHOD(DeleteMoveCallback)(THIS_ D3DRMFRAME3MOVECALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteVisual)(THIS_ IUnknown *visual) PURE; + STDMETHOD_(D3DCOLOR, GetSceneBackground)(THIS) PURE; + STDMETHOD(GetSceneBackgroundDepth)(THIS_ IDirectDrawSurface **surface) PURE; + STDMETHOD_(D3DCOLOR, GetSceneFogColor)(THIS) PURE; + STDMETHOD_(BOOL, GetSceneFogEnable)(THIS) PURE; + STDMETHOD_(D3DRMFOGMODE, GetSceneFogMode)(THIS) PURE; + STDMETHOD(GetSceneFogParams)(THIS_ D3DVALUE *return_start, D3DVALUE *return_end, + D3DVALUE *return_density) PURE; + STDMETHOD(SetSceneBackground)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetSceneBackgroundRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetSceneBackgroundDepth)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(SetSceneBackgroundImage)(THIS_ struct IDirect3DRMTexture3 *texture) PURE; + STDMETHOD(SetSceneFogEnable)(THIS_ BOOL) PURE; + STDMETHOD(SetSceneFogColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetSceneFogMode)(THIS_ D3DRMFOGMODE) PURE; + STDMETHOD(SetSceneFogParams)(THIS_ D3DVALUE start, D3DVALUE end, D3DVALUE density) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD_(D3DRMZBUFFERMODE, GetZbufferMode)(THIS) PURE; + STDMETHOD(SetMaterialMode)(THIS_ D3DRMMATERIALMODE) PURE; + STDMETHOD(SetOrientation)(THIS_ IDirect3DRMFrame3 *reference, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, + D3DVALUE ux, D3DVALUE uy, D3DVALUE uz) PURE; + STDMETHOD(SetPosition)(THIS_ IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetRotation)(THIS_ IDirect3DRMFrame3 *reference, + D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE; + STDMETHOD(SetSortMode)(THIS_ D3DRMSORTMODE) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture3 *texture) PURE; + STDMETHOD(SetVelocity)(THIS_ IDirect3DRMFrame3 *reference, + D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation) PURE; + STDMETHOD(SetZbufferMode)(THIS_ D3DRMZBUFFERMODE) PURE; + STDMETHOD(Transform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE; + STDMETHOD(GetBox)(THIS_ D3DRMBOX *box) PURE; + STDMETHOD_(BOOL, GetBoxEnable)(THIS) PURE; + STDMETHOD(GetAxes)(THIS_ D3DVECTOR *dir, D3DVECTOR *up); + STDMETHOD(GetMaterial)(THIS_ struct IDirect3DRMMaterial2 **material) PURE; + STDMETHOD_(BOOL, GetInheritAxes)(THIS); + STDMETHOD(GetHierarchyBox)(THIS_ D3DRMBOX *box) PURE; + STDMETHOD(SetBox)(THIS_ D3DRMBOX *box) PURE; + STDMETHOD(SetBoxEnable)(THIS_ BOOL) PURE; + STDMETHOD(SetAxes)(THIS_ D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz); + STDMETHOD(SetInheritAxes)(THIS_ BOOL inherit_from_parent); + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial2 *material) PURE; + STDMETHOD(SetQuaternion)(THIS_ IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q) PURE; + STDMETHOD(RayPick)(THIS_ IDirect3DRMFrame3 *reference, D3DRMRAY *ray, DWORD flags, + struct IDirect3DRMPicked2Array **return_visuals) PURE; + STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags); + STDMETHOD(TransformVectors)(THIS_ IDirect3DRMFrame3 *reference, DWORD vector_count, + D3DVECTOR *dst_vectors, D3DVECTOR *src_vectors) PURE; + STDMETHOD(InverseTransformVectors)(THIS_ IDirect3DRMFrame3 *reference, DWORD vector_count, + D3DVECTOR *dst_vectors, D3DVECTOR *src_vectors) PURE; + STDMETHOD(SetTraversalOptions)(THIS_ DWORD flags) PURE; + STDMETHOD(GetTraversalOptions)(THIS_ DWORD *flags) PURE; + STDMETHOD(SetSceneFogMethod)(THIS_ DWORD flags) PURE; + STDMETHOD(GetSceneFogMethod)(THIS_ DWORD *fog_mode) PURE; + STDMETHOD(SetMaterialOverride)(THIS_ D3DRMMATERIALOVERRIDE *override) PURE; + STDMETHOD(GetMaterialOverride)(THIS_ D3DRMMATERIALOVERRIDE *override) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFrame3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFrame3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFrame3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFrame3_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMFrame3_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMFrame3_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMFrame3_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMFrame3_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMFrame3_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMFrame3_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMFrame3_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMFrame3 methods ***/ +#define IDirect3DRMFrame3_AddChild(p,a) (p)->lpVtbl->AddChild(p,a) +#define IDirect3DRMFrame3_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DRMFrame3_AddMoveCallback(p,a,b,c) (p)->lpVtbl->AddMoveCallback(p,a,b,c) +#define IDirect3DRMFrame3_AddTransform(p,a,b) (p)->lpVtbl->AddTransform(p,a,b) +#define IDirect3DRMFrame3_AddTranslation(p,a,b,c,d) (p)->lpVtbl->AddTranslation(p,a,b,c,d) +#define IDirect3DRMFrame3_AddScale(p,a,b,c,d) (p)->lpVtbl->AddScale(p,a,b,c,d) +#define IDirect3DRMFrame3_AddRotation(p,a,b,c,d,e) (p)->lpVtbl->AddRotation(p,a,b,c,d,e) +#define IDirect3DRMFrame3_AddVisual(p,a) (p)->lpVtbl->AddVisual(p,a) +#define IDirect3DRMFrame3_GetChildren(p,a) (p)->lpVtbl->GetChildren(p,a) +#define IDirect3DRMFrame3_GetColor(p) (p)->lpVtbl->GetColor(p) +#define IDirect3DRMFrame3_GetLights(p,a) (p)->lpVtbl->GetLights(p,a) +#define IDirect3DRMFrame3_GetMaterialMode(p) (p)->lpVtbl->GetMaterialMode(p) +#define IDirect3DRMFrame3_GetParent(p,a) (p)->lpVtbl->GetParent(p,a) +#define IDirect3DRMFrame3_GetPosition(p,a,b) (p)->lpVtbl->GetPosition(p,a,b) +#define IDirect3DRMFrame3_GetRotation(p,a,b,c) (p)->lpVtbl->GetRotation(p,a,b,c) +#define IDirect3DRMFrame3_GetScene(p,a) (p)->lpVtbl->GetScene(p,a) +#define IDirect3DRMFrame3_GetSortMode(p) (p)->lpVtbl->GetSortMode(p) +#define IDirect3DRMFrame3_GetTexture(p,a) (p)->lpVtbl->GetTexture(p,a) +#define IDirect3DRMFrame3_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DRMFrame3_GetVelocity(p,a,b,c) (p)->lpVtbl->GetVelocity(p,a,b,c) +#define IDirect3DRMFrame3_GetOrientation(p,a,b,c) (p)->lpVtbl->GetOrientation(p,a,b,c) +#define IDirect3DRMFrame3_GetVisuals(p,a,b) (p)->lpVtbl->GetVisuals(p,a,b) +#define IDirect3DRMFrame3_InverseTransform(p,a,b) (p)->lpVtbl->InverseTransform(p,a,b) +#define IDirect3DRMFrame3_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMFrame3_LookAt(p,a,b,c) (p)->lpVtbl->LookAt(p,a,b,c) +#define IDirect3DRMFrame3_Move(p,a) (p)->lpVtbl->Move(p,a) +#define IDirect3DRMFrame3_DeleteChild(p,a) (p)->lpVtbl->DeleteChild(p,a) +#define IDirect3DRMFrame3_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DRMFrame3_DeleteMoveCallback(p,a,b) (p)->lpVtbl->DeleteMoveCallback(p,a,b) +#define IDirect3DRMFrame3_DeleteVisual(p,a) (p)->lpVtbl->DeleteVisual(p,a) +#define IDirect3DRMFrame3_GetSceneBackground(p) (p)->lpVtbl->GetSceneBackground(p) +#define IDirect3DRMFrame3_GetSceneBackgroundDepth(p,a) (p)->lpVtbl->GetSceneBackgroundDepth(p,a) +#define IDirect3DRMFrame3_GetSceneFogColor(p) (p)->lpVtbl->GetSceneFogColor(p) +#define IDirect3DRMFrame3_GetSceneFogEnable(p) (p)->lpVtbl->GetSceneFogEnable(p) +#define IDirect3DRMFrame3_GetSceneFogMode(p) (p)->lpVtbl->GetSceneFogMode(p) +#define IDirect3DRMFrame3_GetSceneFogParams(p,a,b,c) (p)->lpVtbl->GetSceneFogParams(p,a,b,c) +#define IDirect3DRMFrame3_SetSceneBackground(p,a) (p)->lpVtbl->SetSceneBackground(p,a) +#define IDirect3DRMFrame3_SetSceneBackgroundRGB(p,a,b,c) (p)->lpVtbl->SetSceneBackgroundRGB(p,a,b,c) +#define IDirect3DRMFrame3_SetSceneBackgroundDepth(p,a) (p)->lpVtbl->SetSceneBackgroundDepth(p,a) +#define IDirect3DRMFrame3_SetSceneBackgroundImage(p,a) (p)->lpVtbl->SetSceneBackgroundImage(p,a) +#define IDirect3DRMFrame3_SetSceneFogEnable(p,a) (p)->lpVtbl->SetSceneFogEnable(p,a) +#define IDirect3DRMFrame3_SetSceneFogColor(p,a) (p)->lpVtbl->SetSceneFogColor(p,a) +#define IDirect3DRMFrame3_SetSceneFogMode(p,a) (p)->lpVtbl->SetSceneFogMode(p,a) +#define IDirect3DRMFrame3_SetSceneFogParams(p,a,b,c) (p)->lpVtbl->SetSceneFogParams(p,a,b,c) +#define IDirect3DRMFrame3_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMFrame3_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMFrame3_GetZbufferMode(p) (p)->lpVtbl->GetZbufferMode(p) +#define IDirect3DRMFrame3_SetMaterialMode(p,a) (p)->lpVtbl->SetMaterialMode(p,a) +#define IDirect3DRMFrame3_SetOrientation(p,a,b,c,d,e,f,g) (p)->lpVtbl->SetOrientation(p,a,b,c,d,e,f,g) +#define IDirect3DRMFrame3_SetPosition(p,a,b,c,d) (p)->lpVtbl->SetPosition(p,a,b,c,d) +#define IDirect3DRMFrame3_SetRotation(p,a,b,c,d,e) (p)->lpVtbl->SetRotation(p,a,b,c,d,e) +#define IDirect3DRMFrame3_SetSortMode(p,a) (p)->lpVtbl->SetSortMode(p,a) +#define IDirect3DRMFrame3_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMFrame3_SetVelocity(p,a,b,c,d,e) (p)->lpVtbl->SetVelocity(p,a,b,c,d,e) +#define IDirect3DRMFrame3_SetZbufferMode(p,a) (p)->lpVtbl->SetZbufferMode(p,a) +#define IDirect3DRMFrame3_Transform(p,a,b) (p)->lpVtbl->Transform(p,a,b) +#define IDirect3DRMFrame3_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMFrame3_GetBoxEnable(p) (p)->lpVtbl->GetBoxEnable(p) +#define IDirect3DRMFrame3_GetAxes(p,a,b) (p)->lpVtbl->GetAxes(p,a,b) +#define IDirect3DRMFrame3_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DRMFrame3_GetInheritAxes(p) (p)->lpVtbl->GetInheritAxes(p) +#define IDirect3DRMFrame3_GetHierarchyBox(p,a) (p)->lpVtbl->GetHierarchyBox(p,a) +#define IDirect3DRMFrame3_SetBox(p,a) (p)->lpVtbl->SetBox(p,a) +#define IDirect3DRMFrame3_SetBoxEnable(p,a) (p)->lpVtbl->SetBoxEnable(p,a) +#define IDirect3DRMFrame3_SetAxes(p,a,b,c,d,e,f) (p)->lpVtbl->SetAxes(p,a,b,c,d,e,f) +#define IDirect3DRMFrame3_SetInheritAxes(p,a) (p)->lpVtbl->SetInheritAxes(p,a) +#define IDirect3DRMFrame3_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMFrame3_SetQuaternion(p,a,b) (p)->lpVtbl->SetQuaternion(p,a,b) +#define IDirect3DRMFrame3_RayPick(p,a,b,c,d) (p)->lpVtbl->RayPick(p,a,b,c,d) +#define IDirect3DRMFrame3_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#define IDirect3DRMFrame3_TransformVectors(p,a,b,c,d) (p)->lpVtbl->TransformVectors(p,a,b,c,d) +#define IDirect3DRMFrame3_InverseTransformVectors(p,a,b,c,d) (p)->lpVtbl->InverseTransformVectors(p,a,b,c,d) +#define IDirect3DRMFrame3_SetTraversalOptions(p,a) (p)->lpVtbl->SetTraversalOptions(p,a) +#define IDirect3DRMFrame3_GetTraversalOptions(p,a) (p)->lpVtbl->GetTraversalOptions(p,a) +#define IDirect3DRMFrame3_SetSceneFogMethod(p,a) (p)->lpVtbl->SetSceneFogMethod(p,a) +#define IDirect3DRMFrame3_GetSceneFogMethod(p,a) (p)->lpVtbl->GetSceneFogMethod(p,a) +#define IDirect3DRMFrame3_SetMaterialOverride(p,a) (p)->lpVtbl->SetMaterialOverride(p,a) +#define IDirect3DRMFrame3_GetMaterialOverride(p,a) (p)->lpVtbl->GetMaterialOverride(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFrame3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFrame3_AddRef(p) (p)->AddRef() +#define IDirect3DRMFrame3_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFrame3_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMFrame3_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMFrame3_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMFrame3_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMFrame3_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMFrame3_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMFrame3_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMFrame3_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMFrame3 methods ***/ +#define IDirect3DRMFrame3_AddChild(p,a) (p)->AddChild(a) +#define IDirect3DRMFrame3_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DRMFrame3_AddMoveCallback(p,a,b,c) (p)->AddMoveCallback(a,b,c) +#define IDirect3DRMFrame3_AddTransform(p,a,b) (p)->AddTransform(a,b) +#define IDirect3DRMFrame3_AddTranslation(p,a,b,c,d) (p)->AddTranslation(a,b,c,d) +#define IDirect3DRMFrame3_AddScale(p,a,b,c,d) (p)->AddScale(a,b,c,d) +#define IDirect3DRMFrame3_AddRotation(p,a,b,c,d,e) (p)->AddRotation(a,b,c,d,e) +#define IDirect3DRMFrame3_AddVisual(p,a) (p)->AddVisual(a) +#define IDirect3DRMFrame3_GetChildren(p,a) (p)->GetChildren(a) +#define IDirect3DRMFrame3_GetColor(p) (p)->GetColor() +#define IDirect3DRMFrame3_GetLights(p,a) (p)->GetLights(a) +#define IDirect3DRMFrame3_GetMaterialMode(p) (p)->GetMaterialMode() +#define IDirect3DRMFrame3_GetParent(p,a) (p)->GetParent(a) +#define IDirect3DRMFrame3_GetPosition(p,a,b) (p)->GetPosition(a,b) +#define IDirect3DRMFrame3_GetRotation(p,a,b,c) (p)->GetRotation(a,b,c) +#define IDirect3DRMFrame3_GetScene(p,a) (p)->GetScene(a) +#define IDirect3DRMFrame3_GetSortMode(p) (p)->GetSortMode() +#define IDirect3DRMFrame3_GetTexture(p,a) (p)->GetTexture(a) +#define IDirect3DRMFrame3_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DRMFrame3_GetVelocity(p,a,b,c) (p)->GetVelocity(a,b,c) +#define IDirect3DRMFrame3_GetOrientation(p,a,b,c) (p)->GetOrientation(a,b,c) +#define IDirect3DRMFrame3_GetVisuals(p,a,b) (p)->GetVisuals(a,b) +#define IDirect3DRMFrame3_InverseTransform(p,a,b) (p)->InverseTransform(a,b) +#define IDirect3DRMFrame3_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMFrame3_LookAt(p,a,b,c) (p)->LookAt(a,b,c) +#define IDirect3DRMFrame3_Move(p,a) (p)->Move(a) +#define IDirect3DRMFrame3_DeleteChild(p,a) (p)->DeleteChild(a) +#define IDirect3DRMFrame3_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DRMFrame3_DeleteMoveCallback(p,a,b) (p)->DeleteMoveCallback(a,b) +#define IDirect3DRMFrame3_DeleteVisual(p,a) (p)->DeleteVisual(a) +#define IDirect3DRMFrame3_GetSceneBackground(p) (p)->GetSceneBackground() +#define IDirect3DRMFrame3_GetSceneBackgroundDepth(p,a) (p)->GetSceneBackgroundDepth(a) +#define IDirect3DRMFrame3_GetSceneFogColor(p) (p)->GetSceneFogColor() +#define IDirect3DRMFrame3_GetSceneFogEnable(p) (p)->GetSceneFogEnable() +#define IDirect3DRMFrame3_GetSceneFogMode(p) (p)->GetSceneFogMode() +#define IDirect3DRMFrame3_GetSceneFogParams(p,a,b,c) (p)->GetSceneFogParams(a,b,c) +#define IDirect3DRMFrame3_SetSceneBackground(p,a) (p)->SetSceneBackground(a) +#define IDirect3DRMFrame3_SetSceneBackgroundRGB(p,a,b,c) (p)->SetSceneBackgroundRGB(a,b,c) +#define IDirect3DRMFrame3_SetSceneBackgroundDepth(p,a) (p)->SetSceneBackgroundDepth(a) +#define IDirect3DRMFrame3_SetSceneBackgroundImage(p,a) (p)->SetSceneBackgroundImage(a) +#define IDirect3DRMFrame3_SetSceneFogEnable(p,a) (p)->SetSceneFogEnable(a) +#define IDirect3DRMFrame3_SetSceneFogColor(p,a) (p)->SetSceneFogColor(a) +#define IDirect3DRMFrame3_SetSceneFogMode(p,a) (p)->SetSceneFogMode(a) +#define IDirect3DRMFrame3_SetSceneFogParams(p,a,b,c) (p)->SetSceneFogParams(a,b,c) +#define IDirect3DRMFrame3_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMFrame3_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMFrame3_GetZbufferMode(p) (p)->GetZbufferMode() +#define IDirect3DRMFrame3_SetMaterialMode(p,a) (p)->SetMaterialMode(a) +#define IDirect3DRMFrame3_SetOrientation(p,a,b,c,d,e,f,g) (p)->SetOrientation(a,b,c,d,e,f,g) +#define IDirect3DRMFrame3_SetPosition(p,a,b,c,d) (p)->SetPosition(a,b,c,d) +#define IDirect3DRMFrame3_SetRotation(p,a,b,c,d,e) (p)->SetRotation(a,b,c,d,e) +#define IDirect3DRMFrame3_SetSortMode(p,a) (p)->SetSortMode(a) +#define IDirect3DRMFrame3_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMFrame3_SetVelocity(p,a,b,c,d,e) (p)->SetVelocity(a,b,c,d,e) +#define IDirect3DRMFrame3_SetZbufferMode(p,a) (p)->SetZbufferMode(a) +#define IDirect3DRMFrame3_Transform(p,a,b) (p)->Transform(a,b) +#define IDirect3DRMFrame3_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMFrame3_GetBoxEnable(p) (p)->GetBoxEnable() +#define IDirect3DRMFrame3_GetAxes(p,a,b) (p)->GetAxes(a,b) +#define IDirect3DRMFrame3_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DRMFrame3_GetInheritAxes(p) (p)->GetInheritAxes() +#define IDirect3DRMFrame3_GetHierarchyBox(p,a) (p)->GetHierarchyBox(a) +#define IDirect3DRMFrame3_SetBox(p,a) (p)->SetBox(a) +#define IDirect3DRMFrame3_SetBoxEnable(p,a) (p)->SetBoxEnable(a) +#define IDirect3DRMFrame3_SetAxes(p,a,b,c,d,e,f) (p)->SetAxes(a,b,c,d,e,f) +#define IDirect3DRMFrame3_SetInheritAxes(p,a) (p)->SetInheritAxes(a) +#define IDirect3DRMFrame3_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMFrame3_SetQuaternion(p,a,b) (p)->SetQuaternion(a,b) +#define IDirect3DRMFrame3_RayPick(p,a,b,c,d) (p)->RayPick(a,b,c,d) +#define IDirect3DRMFrame3_Save(p,a,b,c) (p)->Save(a,b,c) +#define IDirect3DRMFrame3_TransformVectors(p,a,b,c,d) (p)->TransformVectors(a,b,c,d) +#define IDirect3DRMFrame3_InverseTransformVectors(p,a,b,c,d) (p)->InverseTransformVectors(a,b,c,d) +#define IDirect3DRMFrame3_SetTraversalOptions(p,a) (p)->SetTraversalOptions(a) +#define IDirect3DRMFrame3_GetTraversalOptions(p,a) (p)->GetTraversalOptions(a) +#define IDirect3DRMFrame3_SetSceneFogMethod(p,a) (p)->SetSceneFogMethod(a) +#define IDirect3DRMFrame3_GetSceneFogMethod(p,a) (p)->GetSceneFogMethod(a) +#define IDirect3DRMFrame3_SetMaterialOverride(p,a) (p)->SetMaterialOverride(a) +#define IDirect3DRMFrame3_GetMaterialOverride(p,a) (p)->GetMaterialOverride(a) +#endif + +/***************************************************************************** + * IDirect3DRMMesh interface + */ +#define INTERFACE IDirect3DRMMesh +DECLARE_INTERFACE_(IDirect3DRMMesh,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMMesh methods ***/ + STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE; + STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE; + STDMETHOD(AddGroup)(THIS_ unsigned vCount, unsigned fCount, unsigned vPerFace, unsigned *fData, + D3DRMGROUPINDEX *returnId) PURE; + STDMETHOD(SetVertices)(THIS_ D3DRMGROUPINDEX id, unsigned index, unsigned count, + D3DRMVERTEX *values) PURE; + STDMETHOD(SetGroupColor)(THIS_ D3DRMGROUPINDEX id, D3DCOLOR value) PURE; + STDMETHOD(SetGroupColorRGB)(THIS_ D3DRMGROUPINDEX id, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetGroupMapping)(THIS_ D3DRMGROUPINDEX id, D3DRMMAPPING value) PURE; + STDMETHOD(SetGroupQuality)(THIS_ D3DRMGROUPINDEX id, D3DRMRENDERQUALITY value) PURE; + STDMETHOD(SetGroupMaterial)(THIS_ D3DRMGROUPINDEX id, struct IDirect3DRMMaterial *material) PURE; + STDMETHOD(SetGroupTexture)(THIS_ D3DRMGROUPINDEX id, struct IDirect3DRMTexture *texture) PURE; + STDMETHOD_(unsigned, GetGroupCount)(THIS) PURE; + STDMETHOD(GetGroup)(THIS_ D3DRMGROUPINDEX id, unsigned *vCount, unsigned *fCount, unsigned *vPerFace, + DWORD *fDataSize, unsigned *fData) PURE; + STDMETHOD(GetVertices)(THIS_ D3DRMGROUPINDEX id, DWORD index, DWORD count, D3DRMVERTEX *returnPtr) PURE; + STDMETHOD_(D3DCOLOR, GetGroupColor)(THIS_ D3DRMGROUPINDEX id) PURE; + STDMETHOD_(D3DRMMAPPING, GetGroupMapping)(THIS_ D3DRMGROUPINDEX id) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetGroupQuality)(THIS_ D3DRMGROUPINDEX id) PURE; + STDMETHOD(GetGroupMaterial)(THIS_ D3DRMGROUPINDEX id, struct IDirect3DRMMaterial **material) PURE; + STDMETHOD(GetGroupTexture)(THIS_ D3DRMGROUPINDEX id, struct IDirect3DRMTexture **texture) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMMesh_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMMesh_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMMesh_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMesh_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMMesh_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMMesh_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMMesh_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMMesh_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMMesh_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMMesh_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMMesh_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMMesh methods ***/ +#define IDirect3DRMMesh_Scale(p,a,b,c) (p)->lpVtbl->Scale(p,a,b,c) +#define IDirect3DRMMesh_Translate(p,a,b,c) (p)->lpVtbl->Translate(p,a,b,c) +#define IDirect3DRMMesh_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMMesh_AddGroup(p,a,b,c,d,e) (p)->lpVtbl->AddGroup(p,a,b,c,d,e) +#define IDirect3DRMMesh_SetVertices(p,a,b,c,d) (p)->lpVtbl->SetVertices(p,a,b,c,d) +#define IDirect3DRMMesh_SetGroupColor(p,a,b) (p)->lpVtbl->SetGroupColor(p,a,b) +#define IDirect3DRMMesh_SetGroupColorRGB(p,a,b,c,d) (p)->lpVtbl->SetGroupColorRGB(p,a,b,c,d) +#define IDirect3DRMMesh_SetGroupMapping(p,a,b) (p)->lpVtbl->SetGroupMapping(p,a,b) +#define IDirect3DRMMesh_SetGroupQuality(p,a,b) (p)->lpVtbl->SetGroupQuality(p,a,b) +#define IDirect3DRMMesh_SetGroupMaterial(p,a,b) (p)->lpVtbl->SetGroupMaterial(p,a,b) +#define IDirect3DRMMesh_SetGroupTexture(p,a,b) (p)->lpVtbl->SetGroupTexture(p,a,b) +#define IDirect3DRMMesh_GetGroupCount(p) (p)->lpVtbl->GetGroupCount(p) +#define IDirect3DRMMesh_GetGroup(p,a,b,c,d,e,f) (p)->lpVtbl->GetGroup(p,a,b,c,d,e,f) +#define IDirect3DRMMesh_GetVertices(p,a,b,c,d) (p)->lpVtbl->GetVertices(p,a,b,c,d) +#define IDirect3DRMMesh_GetGroupColor(p,a) (p)->lpVtbl->GetGroupColor(p,a) +#define IDirect3DRMMesh_GetGroupMapping(p,a) (p)->lpVtbl->GetGroupMapping(p,a) +#define IDirect3DRMMesh_GetGroupQuality(p,a) (p)->lpVtbl->GetGroupQuality(p,a) +#define IDirect3DRMMesh_GetGroupMaterial(p,a,b) (p)->lpVtbl->GetGroupMaterial(p,a,b) +#define IDirect3DRMMesh_GetGroupTexture(p,a,b) (p)->lpVtbl->GetGroupTexture(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMMesh_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMMesh_AddRef(p) (p)->AddRef() +#define IDirect3DRMMesh_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMesh_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMMesh_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMMesh_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMMesh_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMMesh_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMMesh_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMMesh_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMMesh_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMMesh methods ***/ +#define IDirect3DRMMesh_Scale(p,a,b,c) (p)->Scale(a,b,c) +#define IDirect3DRMMesh_Translate(p,a,b,c) (p)->Translate(a,b,c) +#define IDirect3DRMMesh_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMMesh_AddGroup(p,a,b,c,d,e) (p)->AddGroup(a,b,c,d,e) +#define IDirect3DRMMesh_SetVertices(p,a,b,c,d) (p)->SetVertices(a,b,c,d) +#define IDirect3DRMMesh_SetGroupColor(p,a,b) (p)->SetGroupColor(a,b) +#define IDirect3DRMMesh_SetGroupColorRGB(p,a,b,c,d) (p)->SetGroupColorRGB(a,b,c,d) +#define IDirect3DRMMesh_SetGroupMapping(p,a,b) (p)->SetGroupMapping(a,b) +#define IDirect3DRMMesh_SetGroupQuality(p,a,b) (p)->SetGroupQuality(a,b) +#define IDirect3DRMMesh_SetGroupMaterial(p,a,b) (p)->SetGroupMaterial(a,b) +#define IDirect3DRMMesh_SetGroupTexture(p,a,b) (p)->SetGroupTexture(a,b) +#define IDirect3DRMMesh_GetGroupCount(p) (p)->GetGroupCount() +#define IDirect3DRMMesh_GetGroup(p,a,b,c,d,e,f) (p)->GetGroup(a,b,c,d,e,f) +#define IDirect3DRMMesh_GetVertices(p,a,b,c,d) (p)->GetVertices(a,b,c,d) +#define IDirect3DRMMesh_GetGroupColor(p,a) (p)->GetGroupColor(a) +#define IDirect3DRMMesh_GetGroupMapping(p,a) (p)->GetGroupMapping(a) +#define IDirect3DRMMesh_GetGroupQuality(p,a) (p)->GetGroupQuality(a) +#define IDirect3DRMMesh_GetGroupMaterial(p,a,b) (p)->GetGroupMaterial(a,b) +#define IDirect3DRMMesh_GetGroupTexture(p,a,b) (p)->GetGroupTexture(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMProgressiveMesh interface + */ +#define INTERFACE IDirect3DRMProgressiveMesh +DECLARE_INTERFACE_(IDirect3DRMProgressiveMesh,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMProgressiveMesh methods ***/ + STDMETHOD(Load) (THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURECALLBACK cb, void *ctx) PURE; + STDMETHOD(GetLoadStatus) (THIS_ D3DRMPMESHLOADSTATUS *status) PURE; + STDMETHOD(SetMinRenderDetail) (THIS_ D3DVALUE d3dVal) PURE; + STDMETHOD(Abort) (THIS_ DWORD flags) PURE; + STDMETHOD(GetFaceDetail) (THIS_ DWORD *count) PURE; + STDMETHOD(GetVertexDetail) (THIS_ DWORD *count) PURE; + STDMETHOD(SetFaceDetail) (THIS_ DWORD count) PURE; + STDMETHOD(SetVertexDetail) (THIS_ DWORD count) PURE; + STDMETHOD(GetFaceDetailRange) (THIS_ DWORD *min_detail, DWORD *max_detail) PURE; + STDMETHOD(GetVertexDetailRange) (THIS_ DWORD *min_detail, DWORD *max_detail) PURE; + STDMETHOD(GetDetail) (THIS_ D3DVALUE *pdvVal) PURE; + STDMETHOD(SetDetail) (THIS_ D3DVALUE d3dVal) PURE; + STDMETHOD(RegisterEvents) (THIS_ HANDLE event, DWORD flags, DWORD reserved) PURE; + STDMETHOD(CreateMesh) (THIS_ IDirect3DRMMesh **mesh) PURE; + STDMETHOD(Duplicate) (THIS_ IDirect3DRMProgressiveMesh **mesh) PURE; + STDMETHOD(GetBox) (THIS_ D3DRMBOX *box) PURE; + STDMETHOD(SetQuality) (THIS_ D3DRMRENDERQUALITY quality) PURE; + STDMETHOD(GetQuality) (THIS_ D3DRMRENDERQUALITY *quality) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMProgressiveMesh_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMProgressiveMesh_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMProgressiveMesh_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMProgressiveMesh_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMProgressiveMesh_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMProgressiveMesh_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMProgressiveMesh_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMProgressiveMesh_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMProgressiveMesh_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMProgressiveMesh_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMProgressiveMesh_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMProgressiveMesh methods ***/ +#define IDirect3DRMProgressiveMesh_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMProgressiveMesh_GetLoadStatus(p,a) (p)->lpVtbl->GetLoadStatus(p,a) +#define IDirect3DRMProgressiveMesh_SetMinRenderDetail(p,a) (p)->lpVtbl->SetMinRenderDetail(p,a) +#define IDirect3DRMProgressiveMesh_Abort(p,a) (p)->lpVtbl->Abort(p,a) +#define IDirect3DRMProgressiveMesh_GetFaceDetail(p,a) (p)->lpVtbl->GetFaceDetail(p,a) +#define IDirect3DRMProgressiveMesh_GetVertexDetail(p,a) (p)->lpVtbl->GetVertexDetail(p,a) +#define IDirect3DRMProgressiveMesh_SetFaceDetail(p,a) (p)->lpVtbl->SetFaceDetail(p,a) +#define IDirect3DRMProgressiveMesh_SetVertexDetail(p,a) (p)->lpVtbl->SetVertexDetail(p,a) +#define IDirect3DRMProgressiveMesh_GetFaceDetailRange(p,a,b) (p)->lpVtbl->GetFaceDetailRange(p,a,b) +#define IDirect3DRMProgressiveMesh_GetVertexDetailRange(p,a,b) (p)->lpVtbl->GetVertexDetailRange(p,a,b) +#define IDirect3DRMProgressiveMesh_GetDetail(p,a) (p)->lpVtbl->GetDetail(p,a) +#define IDirect3DRMProgressiveMesh_SetDetail(p,a) (p)->lpVtbl->SetDetail(p,a) +#define IDirect3DRMProgressiveMesh_RegisterEvents(p,a,b,c) (p)->lpVtbl->RegisterEvents(p,a,b,c) +#define IDirect3DRMProgressiveMesh_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +#define IDirect3DRMProgressiveMesh_Duplicate(p,a) (p)->lpVtbl->Duplicate(p,a) +#define IDirect3DRMProgressiveMesh_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMProgressiveMesh_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMProgressiveMesh_GetQuality(p,a) (p)->lpVtbl->GetQuality(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMProgressiveMesh_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMProgressiveMesh_AddRef(p) (p)->AddRef() +#define IDirect3DRMProgressiveMesh_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMProgressiveMesh_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMProgressiveMesh_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMProgressiveMesh_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMProgressiveMesh_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMProgressiveMesh_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMProgressiveMesh_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMProgressiveMesh_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMProgressiveMesh_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMProgressiveMesh methods ***/ +#define IDirect3DRMProgressiveMesh_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMProgressiveMesh_GetLoadStatus(p,a) (p)->GetLoadStatus(a) +#define IDirect3DRMProgressiveMesh_SetMinRenderDetail(p,a) (p)->SetMinRenderDetail(a) +#define IDirect3DRMProgressiveMesh_Abort(p,a) (p)->Abort(a) +#define IDirect3DRMProgressiveMesh_GetFaceDetail(p,a) (p)->GetFaceDetail(a) +#define IDirect3DRMProgressiveMesh_GetVertexDetail(p,a) (p)->GetVertexDetail(a) +#define IDirect3DRMProgressiveMesh_SetFaceDetail(p,a) (p)->SetFaceDetail(a) +#define IDirect3DRMProgressiveMesh_SetVertexDetail(p,a) (p)->SetVertexDetail(a) +#define IDirect3DRMProgressiveMesh_GetFaceDetailRange(p,a,b) (p)->GetFaceDetailRange(a,b) +#define IDirect3DRMProgressiveMesh_GetVertexDetailRange(p,a,b) (p)->GetVertexDetailRange(a,b) +#define IDirect3DRMProgressiveMesh_GetDetail(p,a) (p)->GetDetail(a) +#define IDirect3DRMProgressiveMesh_SetDetail(p,a) (p)->SetDetail(a) +#define IDirect3DRMProgressiveMesh_RegisterEvents(p,a,b,c) (p)->RegisterEvents(a,b,c) +#define IDirect3DRMProgressiveMesh_CreateMesh(p,a) (p)->CreateMesh(a) +#define IDirect3DRMProgressiveMesh_Duplicate(p,a) (p)->Duplicate(a) +#define IDirect3DRMProgressiveMesh_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMProgressiveMesh_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMProgressiveMesh_GetQuality(p,a) (p)->GetQuality(a) +#endif + +/***************************************************************************** + * IDirect3DRMShadow interface + */ +#define INTERFACE IDirect3DRMShadow +DECLARE_INTERFACE_(IDirect3DRMShadow,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMShadow methods ***/ + STDMETHOD(Init)(THIS_ IDirect3DRMVisual *visual, struct IDirect3DRMLight *light, + D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMShadow_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMShadow_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMShadow_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMShadow_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMShadow_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMShadow_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMShadow_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMShadow_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMShadow_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMShadow_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMShadow_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMShadow methods ***/ +#define IDirect3DRMShadow_Init(p,a,b,c,d,e,f,g) (p)->lpVtbl->Init(p,a,b,c,d,e,f,g) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMShadow_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMShadow_AddRef(p) (p)->AddRef() +#define IDirect3DRMShadow_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMShadow_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMShadow_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMShadow_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMShadow_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMShadow_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMShadow_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMShadow_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMShadow_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMShadow methods ***/ +#define IDirect3DRMShadow_Init(p,a,b,c,d,e,f,g) (p)->Init(a,b,c,d,e,f,g) +#endif + +/***************************************************************************** + * IDirect3DRMShadow2 interface + */ +#define INTERFACE IDirect3DRMShadow2 +DECLARE_INTERFACE_(IDirect3DRMShadow2,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMShadow methods ***/ + STDMETHOD(Init)(THIS_ IUnknown *object, struct IDirect3DRMLight *light, + D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz) PURE; + /*** IDirect3DRMShadow2 methods ***/ + STDMETHOD(GetVisual)(THIS_ IDirect3DRMVisual **visual) PURE; + STDMETHOD(SetVisual)(THIS_ IUnknown *visual, DWORD flags) PURE; + STDMETHOD(GetLight)(THIS_ struct IDirect3DRMLight **light) PURE; + STDMETHOD(SetLight)(THIS_ struct IDirect3DRMLight *light, DWORD flags) PURE; + STDMETHOD(GetPlane)(THIS_ D3DVALUE *px, D3DVALUE *py, D3DVALUE *pz, + D3DVALUE *nx, D3DVALUE *ny, D3DVALUE *nz) PURE; + STDMETHOD(SetPlane)(THIS_ D3DVALUE px, D3DVALUE py, D3DVALUE pz, + D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, DWORD) PURE; + STDMETHOD(GetOptions)(THIS_ DWORD *flags) PURE; + STDMETHOD(SetOptions)(THIS_ DWORD) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMShadow2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMShadow2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMShadow2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMShadow2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMShadow2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMShadow2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMShadow2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMShadow2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMShadow2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMShadow2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMShadow2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMShadow methods ***/ +#define IDirect3DRMShadow2_Init(p,a,b,c,d,e,f,g) (p)->lpVtbl->Init(p,a,b,c,d,e,f,g) +/*** IDirect3DRMShadow2 methods ***/ +#define IDirect3DRMShadow2_GetVisual(p,a) (p)->lpVtbl->GetVisual(p,a) +#define IDirect3DRMShadow2_SetVisual(p,a,b) (p)->lpVtbl->SetVisual(p,a,b) +#define IDirect3DRMShadow2_GetLight(p,a) (p)->lpVtbl->GetLight(p,a) +#define IDirect3DRMShadow2_SetLight(p,a,b) (p)->lpVtbl->SetLight(p,a,b) +#define IDirect3DRMShadow2_GetPlane(p,a,b,c,d,e,f) (p)->lpVtbl->GetPlane(p,a,b,c,d,e,f) +#define IDirect3DRMShadow2_SetPlane(p,a,b,c,d,e,f) (p)->lpVtbl->SetPlane(p,a,b,c,d,e,f) +#define IDirect3DRMShadow2_GetOptions(p,a) (p)->lpVtbl->GetOptions(p,a) +#define IDirect3DRMShadow2_SetOptions(p,a) (p)->lpVtbl->SetOptions(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMShadow2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMShadow2_AddRef(p) (p)->AddRef() +#define IDirect3DRMShadow2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMShadow2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMShadow2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMShadow2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMShadow2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMShadow2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMShadow2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMShadow2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMShadow2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMShadow methods ***/ +#define IDirect3DRMShadow2_Init(p,a,b,c,d,e,f,g) (p)->Init(a,b,c,d,e,f,g) +/*** IDirect3DRMShadow2 methods ***/ +#define IDirect3DRMShadow2_GetVisual(p,a) (p)->GetVisual(a) +#define IDirect3DRMShadow2_SetVisual(p,a,b) (p)->SetVisual(a,b) +#define IDirect3DRMShadow2_GetLight(p,a) (p)->GetLight(a) +#define IDirect3DRMShadow2_SetLight(p,a,b) (p)->SetLight(a,b) +#define IDirect3DRMShadow2_GetPlane(p,a,b,c,d,e,f) (p)->GetPlane(a,b,c,d,e,f) +#define IDirect3DRMShadow2_SetPlane(p,a,b,c,d,e,f) (p)->SetPlane(a,b,c,d,e,f) +#define IDirect3DRMShadow2_GetOptions(p,a) (p)->GetOptions(a) +#define IDirect3DRMShadow2_SetOptions(p,a) (p)->SetOptions(a) +#endif + +/***************************************************************************** + * IDirect3DRMFace interface + */ +#define INTERFACE IDirect3DRMFace +DECLARE_INTERFACE_(IDirect3DRMFace,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMFace methods ***/ + STDMETHOD(AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddVertexAndNormalIndexed)(THIS_ DWORD vertex, DWORD normal) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE, D3DVALUE, D3DVALUE) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetTextureCoordinates)(THIS_ DWORD vertex, D3DVALUE u, D3DVALUE v) PURE; + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial *material) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(GetVertex)(THIS_ DWORD index, D3DVECTOR *vertex, D3DVECTOR *normal) PURE; + STDMETHOD(GetVertices)(THIS_ DWORD *vertex_count, D3DVECTOR *coords, D3DVECTOR *normals); + STDMETHOD(GetTextureCoordinates)(THIS_ DWORD vertex, D3DVALUE *u, D3DVALUE *v) PURE; + STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE; + STDMETHOD(GetNormal)(THIS_ D3DVECTOR *) PURE; + STDMETHOD(GetTexture)(THIS_ struct IDirect3DRMTexture **texture) PURE; + STDMETHOD(GetMaterial)(THIS_ struct IDirect3DRMMaterial **material) PURE; + STDMETHOD_(int, GetVertexCount)(THIS) PURE; + STDMETHOD_(int, GetVertexIndex)(THIS_ DWORD which) PURE; + STDMETHOD_(int, GetTextureCoordinateIndex)(THIS_ DWORD which) PURE; + STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFace_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFace_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFace_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFace_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMFace_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMFace_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMFace_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMFace_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMFace_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMFace_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMFace_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMFace methods ***/ +#define IDirect3DRMFace_AddVertex(p,a,b,c) (p)->lpVtbl->AddVertex(p,a,b,c) +#define IDirect3DRMFace_AddVertexAndNormalIndexed(p,a,b) (p)->lpVtbl->AddVertexAndNormalIndexed(p,a,b) +#define IDirect3DRMFace_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMFace_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMFace_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMFace_SetTextureCoordinates(p,a,b,c) (p)->lpVtbl->SetTextureCoordinates(p,a,b,c) +#define IDirect3DRMFace_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMFace_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMFace_GetVertex(p,a,b,c) (p)->lpVtbl->GetVertex(p,a,b,c) +#define IDirect3DRMFace_GetVertices(p,a,b,c) (p)->lpVtbl->GetVertices(p,a,b,c) +#define IDirect3DRMFace_GetTextureCoordinates(p,a,b,c) (p)->lpVtbl->GetTextureCoordinates(p,a,b,c) +#define IDirect3DRMFace_GetTextureTopology(p,a,b) (p)->lpVtbl->GetTextureTopology(p,a,b) +#define IDirect3DRMFace_GetNormal(p,a) (p)->lpVtbl->GetNormal(p,a) +#define IDirect3DRMFace_GetTexture(p,a) (p)->lpVtbl->GetTexture(p,a) +#define IDirect3DRMFace_GetVertexCount(p) (p)->lpVtbl->GetVertexCount(p) +#define IDirect3DRMFace_GetVertexIndex(p,a) (p)->lpVtbl->GetVertexIndex(p,a) +#define IDirect3DRMFace_GetTextureCoordinateIndex(p,a) (p)->lpVtbl->GetTextureCoordinateIndex(p,a) +#define IDirect3DRMFace_GetColor(p) (p)->lpVtbl->GetColor(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFace_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFace_AddRef(p) (p)->AddRef() +#define IDirect3DRMFace_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFace_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMFace_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMFace_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMFace_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMFace_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMFace_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMFace_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMFace_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMFace methods ***/ +#define IDirect3DRMFace_AddVertex(p,a,b,c) (p)->AddVertex(a,b,c) +#define IDirect3DRMFace_AddVertexAndNormalIndexed(p,a,b) (p)->AddVertexAndNormalIndexed(a,b) +#define IDirect3DRMFace_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMFace_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMFace_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMFace_SetTextureCoordinates(p,a,b,c) (p)->SetTextureCoordinates(a,b,c) +#define IDirect3DRMFace_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMFace_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMFace_GetVertex(p,a,b,c) (p)->GetVertex(a,b,c) +#define IDirect3DRMFace_GetVertices(p,a,b,c) (p)->GetVertices(a,b,c) +#define IDirect3DRMFace_GetTextureCoordinates(p,a,b,c) (p)->GetTextureCoordinates(a,b,c) +#define IDirect3DRMFace_GetTextureTopology(p,a,b) (p)->GetTextureTopology(a,b) +#define IDirect3DRMFace_GetNormal(p,a) (p)->GetNormal(a) +#define IDirect3DRMFace_GetTexture(p,a) (p)->GetTexture(a) +#define IDirect3DRMFace_GetVertexCount(p) (p)->GetVertexCount() +#define IDirect3DRMFace_GetVertexIndex(p,a) (p)->GetVertexIndex(a) +#define IDirect3DRMFace_GetTextureCoordinateIndex(p,a) (p)->GetTextureCoordinateIndex(a) +#define IDirect3DRMFace_GetColor(p) (p)->GetColor() +#endif + +/***************************************************************************** + * IDirect3DRMFace2 interface + */ +#define INTERFACE IDirect3DRMFace2 +DECLARE_INTERFACE_(IDirect3DRMFace2,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMFace methods ***/ + STDMETHOD(AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddVertexAndNormalIndexed)(THIS_ DWORD vertex, DWORD normal) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE, D3DVALUE, D3DVALUE) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture3 *texture) PURE; + STDMETHOD(SetTextureCoordinates)(THIS_ DWORD vertex, D3DVALUE u, D3DVALUE v) PURE; + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial2 *material) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(GetVertex)(THIS_ DWORD index, D3DVECTOR *vertex, D3DVECTOR *normal) PURE; + STDMETHOD(GetVertices)(THIS_ DWORD *vertex_count, D3DVECTOR *coords, D3DVECTOR *normals); + STDMETHOD(GetTextureCoordinates)(THIS_ DWORD vertex, D3DVALUE *u, D3DVALUE *v) PURE; + STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE; + STDMETHOD(GetNormal)(THIS_ D3DVECTOR *) PURE; + STDMETHOD(GetTexture)(THIS_ struct IDirect3DRMTexture3 **texture) PURE; + STDMETHOD(GetMaterial)(THIS_ struct IDirect3DRMMaterial2 **material) PURE; + STDMETHOD_(int, GetVertexCount)(THIS) PURE; + STDMETHOD_(int, GetVertexIndex)(THIS_ DWORD which) PURE; + STDMETHOD_(int, GetTextureCoordinateIndex)(THIS_ DWORD which) PURE; + STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFace2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFace2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFace2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFace2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMFace2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMFace2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMFace2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMFace2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMFace2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMFace2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMFace2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMFace methods ***/ +#define IDirect3DRMFace2_AddVertex(p,a,b,c) (p)->lpVtbl->AddVertex(p,a,b,c) +#define IDirect3DRMFace2_AddVertexAndNormalIndexed(p,a,b) (p)->lpVtbl->AddVertexAndNormalIndexed(p,a,b) +#define IDirect3DRMFace2_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMFace2_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMFace2_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMFace2_SetTextureCoordinates(p,a,b,c) (p)->lpVtbl->SetTextureCoordinates(p,a,b,c) +#define IDirect3DRMFace2_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMFace2_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMFace2_GetVertex(p,a,b,c) (p)->lpVtbl->GetVertex(p,a,b,c) +#define IDirect3DRMFace2_GetVertices(p,a,b,c) (p)->lpVtbl->GetVertices(p,a,b,c) +#define IDirect3DRMFace2_GetTextureCoordinates(p,a,b,c) (p)->lpVtbl->GetTextureCoordinates(p,a,b,c) +#define IDirect3DRMFace2_GetTextureTopology(p,a,b) (p)->lpVtbl->GetTextureTopology(p,a,b) +#define IDirect3DRMFace2_GetNormal(p,a) (p)->lpVtbl->GetNormal(p,a) +#define IDirect3DRMFace2_GetTexture(p,a) (p)->lpVtbl->GetTexture(p,a) +#define IDirect3DRMFace2_GetVertexCount(p) (p)->lpVtbl->GetVertexCount(p) +#define IDirect3DRMFace2_GetVertexIndex(p,a) (p)->lpVtbl->GetVertexIndex(p,a) +#define IDirect3DRMFace2_GetTextureCoordinateIndex(p,a) (p)->lpVtbl->GetTextureCoordinateIndex(p,a) +#define IDirect3DRMFace2_GetColor(p) (p)->lpVtbl->GetColor(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFace2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFace2_AddRef(p) (p)->AddRef() +#define IDirect3DRMFace2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMFace2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMFace2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMFace2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMFace2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMFace2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMFace2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMFace2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMFace2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMFace methods ***/ +#define IDirect3DRMFace2_AddVertex(p,a,b,c) (p)->AddVertex(a,b,c) +#define IDirect3DRMFace2_AddVertexAndNormalIndexed(p,a,b) (p)->AddVertexAndNormalIndexed(a,b) +#define IDirect3DRMFace2_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMFace2_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMFace2_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMFace2_SetTextureCoordinates(p,a,b,c) (p)->SetTextureCoordinates(a,b,c) +#define IDirect3DRMFace2_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMFace2_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMFace2_GetVertex(p,a,b,c) (p)->GetVertex(a,b,c) +#define IDirect3DRMFace2_GetVertices(p,a,b,c) (p)->GetVertices(a,b,c) +#define IDirect3DRMFace2_GetTextureCoordinates(p,a,b,c) (p)->GetTextureCoordinates(a,b,c) +#define IDirect3DRMFace2_GetTextureTopology(p,a,b) (p)->GetTextureTopology(a,b) +#define IDirect3DRMFace2_GetNormal(p,a) (p)->GetNormal(a) +#define IDirect3DRMFace2_GetTexture(p,a) (p)->GetTexture(a) +#define IDirect3DRMFace2_GetVertexCount(p) (p)->GetVertexCount() +#define IDirect3DRMFace2_GetVertexIndex(p,a) (p)->GetVertexIndex(a) +#define IDirect3DRMFace2_GetTextureCoordinateIndex(p,a) (p)->GetTextureCoordinateIndex(a) +#define IDirect3DRMFace2_GetColor(p) (p)->GetColor() +#endif + +/***************************************************************************** + * IDirect3DRMMeshBuilder interface + */ +#define INTERFACE IDirect3DRMMeshBuilder +DECLARE_INTERFACE_(IDirect3DRMMeshBuilder,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMMeshBuilder methods ***/ + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURECALLBACK cb, void *ctx) PURE; + STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT, D3DRMSAVEOPTIONS save) PURE; + STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE; + STDMETHOD(SetColorSource)(THIS_ D3DRMCOLORSOURCE) PURE; + STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE; + STDMETHOD(GenerateNormals)(THIS) PURE; + STDMETHOD_(D3DRMCOLORSOURCE, GetColorSource)(THIS) PURE; + STDMETHOD(AddMesh)(THIS_ IDirect3DRMMesh *mesh) PURE; + STDMETHOD(AddMeshBuilder)(THIS_ IDirect3DRMMeshBuilder *mesh_builder) PURE; + STDMETHOD(AddFrame)(THIS_ IDirect3DRMFrame *frame) PURE; + STDMETHOD(AddFace)(THIS_ IDirect3DRMFace *face) PURE; + STDMETHOD(AddFaces)(THIS_ DWORD vertex_count, D3DVECTOR *vertices, DWORD normal_count, + D3DVECTOR *normals, DWORD *face_data, struct IDirect3DRMFaceArray **array) PURE; + STDMETHOD(ReserveSpace)(THIS_ DWORD vertex_Count, DWORD normal_count, DWORD face_count) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial *material) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE; + STDMETHOD(SetPerspective)(THIS_ BOOL) PURE; + STDMETHOD(SetVertex)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetNormal)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetTextureCoordinates)(THIS_ DWORD index, D3DVALUE u, D3DVALUE v) PURE; + STDMETHOD(SetVertexColor)(THIS_ DWORD index, D3DCOLOR) PURE; + STDMETHOD(SetVertexColorRGB)(THIS_ DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(GetFaces)(THIS_ struct IDirect3DRMFaceArray **array) PURE; + STDMETHOD(GetVertices)(THIS_ DWORD *vcount, D3DVECTOR *vertices, DWORD *ncount, D3DVECTOR *normals, + DWORD *face_data_size, DWORD *face_data) PURE; + STDMETHOD(GetTextureCoordinates)(THIS_ DWORD index, D3DVALUE *u, D3DVALUE *v) PURE; + STDMETHOD_(int, AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD_(int, AddNormal)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace **face) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE; + STDMETHOD_(BOOL, GetPerspective)(THIS) PURE; + STDMETHOD_(int, GetFaceCount)(THIS) PURE; + STDMETHOD_(int, GetVertexCount)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetVertexColor)(THIS_ DWORD index) PURE; + STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMMeshBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMMeshBuilder_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMMeshBuilder_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMeshBuilder_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMMeshBuilder_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMMeshBuilder_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMMeshBuilder_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMMeshBuilder_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMMeshBuilder_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMMeshBuilder_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMMeshBuilder_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMMeshBuilder methods ***/ +#define IDirect3DRMMeshBuilder_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMMeshBuilder_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#define IDirect3DRMMeshBuilder_Scale(p,a,b,c) (p)->lpVtbl->Scale(p,a,b,c) +#define IDirect3DRMMeshBuilder_Translate(p,a,b,c) (p)->lpVtbl->Translate(p,a) +#define IDirect3DRMMeshBuilder_SetColorSource(p,a) (p)->lpVtbl->SetColorSource(p,a,b,c) +#define IDirect3DRMMeshBuilder_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMMeshBuilder_GenerateNormals(p) (p)->lpVtbl->GenerateNormals(p) +#define IDirect3DRMMeshBuilder_GetColorSource(p) (p)->lpVtbl->GetColorSource(p) +#define IDirect3DRMMeshBuilder_AddMesh(p,a) (p)->lpVtbl->AddMesh(p,a) +#define IDirect3DRMMeshBuilder_AddMeshBuilder(p,a) (p)->lpVtbl->AddMeshBuilder(p,a) +#define IDirect3DRMMeshBuilder_AddFrame(p,a) (p)->lpVtbl->AddFrame(p,a) +#define IDirect3DRMMeshBuilder_AddFace(p,a) (p)->lpVtbl->AddFace(p,a) +#define IDirect3DRMMeshBuilder_AddFaces(p,a,b,c,d,e,f) (p)->lpVtbl->AddFaces(p,a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder_ReserveSpace(p,a,b,c) (p)->lpVtbl->ReserveSpace(p,a,b,c) +#define IDirect3DRMMeshBuilder_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMMeshBuilder_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMMeshBuilder_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMMeshBuilder_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMMeshBuilder_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMMeshBuilder_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMMeshBuilder_SetPerspective(p,a) (p)->lpVtbl->SetPerspective(p,a) +#define IDirect3DRMMeshBuilder_SetVertex(p,a,b,c,d) (p)->lpVtbl->SetVertex(p,a,b,c,d) +#define IDirect3DRMMeshBuilder_SetNormal(p,a,b,c,d) (p)->lpVtbl->SetNormal(p,a,b,c,d) +#define IDirect3DRMMeshBuilder_SetTextureCoordinates(p,a,b,c) (p)->lpVtbl->SetTextureCoordinates(p,a,b,c) +#define IDirect3DRMMeshBuilder_SetVertexColor(p,a,b) (p)->lpVtbl->SetVertexColor(p,a,b) +#define IDirect3DRMMeshBuilder_SetVertexColorRGB(p,a,b,c,d) (p)->lpVtbl->SetVertexColorRGB(p,a,b,c,d) +#define IDirect3DRMMeshBuilder_GetFaces(p,a) (p)->lpVtbl->GetFaces(p,a) +#define IDirect3DRMMeshBuilder_GetVertices(p,a,b,c,d,e,f) (p)->lpVtbl->GetVertices(p,a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder_GetTextureCoordinates(p,a,b,c) (p)->lpVtbl->GetTextureCoordinates(p,a,b,c) +#define IDirect3DRMMeshBuilder_AddVertex(p,a,b,c) (p)->lpVtbl->AddVertex(p,a,b,c) +#define IDirect3DRMMeshBuilder_AddNormal(p,a,b,c) (p)->lpVtbl->AddNormal(p,a,b,c) +#define IDirect3DRMMeshBuilder_CreateFace(p,a) (p)->lpVtbl->CreateFace(p,a) +#define IDirect3DRMMeshBuilder_GetQuality(p) (p)->lpVtbl->GetQuality(p) +#define IDirect3DRMMeshBuilder_GetPerspective(p) (p)->lpVtbl->GetPerspective(p) +#define IDirect3DRMMeshBuilder_GetFaceCount(p) (p)->lpVtbl->GetFaceCount(p) +#define IDirect3DRMMeshBuilder_GetVertexCount(p) (p)->lpVtbl->GetVertexCount(p) +#define IDirect3DRMMeshBuilder_GetVertexColor(p,a) (p)->lpVtbl->GetVertexColor(p,a) +#define IDirect3DRMMeshBuilder_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMMeshBuilder_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMMeshBuilder_AddRef(p) (p)->AddRef() +#define IDirect3DRMMeshBuilder_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMeshBuilder_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMMeshBuilder_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMMeshBuilder_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMMeshBuilder_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMMeshBuilder_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMMeshBuilder_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMMeshBuilder_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMMeshBuilder_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMMeshBuilder methods ***/ +#define IDirect3DRMMeshBuilder_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMMeshBuilder_Save(p,a,b,c) (p)->Save(a,b,c) +#define IDirect3DRMMeshBuilder_Scale(p,a,b,c) (p)->Scale(a,b,c) +#define IDirect3DRMMeshBuilder_Translate(p,a,b,c) (p)->Translate(a) +#define IDirect3DRMMeshBuilder_SetColorSource(p,a) (p)->SetColorSource(a,b,c) +#define IDirect3DRMMeshBuilder_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMMeshBuilder_GenerateNormals(p) (p)->GenerateNormals() +#define IDirect3DRMMeshBuilder_GetColorSource(p) (p)->GetColorSource() +#define IDirect3DRMMeshBuilder_AddMesh(p,a) (p)-->AddMesh(a) +#define IDirect3DRMMeshBuilder_AddMeshBuilder(p,a) (p)->AddMeshBuilder(a) +#define IDirect3DRMMeshBuilder_AddFrame(p,a) (p)->AddFrame(a) +#define IDirect3DRMMeshBuilder_AddFace(p,a) (p)->AddFace(a) +#define IDirect3DRMMeshBuilder_AddFaces(p,a,b,c,d,e,f) (p)->AddFaces(a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder_ReserveSpace(p,a,b,c) (p)->ReserveSpace(a,b,c) +#define IDirect3DRMMeshBuilder_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMMeshBuilder_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMMeshBuilder_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMMeshBuilder_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMMeshBuilder_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMMeshBuilder_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMMeshBuilder_SetPerspective(p,a) (p)->SetPerspective(a) +#define IDirect3DRMMeshBuilder_SetVertex(p,a,b,c,d) (p)->SetVertex(a,b,c,d) +#define IDirect3DRMMeshBuilder_SetNormal(p,a,b,c,d) (p)->SetNormal(a,b,c,d) +#define IDirect3DRMMeshBuilder_SetTextureCoordinates(p,a,b,c) (p)->SetTextureCoordinates(a,b,c) +#define IDirect3DRMMeshBuilder_SetVertexColor(p,a,b) (p)->SetVertexColor(a,b) +#define IDirect3DRMMeshBuilder_SetVertexColorRGB(p,a,b,c,d) (p)->SetVertexColorRGB(a,b,c,d) +#define IDirect3DRMMeshBuilder_GetFaces(p,a) (p)->GetFaces(a) +#define IDirect3DRMMeshBuilder_GetVertices(p,a,b,c,d,e,f) (p)->GetVertices(a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder_GetTextureCoordinates(p,a,b,c) (p)->GetTextureCoordinates(a,b,c) +#define IDirect3DRMMeshBuilder_AddVertex(p,a,b,c) (p)->AddVertex(a,b,c) +#define IDirect3DRMMeshBuilder_AddNormal(p,a,b,c) (p)->AddNormal(a,b,c) +#define IDirect3DRMMeshBuilder_CreateFace(p,a) (p)->CreateFace(a) +#define IDirect3DRMMeshBuilder_GetQuality(p) (p)->GetQuality() +#define IDirect3DRMMeshBuilder_GetPerspective(p) (p)->GetPerspective() +#define IDirect3DRMMeshBuilder_GetFaceCount(p) (p)->GetFaceCount() +#define IDirect3DRMMeshBuilder_GetVertexCount(p) (p)->GetVertexCount() +#define IDirect3DRMMeshBuilder_GetVertexColor(p,a) (p)->GetVertexColor(a) +#define IDirect3DRMMeshBuilder_CreateMesh(p,a) (p)->CreateMesh(a) +#endif + +/***************************************************************************** + * IDirect3DRMMeshBuilder2 interface + */ +#define INTERFACE IDirect3DRMMeshBuilder2 +DECLARE_INTERFACE_(IDirect3DRMMeshBuilder2,IDirect3DRMMeshBuilder) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMMeshBuilder methods ***/ + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURECALLBACK cb, void *ctx) PURE; + STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT, D3DRMSAVEOPTIONS save) PURE; + STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE; + STDMETHOD(SetColorSource)(THIS_ D3DRMCOLORSOURCE) PURE; + STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE; + STDMETHOD(GenerateNormals)(THIS) PURE; + STDMETHOD_(D3DRMCOLORSOURCE, GetColorSource)(THIS) PURE; + STDMETHOD(AddMesh)(THIS_ IDirect3DRMMesh *mesh) PURE; + STDMETHOD(AddMeshBuilder)(THIS_ IDirect3DRMMeshBuilder *mesh_builder) PURE; + STDMETHOD(AddFrame)(THIS_ IDirect3DRMFrame *frame) PURE; + STDMETHOD(AddFace)(THIS_ IDirect3DRMFace *face) PURE; + STDMETHOD(AddFaces)(THIS_ DWORD vertex_count, D3DVECTOR *vertices, DWORD normal_count, + D3DVECTOR *normals, DWORD *face_data, struct IDirect3DRMFaceArray **array) PURE; + STDMETHOD(ReserveSpace)(THIS_ DWORD vertex_Count, DWORD normal_count, DWORD face_count) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture *texture) PURE; + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial *material) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE; + STDMETHOD(SetPerspective)(THIS_ BOOL) PURE; + STDMETHOD(SetVertex)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetNormal)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetTextureCoordinates)(THIS_ DWORD index, D3DVALUE u, D3DVALUE v) PURE; + STDMETHOD(SetVertexColor)(THIS_ DWORD index, D3DCOLOR) PURE; + STDMETHOD(SetVertexColorRGB)(THIS_ DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(GetFaces)(THIS_ struct IDirect3DRMFaceArray **array) PURE; + STDMETHOD(GetVertices)(THIS_ DWORD *vcount, D3DVECTOR *vertices, DWORD *ncount, D3DVECTOR *normals, + DWORD *face_data_size, DWORD *face_data) PURE; + STDMETHOD(GetTextureCoordinates)(THIS_ DWORD index, D3DVALUE *u, D3DVALUE *v) PURE; + STDMETHOD_(int, AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD_(int, AddNormal)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace **face) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE; + STDMETHOD_(BOOL, GetPerspective)(THIS) PURE; + STDMETHOD_(int, GetFaceCount)(THIS) PURE; + STDMETHOD_(int, GetVertexCount)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetVertexColor)(THIS_ DWORD index) PURE; + STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE; + /*** IDirect3DRMMeshBuilder2 methods ***/ + STDMETHOD(GenerateNormals2)(THIS_ D3DVALUE crease, DWORD flags) PURE; + STDMETHOD(GetFace)(THIS_ DWORD index, IDirect3DRMFace **face) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMMeshBuilder2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMMeshBuilder2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMMeshBuilder2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMeshBuilder2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMMeshBuilder2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMMeshBuilder2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMMeshBuilder2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMMeshBuilder2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMMeshBuilder2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMMeshBuilder2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMMeshBuilder2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMMeshBuilder methods ***/ +#define IDirect3DRMMeshBuilder2_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMMeshBuilder2_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#define IDirect3DRMMeshBuilder2_Scale(p,a,b,c) (p)->lpVtbl->Scale(p,a,b,c) +#define IDirect3DRMMeshBuilder2_Translate(p,a,b,c) (p)->lpVtbl->Translate(p,a) +#define IDirect3DRMMeshBuilder2_SetColorSource(p,a) (p)->lpVtbl->SetColorSource(p,a,b,c) +#define IDirect3DRMMeshBuilder2_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMMeshBuilder2_GenerateNormals(p) (p)->lpVtbl->GenerateNormals(p) +#define IDirect3DRMMeshBuilder2_GetColorSource(p) (p)->lpVtbl->GetColorSource(p) +#define IDirect3DRMMeshBuilder2_AddMesh(p,a) (p)->lpVtbl->AddMesh(p,a) +#define IDirect3DRMMeshBuilder2_AddMeshBuilder(p,a) (p)->lpVtbl->AddMeshBuilder(p,a) +#define IDirect3DRMMeshBuilder2_AddFrame(p,a) (p)->lpVtbl->AddFrame(p,a) +#define IDirect3DRMMeshBuilder2_AddFace(p,a) (p)->lpVtbl->AddFace(p,a) +#define IDirect3DRMMeshBuilder2_AddFaces(p,a,b,c,d,e,f) (p)->lpVtbl->AddFaces(p,a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder2_ReserveSpace(p,a,b,c) (p)->lpVtbl->ReserveSpace(p,a,b,c) +#define IDirect3DRMMeshBuilder2_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMMeshBuilder2_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMMeshBuilder2_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMMeshBuilder2_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMMeshBuilder2_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMMeshBuilder2_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMMeshBuilder2_SetPerspective(p,a) (p)->lpVtbl->SetPerspective(p,a) +#define IDirect3DRMMeshBuilder2_SetVertex(p,a,b,c,d) (p)->lpVtbl->SetVertex(p,a,b,c,d) +#define IDirect3DRMMeshBuilder2_SetNormal(p,a,b,c,d) (p)->lpVtbl->SetNormal(p,a,b,c,d) +#define IDirect3DRMMeshBuilder2_SetTextureCoordinates(p,a,b,c) (p)->lpVtbl->SetTextureCoordinates(p,a,b,c) +#define IDirect3DRMMeshBuilder2_SetVertexColor(p,a,b) (p)->lpVtbl->SetVertexColor(p,a,b) +#define IDirect3DRMMeshBuilder2_SetVertexColorRGB(p,a,b,c,d) (p)->lpVtbl->SetVertexColorRGB(p,a,b,c,d) +#define IDirect3DRMMeshBuilder2_GetFaces(p,a) (p)->lpVtbl->GetFaces(p,a) +#define IDirect3DRMMeshBuilder2_GetVertices(p,a,b,c,d,e,f) (p)->lpVtbl->GetVertices(p,a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder2_GetTextureCoordinates(p,a,b,c) (p)->lpVtbl->GetTextureCoordinates(p,a,b,c) +#define IDirect3DRMMeshBuilder2_AddVertex(p,a,b,c) (p)->lpVtbl->AddVertex(p,a,b,c) +#define IDirect3DRMMeshBuilder2_AddNormal(p,a,b,c) (p)->lpVtbl->AddNormal(p,a,b,c) +#define IDirect3DRMMeshBuilder2_CreateFace(p,a) (p)->lpVtbl->CreateFace(p,a) +#define IDirect3DRMMeshBuilder2_GetQuality(p) (p)->lpVtbl->GetQuality(p) +#define IDirect3DRMMeshBuilder2_GetPerspective(p) (p)->lpVtbl->GetPerspective(p) +#define IDirect3DRMMeshBuilder2_GetFaceCount(p) (p)->lpVtbl->GetFaceCount(p) +#define IDirect3DRMMeshBuilder2_GetVertexCount(p) (p)->lpVtbl->GetVertexCount(p) +#define IDirect3DRMMeshBuilder2_GetVertexColor(p,a) (p)->lpVtbl->GetVertexColor(p,a) +#define IDirect3DRMMeshBuilder2_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +/*** IDirect3DRMMeshBuilder2 methods ***/ +#define IDirect3DRMMeshBuilder2_GenerateNormals2(p,a,b) (p)->lpVtbl->GenerateNormals2(p,a,b) +#define IDirect3DRMMeshBuilder2_GetFace(p,a,b) (p)->lpVtbl->GetFace(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMMeshBuilder2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMMeshBuilder2_AddRef(p) (p)->AddRef() +#define IDirect3DRMMeshBuilder2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMeshBuilder2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMMeshBuilder2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMMeshBuilder2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMMeshBuilder2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMMeshBuilder2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMMeshBuilder2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMMeshBuilder2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMMeshBuilder2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMMeshBuilder methods ***/ +#define IDirect3DRMMeshBuilder2_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMMeshBuilder2_Save(p,a,b,c) (p)->Save(a,b,c) +#define IDirect3DRMMeshBuilder2_Scale(p,a,b,c) (p)->Scale(a,b,c) +#define IDirect3DRMMeshBuilder2_Translate(p,a,b,c) (p)->Translate(a) +#define IDirect3DRMMeshBuilder2_SetColorSource(p,a) (p)->SetColorSource(a,b,c) +#define IDirect3DRMMeshBuilder2_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMMeshBuilder2_GenerateNormals(p) (p)->GenerateNormals() +#define IDirect3DRMMeshBuilder2_GetColorSource(p) (p)->GetColorSource() +#define IDirect3DRMMeshBuilder2_AddMesh(p,a) (p)-->AddMesh(a) +#define IDirect3DRMMeshBuilder2_AddMeshBuilder(p,a) (p)->AddMeshBuilder(a) +#define IDirect3DRMMeshBuilder2_AddFrame(p,a) (p)->AddFrame(a) +#define IDirect3DRMMeshBuilder2_AddFace(p,a) (p)->AddFace(a) +#define IDirect3DRMMeshBuilder2_AddFaces(p,a,b,c,d,e,f) (p)->AddFaces(a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder2_ReserveSpace(p,a,b,c) (p)->ReserveSpace(a,b,c) +#define IDirect3DRMMeshBuilder2_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMMeshBuilder2_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMMeshBuilder2_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMMeshBuilder2_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMMeshBuilder2_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMMeshBuilder2_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMMeshBuilder2_SetPerspective(p,a) (p)->SetPerspective(a) +#define IDirect3DRMMeshBuilder2_SetVertex(p,a,b,c,d) (p)->SetVertex(a,b,c,d) +#define IDirect3DRMMeshBuilder2_SetNormal(p,a,b,c,d) (p)->SetNormal(a,b,c,d) +#define IDirect3DRMMeshBuilder2_SetTextureCoordinates(p,a,b,c) (p)->SetTextureCoordinates(a,b,c) +#define IDirect3DRMMeshBuilder2_SetVertexColor(p,a,b) (p)->SetVertexColor(a,b) +#define IDirect3DRMMeshBuilder2_SetVertexColorRGB(p,a,b,c,d) (p)->SetVertexColorRGB(a,b,c,d) +#define IDirect3DRMMeshBuilder2_GetFaces(p,a) (p)->GetFaces(a) +#define IDirect3DRMMeshBuilder2_GetVertices(p,a,b,c,d,e,f) (p)->GetVertices(a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder2_GetTextureCoordinates(p,a,b,c) (p)->GetTextureCoordinates(a,b,c) +#define IDirect3DRMMeshBuilder2_AddVertex(p,a,b,c) (p)->AddVertex(a,b,c) +#define IDirect3DRMMeshBuilder2_AddNormal(p,a,b,c) (p)->AddNormal(a,b,c) +#define IDirect3DRMMeshBuilder2_CreateFace(p,a) (p)->CreateFace(a) +#define IDirect3DRMMeshBuilder2_GetQuality(p) (p)->GetQuality() +#define IDirect3DRMMeshBuilder2_GetPerspective(p) (p)->GetPerspective() +#define IDirect3DRMMeshBuilder2_GetFaceCount(p) (p)->GetFaceCount() +#define IDirect3DRMMeshBuilder2_GetVertexCount(p) (p)->GetVertexCount() +#define IDirect3DRMMeshBuilder2_GetVertexColor(p,a) (p)->GetVertexColor(a) +#define IDirect3DRMMeshBuilder2_CreateMesh(p,a) (p)->CreateMesh(a) +/*** IDirect3DRMMeshBuilder2 methods ***/ +#define IDirect3DRMMeshBuilder2_GenerateNormals2(p,a,b) (p)->GenerateNormals2(a,b) +#define IDirect3DRMMeshBuilder2_GetFace(p,a,b) (p)->GetFace(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMMeshBuilder3 interface + */ +#define INTERFACE IDirect3DRMMeshBuilder3 +DECLARE_INTERFACE_(IDirect3DRMMeshBuilder3,IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMMeshBuilder3 methods ***/ + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURE3CALLBACK cb, void *ctx) PURE; + STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT, D3DRMSAVEOPTIONS save) PURE; + STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE; + STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE; + STDMETHOD(SetColorSource)(THIS_ D3DRMCOLORSOURCE) PURE; + STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE; + STDMETHOD(GenerateNormals)(THIS_ D3DVALUE crease, DWORD flags) PURE; + STDMETHOD_(D3DRMCOLORSOURCE, GetColorSource)(THIS) PURE; + STDMETHOD(AddMesh)(THIS_ IDirect3DRMMesh *mesh) PURE; + STDMETHOD(AddMeshBuilder)(THIS_ IDirect3DRMMeshBuilder3 *mesh_builder, DWORD flags) PURE; + STDMETHOD(AddFrame)(THIS_ IDirect3DRMFrame3 *frame) PURE; + STDMETHOD(AddFace)(THIS_ IDirect3DRMFace2 *face) PURE; + STDMETHOD(AddFaces)(THIS_ DWORD vertex_count, D3DVECTOR *vertices, DWORD normal_count, + D3DVECTOR *normals, DWORD *face_data, struct IDirect3DRMFaceArray **array) PURE; + STDMETHOD(ReserveSpace)(THIS_ DWORD vertex_Count, DWORD normal_count, DWORD face_count) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetTexture)(THIS_ struct IDirect3DRMTexture3 *texture) PURE; + STDMETHOD(SetMaterial)(THIS_ struct IDirect3DRMMaterial2 *material) PURE; + STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE; + STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE; + STDMETHOD(SetPerspective)(THIS_ BOOL) PURE; + STDMETHOD(SetVertex)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetNormal)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(SetTextureCoordinates)(THIS_ DWORD index, D3DVALUE u, D3DVALUE v) PURE; + STDMETHOD(SetVertexColor)(THIS_ DWORD index, D3DCOLOR) PURE; + STDMETHOD(SetVertexColorRGB)(THIS_ DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(GetFaces)(THIS_ struct IDirect3DRMFaceArray **array) PURE; + STDMETHOD(GetGeometry)(THIS_ DWORD *vcount, D3DVECTOR *vertices, DWORD *ncount, D3DVECTOR *normals, + DWORD *face_data_size, DWORD *face_data) PURE; + STDMETHOD(GetTextureCoordinates)(THIS_ DWORD index, D3DVALUE *u, D3DVALUE *v) PURE; + STDMETHOD_(int, AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD_(int, AddNormal)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace2 **face) PURE; + STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE; + STDMETHOD_(BOOL, GetPerspective)(THIS) PURE; + STDMETHOD_(int, GetFaceCount)(THIS) PURE; + STDMETHOD_(int, GetVertexCount)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetVertexColor)(THIS_ DWORD index) PURE; + STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE; + STDMETHOD(GetFace)(THIS_ DWORD index, IDirect3DRMFace2 **face) PURE; + STDMETHOD(GetVertex)(THIS_ DWORD index, D3DVECTOR *vector) PURE; + STDMETHOD(GetNormal)(THIS_ DWORD index, D3DVECTOR *vector) PURE; + STDMETHOD(DeleteVertices)(THIS_ DWORD IndexFirst, DWORD count) PURE; + STDMETHOD(DeleteNormals)(THIS_ DWORD IndexFirst, DWORD count) PURE; + STDMETHOD(DeleteFace)(THIS_ IDirect3DRMFace2 *face) PURE; + STDMETHOD(Empty)(THIS_ DWORD flags) PURE; + STDMETHOD(Optimize)(THIS_ DWORD flags) PURE; + STDMETHOD(AddFacesIndexed)(THIS_ DWORD flags, DWORD *pvIndices, DWORD *pIndexFirst, DWORD *pCount) PURE; + STDMETHOD(CreateSubMesh)(THIS_ IUnknown **mesh) PURE; + STDMETHOD(GetParentMesh)(THIS_ DWORD flags, IUnknown **parent) PURE; + STDMETHOD(GetSubMeshes)(THIS_ DWORD *count, IUnknown **meshes) PURE; + STDMETHOD(DeleteSubMesh)(THIS_ IUnknown *mesh) PURE; + STDMETHOD(Enable)(THIS_ DWORD) PURE; + STDMETHOD(GetEnable)(THIS_ DWORD *) PURE; + STDMETHOD(AddTriangles)(THIS_ DWORD flags, DWORD format, DWORD vertex_count, void *data) PURE; + STDMETHOD(SetVertices)(THIS_ DWORD start_idx, DWORD count, D3DVECTOR *v) PURE; + STDMETHOD(GetVertices)(THIS_ DWORD start_idx, DWORD *count, D3DVECTOR *v) PURE; + STDMETHOD(SetNormals)(THIS_ DWORD start_idx, DWORD count, D3DVECTOR *v) PURE; + STDMETHOD(GetNormals)(THIS_ DWORD start_idx, DWORD *count, D3DVECTOR *v) PURE; + STDMETHOD_(int, GetNormalCount)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMMeshBuilder3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMMeshBuilder3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMMeshBuilder3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMeshBuilder3_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMMeshBuilder3_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMMeshBuilder3_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMMeshBuilder3_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMMeshBuilder3_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMMeshBuilder3_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMMeshBuilder3_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMMeshBuilder3_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) + +/*** IDirect3DRMMeshBuilder3 methods ***/ +#define IDirect3DRMMeshBuilder3_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DRMMeshBuilder3_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#define IDirect3DRMMeshBuilder3_Scale(p,a,b,c) (p)->lpVtbl->Scale(p,a,b,c) +#define IDirect3DRMMeshBuilder3_Translate(p,a,b,c) (p)->lpVtbl->Translate(p,a) +#define IDirect3DRMMeshBuilder3_SetColorSource(p,a) (p)->lpVtbl->SetColorSource(p,a,b,c) +#define IDirect3DRMMeshBuilder3_GetBox(p,a) (p)->lpVtbl->GetBox(p,a) +#define IDirect3DRMMeshBuilder3_GenerateNormals(p,a,b) (p)->lpVtbl->GenerateNormals(p,a,b) +#define IDirect3DRMMeshBuilder3_GetColorSource(p) (p)->lpVtbl->GetColorSource(p) +#define IDirect3DRMMeshBuilder3_AddMesh(p,a) (p)->lpVtbl->AddMesh(p,a) +#define IDirect3DRMMeshBuilder3_AddMeshBuilder(p,a) (p)->lpVtbl->AddMeshBuilder(p,a) +#define IDirect3DRMMeshBuilder3_AddFrame(p,a) (p)->lpVtbl->AddFrame(p,a) +#define IDirect3DRMMeshBuilder3_AddFace(p,a) (p)->lpVtbl->AddFace(p,a) +#define IDirect3DRMMeshBuilder3_AddFaces(p,a,b,c,d,e,f) (p)->lpVtbl->AddFaces(p,a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder3_ReserveSpace(p,a,b,c) (p)->lpVtbl->ReserveSpace(p,a,b,c) +#define IDirect3DRMMeshBuilder3_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMMeshBuilder3_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMMeshBuilder3_SetTexture(p,a) (p)->lpVtbl->SetTexture(p,a) +#define IDirect3DRMMeshBuilder3_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DRMMeshBuilder3_SetTextureTopology(p,a,b) (p)->lpVtbl->SetTextureTopology(p,a,b) +#define IDirect3DRMMeshBuilder3_SetQuality(p,a) (p)->lpVtbl->SetQuality(p,a) +#define IDirect3DRMMeshBuilder3_SetPerspective(p,a) (p)->lpVtbl->SetPerspective(p,a) +#define IDirect3DRMMeshBuilder3_SetVertex(p,a,b,c,d) (p)->lpVtbl->SetVertex(p,a,b,c,d) +#define IDirect3DRMMeshBuilder3_SetNormal(p,a,b,c,d) (p)->lpVtbl->SetNormal(p,a,b,c,d) +#define IDirect3DRMMeshBuilder3_SetTextureCoordinates(p,a,b,c) (p)->lpVtbl->SetTextureCoordinates(p,a,b,c) +#define IDirect3DRMMeshBuilder3_SetVertexColor(p,a,b) (p)->lpVtbl->SetVertexColor(p,a,b) +#define IDirect3DRMMeshBuilder3_SetVertexColorRGB(p,a,b,c,d) (p)->lpVtbl->SetVertexColorRGB(p,a,b,c,d) +#define IDirect3DRMMeshBuilder3_GetFaces(p,a) (p)->lpVtbl->GetFaces(p,a) +#define IDirect3DRMMeshBuilder3_GetGeometry(p,a,b,c,d,e,f) (p)->lpVtbl->GetGeometry(p,a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder3_GetTextureCoordinates(p,a,b,c) (p)->lpVtbl->GetTextureCoordinates(p,a,b,c) +#define IDirect3DRMMeshBuilder3_AddVertex(p,a,b,c) (p)->lpVtbl->AddVertex(p,a,b,c) +#define IDirect3DRMMeshBuilder3_AddNormal(p,a,b,c) (p)->lpVtbl->AddNormal(p,a,b,c) + +#define IDirect3DRMMeshBuilder3_CreateFace(p,a) (p)->lpVtbl->CreateFace(p,a) +#define IDirect3DRMMeshBuilder3_GetQuality(p) (p)->lpVtbl->GetQuality(p) +#define IDirect3DRMMeshBuilder3_GetPerspective(p) (p)->lpVtbl->GetPerspective(p) + +#define IDirect3DRMMeshBuilder3_GetFaceCount(p) (p)->lpVtbl->GetFaceCount(p) +#define IDirect3DRMMeshBuilder3_GetVertexCount(p) (p)->lpVtbl->GetVertexCount(p) +#define IDirect3DRMMeshBuilder3_GetVertexColor(p,a) (p)->lpVtbl->GetVertexColor(p,a) +#define IDirect3DRMMeshBuilder3_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) +#define IDirect3DRMMeshBuilder3_GetFace(p,a,b) (p)->lpVtbl->GetFace(p,a,b) +#define IDirect3DRMMeshBuilder3_GetVertex(p,a,b) (p)->lpVtbl->GetVertex(p,a,b) +#define IDirect3DRMMeshBuilder3_GetNormal(p,a,b) (p)->lpVtbl->GetNormal(p,a,b) +#define IDirect3DRMMeshBuilder3_DeleteVertices(p,a,b) (p)->lpVtbl->DeleteVertices(p,a,b) +#define IDirect3DRMMeshBuilder3_DeleteNormals(p,a,b) (p)->lpVtbl->DeleteNormals(p,a,b) +#define IDirect3DRMMeshBuilder3_DeleteFace(p,a) (p)->lpVtbl->DeleteFace(p,a) +#define IDirect3DRMMeshBuilder3_Empty(p,a) (p)->lpVtbl->Empty(p,a) +#define IDirect3DRMMeshBuilder3_Optimize(p,a) (p)->lpVtbl->Optimize(p,a) +#define IDirect3DRMMeshBuilder3_AddFacesIndexed(p,a,b,c,d) (p)->lpVtbl->AddFacesIndexed(p,a,b,c,d) +#define IDirect3DRMMeshBuilder3_CreateSubMesh(p,a) (p)->lpVtbl->CreateSubMesh(p,a) +#define IDirect3DRMMeshBuilder3_GetParentMesh(p,a,b) (p)->lpVtbl->GetParentMesh(p,a,b) +#define IDirect3DRMMeshBuilder3_GetSubMeshes(p,a,b) (p)->lpVtbl->GetSubMeshes(p,a,b) +#define IDirect3DRMMeshBuilder3_DeleteSubMesh(p,a) (p)->lpVtbl->DeleteSubMesh(p,a) +#define IDirect3DRMMeshBuilder3_Enable(p,a) (p)->lpVtbl->Enable(p,a) +#define IDirect3DRMMeshBuilder3_AddTriangles(p,a,b,c,d) (p)->lpVtbl->AddTriangles(p,a,b,c,d) +#define IDirect3DRMMeshBuilder3_SetVertices(p,a,b,c) (p)->lpVtbl->SetVertices(p,a,b,c) +#define IDirect3DRMMeshBuilder3_GetVertices(p,a,b,c) (p)->lpVtbl->GetVertices(p,a,b,c) +#define IDirect3DRMMeshBuilder3_SetNormals(p,a,b,c) (p)->lpVtbl->SetNormals(p,a,b,c) +#define IDirect3DRMMeshBuilder3_GetNormals(p,a,b,c) (p)->lpVtbl->GetNormals(p,a,b,c) +#define IDirect3DRMMeshBuilder3_GetNormalCount(p) (p)->lpVtbl->GetNormalCount(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMMeshBuilder3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMMeshBuilder3_AddRef(p) (p)->AddRef() +#define IDirect3DRMMeshBuilder3_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMeshBuilder3_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMMeshBuilder3_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMMeshBuilder3_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMMeshBuilder3_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMMeshBuilder3_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMMeshBuilder3_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMMeshBuilder3_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMMeshBuilder3_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMMeshBuilder3 methods ***/ +#define IDirect3DRMMeshBuilder3_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DRMMeshBuilder3_Save(p,a,b,c) (p)->Save(a,b,c) +#define IDirect3DRMMeshBuilder3_Scale(p,a,b,c) (p)->Scale(a,b,c) +#define IDirect3DRMMeshBuilder3_Translate(p,a,b,c) (p)->Translate(a) +#define IDirect3DRMMeshBuilder3_SetColorSource(p,a) (p)->SetColorSource(a,b,c) +#define IDirect3DRMMeshBuilder3_GetBox(p,a) (p)->GetBox(a) +#define IDirect3DRMMeshBuilder3_GenerateNormals(p,a,b) (p)->GenerateNormals(a,b) +#define IDirect3DRMMeshBuilder3_GetColorSource(p) (p)->GetColorSource() +#define IDirect3DRMMeshBuilder3_AddMesh(p,a) (p)-->AddMesh(a) +#define IDirect3DRMMeshBuilder3_AddMeshBuilder(p,a) (p)->AddMeshBuilder(a) +#define IDirect3DRMMeshBuilder3_AddFrame(p,a) (p)->AddFrame(a) +#define IDirect3DRMMeshBuilder3_AddFace(p,a) (p)->AddFace(a) +#define IDirect3DRMMeshBuilder3_AddFaces(p,a,b,c,d,e,f) (p)->AddFaces(a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder3_ReserveSpace(p,a,b,c) (p)->ReserveSpace(a,b,c) +#define IDirect3DRMMeshBuilder3_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMMeshBuilder3_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMMeshBuilder3_SetTexture(p,a) (p)->SetTexture(a) +#define IDirect3DRMMeshBuilder3_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DRMMeshBuilder3_SetTextureTopology(p,a,b) (p)->SetTextureTopology(a,b) +#define IDirect3DRMMeshBuilder3_SetQuality(p,a) (p)->SetQuality(a) +#define IDirect3DRMMeshBuilder3_SetPerspective(p,a) (p)->SetPerspective(a) +#define IDirect3DRMMeshBuilder3_SetVertex(p,a,b,c,d) (p)->SetVertex(a,b,c,d) +#define IDirect3DRMMeshBuilder3_SetNormal(p,a,b,c,d) (p)->SetNormal(a,b,c,d) +#define IDirect3DRMMeshBuilder3_SetTextureCoordinates(p,a,b,c) (p)->SetTextureCoordinates(a,b,c) +#define IDirect3DRMMeshBuilder3_SetVertexColor(p,a,b) (p)->SetVertexColor(a,b) +#define IDirect3DRMMeshBuilder3_SetVertexColorRGB(p,a,b,c,d) (p)->SetVertexColorRGB(a,b,c,d) +#define IDirect3DRMMeshBuilder3_GetFaces(p,a) (p)->GetFaces(a) +#define IDirect3DRMMeshBuilder3_GetGeometry(p,a,b,c,d,e,f) (p)->GetGeometry(a,b,c,d,e,f) +#define IDirect3DRMMeshBuilder3_GetTextureCoordinates(p,a,b,c) (p)->GetTextureCoordinates(a,b,c) +#define IDirect3DRMMeshBuilder3_AddVertex(p,a,b,c) (p)->AddVertex(a,b,c) +#define IDirect3DRMMeshBuilder3_AddNormal(p,a,b,c) (p)->AddNormal(a,b,c) +#define IDirect3DRMMeshBuilder3_CreateFace(p,a) (p)->CreateFace(a) + +#define IDirect3DRMMeshBuilder3_GetQuality(p) (p)->GetQuality() +#define IDirect3DRMMeshBuilder3_GetPerspective(p) (p)->GetPerspective() +#define IDirect3DRMMeshBuilder3_GetFaceCount(p) (p)->GetFaceCount() +#define IDirect3DRMMeshBuilder3_GetVertexCount(p) (p)->GetVertexCount() +#define IDirect3DRMMeshBuilder3_GetVertexColor(p,a) (p)->GetVertexColor(a) +#define IDirect3DRMMeshBuilder3_CreateMesh(p,a) (p)->CreateMesh(a) +#define IDirect3DRMMeshBuilder3_GetFace(p,a,b) (p)->GetFace(a,b) +#define IDirect3DRMMeshBuilder3_GetVertex(p,a,b) (p)->GetVertex(a,b) +#define IDirect3DRMMeshBuilder3_GetNormal(p,a,b) (p)->GetNormal(a,b) +#define IDirect3DRMMeshBuilder3_DeleteVertices(p,a,b) (p)->DeleteVertices(a,b) +#define IDirect3DRMMeshBuilder3_DeleteNormals(p,a,b) (p)->DeleteNormals(a,b) +#define IDirect3DRMMeshBuilder3_DeleteFace(p,a) (p)->DeleteFace(a) +#define IDirect3DRMMeshBuilder3_Empty(p,a) (p)->Empty(a) +#define IDirect3DRMMeshBuilder3_Optimize(p,a) (p)->Optimize(a) +#define IDirect3DRMMeshBuilder3_AddFacesIndexed(p,a,b,c,d) (p)->AddFacesIndexed(a,b,c,d) +#define IDirect3DRMMeshBuilder3_CreateSubMesh(p,a) (p)->CreateSubMesh(a) +#define IDirect3DRMMeshBuilder3_GetParentMesh(p,a,b) (p)->GetParentMesh(a,b) +#define IDirect3DRMMeshBuilder3_GetSubMeshes(p,a,b) (p)->GetSubMeshes(a,b) +#define IDirect3DRMMeshBuilder3_DeleteSubMesh(p,a) (p)->DeleteSubMesh(a) +#define IDirect3DRMMeshBuilder3_Enable(p,a) (p)->Enable(a) +#define IDirect3DRMMeshBuilder3_AddTriangles(p,a,b,c,d) (p)->AddTriangles(a,b,c,d) +#define IDirect3DRMMeshBuilder3_SetVertices(p,a,b,c) (p)->SetVertices(a,b,c) +#define IDirect3DRMMeshBuilder3_GetVertices(p,a,b,c) (p)->GetVertices(a,b,c) +#define IDirect3DRMMeshBuilder3_SetNormals(p,a,b,c) (p)->SetNormals(a,b,c) +#define IDirect3DRMMeshBuilder3_GetNormals(p,a,b,c) (p)->GetNormals(a,b,c) +#define IDirect3DRMMeshBuilder3_GetNormalCount(p) (p)->GetNormalCount() +#endif + +/***************************************************************************** + * IDirect3DRMLight interface + */ +#define INTERFACE IDirect3DRMLight +DECLARE_INTERFACE_(IDirect3DRMLight,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMLight methods ***/ + STDMETHOD(SetType)(THIS_ D3DRMLIGHTTYPE) PURE; + STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE; + STDMETHOD(SetRange)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetUmbra)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetPenumbra)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetConstantAttenuation)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetLinearAttenuation)(THIS_ D3DVALUE) PURE; + STDMETHOD(SetQuadraticAttenuation)(THIS_ D3DVALUE) PURE; + STDMETHOD_(D3DVALUE, GetRange)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetUmbra)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetPenumbra)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetConstantAttenuation)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetLinearAttenuation)(THIS) PURE; + STDMETHOD_(D3DVALUE, GetQuadraticAttenuation)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE; + STDMETHOD_(D3DRMLIGHTTYPE, GetType)(THIS) PURE; + STDMETHOD(SetEnableFrame)(THIS_ IDirect3DRMFrame *frame) PURE; + STDMETHOD(GetEnableFrame)(THIS_ IDirect3DRMFrame **frame) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMLight_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMLight_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMLight_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMLight_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMLight_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMLight_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMLight_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMLight_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMLight_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMLight_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMLight_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMLight methods ***/ +#define IDirect3DRMLight_SetType(p,a) (p)->lpVtbl->SetType(p,a) +#define IDirect3DRMLight_SetColor(p,a) (p)->lpVtbl->SetColor(p,a) +#define IDirect3DRMLight_SetColorRGB(p,a,b,c) (p)->lpVtbl->SetColorRGB(p,a,b,c) +#define IDirect3DRMLight_SetRange(p,a) (p)->lpVtbl->SetRange(p,a) +#define IDirect3DRMLight_SetUmbra(p,a) (p)->lpVtbl->SetUmbra(p,a) +#define IDirect3DRMLight_SetPenumbra(p,a) (p)->lpVtbl->SetPenumbra(p,a) +#define IDirect3DRMLight_SetConstantAttenuation(p,a) (p)->lpVtbl->SetConstantAttenuation(p,a) +#define IDirect3DRMLight_SetLinearAttenuation(p,a) (p)->lpVtbl->SetLinearAttenuation(p,a) +#define IDirect3DRMLight_SetQuadraticAttenuation(p,a) (p)->lpVtbl->SetQuadraticAttenuation(p,a) +#define IDirect3DRMLight_GetRange(p) (p)->lpVtbl->GetRange(p) +#define IDirect3DRMLight_GetUmbra(p) (p)->lpVtbl->GetUmbra(p) +#define IDirect3DRMLight_GetPenumbra(p) (p)->lpVtbl->GetPenumbra(p) +#define IDirect3DRMLight_GetConstantAttenuation(p) (p)->lpVtbl->GetConstantAttenuation(p) +#define IDirect3DRMLight_GetLinearAttenuation(p) (p)->lpVtbl->GetLinearAttenuation(p) +#define IDirect3DRMLight_GetQuadraticAttenuation(p) (p)->lpVtbl->GetQuadraticAttenuation(p) +#define IDirect3DRMLight_GetColor(p) (p)->lpVtbl->GetColor(p) +#define IDirect3DRMLight_GetType(p) (p)->lpVtbl->GetType(p) +#define IDirect3DRMLight_SetEnableFrame(p,a) (p)->lpVtbl->SetEnableFrame(p,a) +#define IDirect3DRMLight_GetEnableFrame(p,a) (p)->lpVtbl->GetEnableFrame(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMLight_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMLight_AddRef(p) (p)->AddRef() +#define IDirect3DRMLight_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMLight_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMLight_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMLight_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMLight_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMLight_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMLight_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMLight_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMLight_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMLight methods ***/ +#define IDirect3DRMLight_SetType(p,a) (p)->SetType(a) +#define IDirect3DRMLight_SetColor(p,a) (p)->SetColor(a) +#define IDirect3DRMLight_SetColorRGB(p,a,b,c) (p)->SetColorRGB(a,b,c) +#define IDirect3DRMLight_SetRange(p,a) (p)->SetRange(a) +#define IDirect3DRMLight_SetUmbra(p,a) (p)->SetUmbra(a) +#define IDirect3DRMLight_SetPenumbra(p,a) (p)->SetPenumbra(a) +#define IDirect3DRMLight_SetConstantAttenuation(p,a) (p)->SetConstantAttenuation(a) +#define IDirect3DRMLight_SetLinearAttenuation(p,a) (p)->SetLinearAttenuation(a) +#define IDirect3DRMLight_SetQuadraticAttenuation(p,a) (p)->SetQuadraticAttenuation(a) +#define IDirect3DRMLight_GetRange(p) (p)->GetRange() +#define IDirect3DRMLight_GetUmbra(p) (p)->GetUmbra() +#define IDirect3DRMLight_GetPenumbra(p) (p)->GetPenumbra() +#define IDirect3DRMLight_GetConstantAttenuation(p) (p)->GetConstantAttenuation() +#define IDirect3DRMLight_GetLinearAttenuation(p) (p)->GetLinearAttenuation() +#define IDirect3DRMLight_GetQuadraticAttenuation(p) (p)->GetQuadraticAttenuation() +#define IDirect3DRMLight_GetColor(p) (p)->GetColor() +#define IDirect3DRMLight_GetType(p) (p)->GetType() +#define IDirect3DRMLight_SetEnableFrame(p,a) (p)->SetEnableFrame(a) +#define IDirect3DRMLight_GetEnableFrame(p,a) (p)->GetEnableFrame(a) +#endif + +/***************************************************************************** + * IDirect3DRMTexture interface + */ +#define INTERFACE IDirect3DRMTexture +DECLARE_INTERFACE_(IDirect3DRMTexture, IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMTexture methods ***/ + STDMETHOD(InitFromFile)(THIS_ const char *filename) PURE; + STDMETHOD(InitFromSurface)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(InitFromResource)(THIS_ HRSRC) PURE; + STDMETHOD(Changed)(THIS_ BOOL pixels, BOOL palette) PURE; + STDMETHOD(SetColors)(THIS_ DWORD) PURE; + STDMETHOD(SetShades)(THIS_ DWORD) PURE; + STDMETHOD(SetDecalSize)(THIS_ D3DVALUE width, D3DVALUE height) PURE; + STDMETHOD(SetDecalOrigin)(THIS_ LONG x, LONG y) PURE; + STDMETHOD(SetDecalScale)(THIS_ DWORD) PURE; + STDMETHOD(SetDecalTransparency)(THIS_ BOOL) PURE; + STDMETHOD(SetDecalTransparentColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(GetDecalSize)(THIS_ D3DVALUE *width_return, D3DVALUE *height_return) PURE; + STDMETHOD(GetDecalOrigin)(THIS_ LONG *x_return, LONG *y_return) PURE; + STDMETHOD_(D3DRMIMAGE *, GetImage)(THIS) PURE; + STDMETHOD_(DWORD, GetShades)(THIS) PURE; + STDMETHOD_(DWORD, GetColors)(THIS) PURE; + STDMETHOD_(DWORD, GetDecalScale)(THIS) PURE; + STDMETHOD_(BOOL, GetDecalTransparency)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetDecalTransparentColor)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMTexture_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMTexture_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMTexture_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMTexture_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMTexture_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMTexture_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMTexture_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMTexture_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMTexture_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMTexture_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMTexture_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMTexture methods ***/ +#define IDirect3DRMTexture_InitFromFile(p,a) (p)->lpVtbl->InitFromFile(p,a) +#define IDirect3DRMTexture_InitFromSurface(p,a) (p)->lpVtbl->InitFromSurface(p,a) +#define IDirect3DRMTexture_InitFromResource(p,a) (p)->lpVtbl->InitFromResource(p,a) +#define IDirect3DRMTexture_Changed(p,a,b) (p)->lpVtbl->Changed(p,a,b) +#define IDirect3DRMTexture_SetColors(p,a) (p)->lpVtbl->SetColors(p,a) +#define IDirect3DRMTexture_SetShades(p,a) (p)->lpVtbl->SetShades(p,a) +#define IDirect3DRMTexture_SetDecalSize(p,a,b) (p)->lpVtbl->SetDecalSize(p,a,b) +#define IDirect3DRMTexture_SetDecalOrigin(p,a,b) (p)->lpVtbl->SetDecalOrigin(p,a,b) +#define IDirect3DRMTexture_SetDecalScale(p,a) (p)->lpVtbl->SetDecalScale(p,a) +#define IDirect3DRMTexture_SetDecalTransparency(p,a) (p)->lpVtbl->SetDecalTransparency(p,a) +#define IDirect3DRMTexture_SetDecalTransparentColor(p,a) (p)->lpVtbl->SetDecalTransparentColor(p,a) +#define IDirect3DRMTexture_GetDecalSize(p,a,b) (p)->lpVtbl->GetDecalSize(p,a,b) +#define IDirect3DRMTexture_GetDecalOrigin(p,a,b) (p)->lpVtbl->GetDecalOrigin(p,a,b) +#define IDirect3DRMTexture_GetImage(p) (p)->lpVtbl->GetImage(p) +#define IDirect3DRMTexture_GetShades(p) (p)->lpVtbl->GetShades(p) +#define IDirect3DRMTexture_GetColors(p) (p)->lpVtbl->GetColors(p) +#define IDirect3DRMTexture_GetDecalScale(p) (p)->lpVtbl->GetDecalScale(p) +#define IDirect3DRMTexture_GetDecalTransparency(p) (p)->lpVtbl->GetDecalTransparency(p) +#define IDirect3DRMTexture_GetDecalTransparencyColor(p) (p)->lpVtbl->GetDecalTransparencyColor(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMTexture_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMTexture_AddRef(p) (p)->AddRef() +#define IDirect3DRMTexture_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMTexture_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMTexture_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMTexture_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMTexture_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMTexture_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMTexture_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMTexture_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMTexture_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMTexture methods ***/ +#define IDirect3DRMTexture_InitFromFile(p,a) (p)->InitFromFile(a) +#define IDirect3DRMTexture_InitFromSurface(p,a) (p)->InitFromSurface(a) +#define IDirect3DRMTexture_InitFromResource(p,a) (p)->InitFromResource(a) +#define IDirect3DRMTexture_Changed(p,a,b) (p)->Changed(a,b) +#define IDirect3DRMTexture_SetColors(p,a) (p)->SetColors(a) +#define IDirect3DRMTexture_SetShades(p,a) (p)->SetShades(a) +#define IDirect3DRMTexture_SetDecalSize(p,a,b) (p)->SetDecalSize(a,b) +#define IDirect3DRMTexture_SetDecalOrigin(p,a,b) (p)->SetDecalOrigin(a,b) +#define IDirect3DRMTexture_SetDecalScale(p,a) (p)->SetDecalScale(a) +#define IDirect3DRMTexture_SetDecalTransparency(p,a) (p)->SetDecalTransparency(a) +#define IDirect3DRMTexture_SetDecalTransparentColor(p,a) (p)->SetDecalTransparentColor(a) +#define IDirect3DRMTexture_GetDecalSize(p,a,b) (p)->GetDecalSize(a,b) +#define IDirect3DRMTexture_GetDecalOrigin(p,a,b) (p)->GetDecalOrigin(a,b) +#define IDirect3DRMTexture_GetImage(p) (p)->GetImage() +#define IDirect3DRMTexture_GetShades(p) (p)->GetShades() +#define IDirect3DRMTexture_GetColors(p) (p)->GetColors() +#define IDirect3DRMTexture_GetDecalScale(p) (p)->GetDecalScale() +#define IDirect3DRMTexture_GetDecalTransparency(p) (p)->GetDecalTransparency() +#define IDirect3DRMTexture_GetDecalTransparentColor(p) (p)->GetDecalTransparentColor() +#endif + +/***************************************************************************** + * IDirect3DRMTexture2 interface + */ +#define INTERFACE IDirect3DRMTexture2 +DECLARE_INTERFACE_(IDirect3DRMTexture2, IDirect3DRMTexture) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMTexture methods ***/ + STDMETHOD(InitFromFile)(THIS_ const char *filename) PURE; + STDMETHOD(InitFromSurface)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(InitFromResource)(THIS_ HRSRC) PURE; + STDMETHOD(Changed)(THIS_ BOOL pixels, BOOL palette) PURE; + STDMETHOD(SetColors)(THIS_ DWORD) PURE; + STDMETHOD(SetShades)(THIS_ DWORD) PURE; + STDMETHOD(SetDecalSize)(THIS_ D3DVALUE width, D3DVALUE height) PURE; + STDMETHOD(SetDecalOrigin)(THIS_ LONG x, LONG y) PURE; + STDMETHOD(SetDecalScale)(THIS_ DWORD) PURE; + STDMETHOD(SetDecalTransparency)(THIS_ BOOL) PURE; + STDMETHOD(SetDecalTransparentColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(GetDecalSize)(THIS_ D3DVALUE *width_return, D3DVALUE *height_return) PURE; + STDMETHOD(GetDecalOrigin)(THIS_ LONG *x_return, LONG *y_return) PURE; + STDMETHOD_(D3DRMIMAGE *, GetImage)(THIS) PURE; + STDMETHOD_(DWORD, GetShades)(THIS) PURE; + STDMETHOD_(DWORD, GetColors)(THIS) PURE; + STDMETHOD_(DWORD, GetDecalScale)(THIS) PURE; + STDMETHOD_(BOOL, GetDecalTransparency)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetDecalTransparentColor)(THIS) PURE; + /*** IDirect3DRMTexture2 methods ***/ + STDMETHOD(InitFromImage)(THIS_ D3DRMIMAGE *image) PURE; + STDMETHOD(InitFromResource2)(THIS_ HMODULE module, const char *name, const char *type) PURE; + STDMETHOD(GenerateMIPMap)(THIS_ DWORD) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMTexture2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMTexture2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMTexture2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMTexture2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMTexture2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMTexture2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMTexture2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMTexture2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMTexture2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMTexture2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMTexture2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMTexture methods ***/ +#define IDirect3DRMTexture2_InitFromFile(p,a) (p)->lpVtbl->InitFromFile(p,a) +#define IDirect3DRMTexture2_InitFromSurface(p,a) (p)->lpVtbl->InitFromSurface(p,a) +#define IDirect3DRMTexture2_InitFromResource(p,a) (p)->lpVtbl->InitFromResource(p,a) +#define IDirect3DRMTexture2_Changed(p,a,b) (p)->lpVtbl->Changed(p,a,b) +#define IDirect3DRMTexture2_SetColors(p,a) (p)->lpVtbl->SetColors(p,a) +#define IDirect3DRMTexture2_SetShades(p,a) (p)->lpVtbl->SetShades(p,a) +#define IDirect3DRMTexture2_SetDecalSize(p,a,b) (p)->lpVtbl->SetDecalSize(p,a,b) +#define IDirect3DRMTexture2_SetDecalOrigin(p,a,b) (p)->lpVtbl->SetDecalOrigin(p,a,b) +#define IDirect3DRMTexture2_SetDecalScale(p,a) (p)->lpVtbl->SetDecalScale(p,a) +#define IDirect3DRMTexture2_SetDecalTransparency(p,a) (p)->lpVtbl->SetDecalTransparency(p,a) +#define IDirect3DRMTexture2_SetDecalTransparentColor(p,a) (p)->lpVtbl->SetDecalTransparentColor(p,a) +#define IDirect3DRMTexture2_GetDecalSize(p,a,b) (p)->lpVtbl->GetDecalSize(p,a,b) +#define IDirect3DRMTexture2_GetDecalOrigin(p,a,b) (p)->lpVtbl->GetDecalOrigin(p,a,b) +#define IDirect3DRMTexture2_GetImage(p) (p)->lpVtbl->GetImage(p) +#define IDirect3DRMTexture2_GetShades(p) (p)->lpVtbl->GetShades(p) +#define IDirect3DRMTexture2_GetColors(p) (p)->lpVtbl->GetColors(p) +#define IDirect3DRMTexture2_GetDecalScale(p) (p)->lpVtbl->GetDecalScale(p) +#define IDirect3DRMTexture2_GetDecalTransparency(p) (p)->lpVtbl->GetDecalTransparency(p) +#define IDirect3DRMTexture2_GetDecalTransparencyColor(p) (p)->lpVtbl->GetDecalTransparencyColor(p) +/*** IDirect3DRMTexture2 methods ***/ +#define IDirect3DRMTexture2_InitFromImage(p,a) (p)->lpVtbl->InitFromImage(p,a) +#define IDirect3DRMTexture2_InitFromResource2(p,a,b,c) (p)->lpVtbl->InitFromResource2(p,a,b,c) +#define IDirect3DRMTexture2_GenerateMIPMap(p,a) (p)->lpVtbl->GenerateMIPMap(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMTexture2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMTexture2_AddRef(p) (p)->AddRef() +#define IDirect3DRMTexture2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMTexture2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMTexture2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMTexture2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMTexture2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMTexture2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMTexture2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMTexture2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMTexture2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMTexture methods ***/ +#define IDirect3DRMTexture2_InitFromFile(p,a) (p)->InitFromFile(a) +#define IDirect3DRMTexture2_InitFromSurface(p,a) (p)->InitFromSurface(a) +#define IDirect3DRMTexture2_InitFromResource(p,a) (p)->InitFromResource(a) +#define IDirect3DRMTexture2_Changed(p,a,b) (p)->Changed(a,b) +#define IDirect3DRMTexture2_SetColors(p,a) (p)->SetColors(a) +#define IDirect3DRMTexture2_SetShades(p,a) (p)->SetShades(a) +#define IDirect3DRMTexture2_SetDecalSize(p,a,b) (p)->SetDecalSize(a,b) +#define IDirect3DRMTexture2_SetDecalOrigin(p,a,b) (p)->SetDecalOrigin(a,b) +#define IDirect3DRMTexture2_SetDecalScale(p,a) (p)->SetDecalScale(a) +#define IDirect3DRMTexture2_SetDecalTransparency(p,a) (p)->SetDecalTransparency(a) +#define IDirect3DRMTexture2_SetDecalTransparentColor(p,a) (p)->SetDecalTransparentColor(a) +#define IDirect3DRMTexture2_GetDecalSize(p,a,b) (p)->GetDecalSize(a,b) +#define IDirect3DRMTexture2_GetDecalOrigin(p,a,b) (p)->GetDecalOrigin(a,b) +#define IDirect3DRMTexture2_GetImage(p) (p)->GetImage() +#define IDirect3DRMTexture2_GetShades(p) (p)->GetShades() +#define IDirect3DRMTexture2_GetColors(p) (p)->GetColors() +#define IDirect3DRMTexture2_GetDecalScale(p) (p)->GetDecalScale() +#define IDirect3DRMTexture2_GetDecalTransparency(p) (p)->GetDecalTransparency() +#define IDirect3DRMTexture2_GetDecalTransparentColor(p) (p)->GetDecalTransparentColor() +/*** IDirect3DRMTexture2 methods ***/ +#define IDirect3DRMTexture2_InitFromImage(p,a) (p)->InitFromImage(a) +#define IDirect3DRMTexture2_InitFromResource2(p,a,b,c) (p)->InitFromResource2(a,b,c) +#define IDirect3DRMTexture2_GenerateMIPMap(p,a) (p)->GenerateMIPMap(a) +#endif + +/***************************************************************************** + * IDirect3DRMTexture3 interface + */ +#define INTERFACE IDirect3DRMTexture3 +DECLARE_INTERFACE_(IDirect3DRMTexture3, IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMTexture3 methods ***/ + STDMETHOD(InitFromFile)(THIS_ const char *filename) PURE; + STDMETHOD(InitFromSurface)(THIS_ IDirectDrawSurface *surface) PURE; + STDMETHOD(InitFromResource)(THIS_ HRSRC) PURE; + STDMETHOD(Changed)(THIS_ DWORD flags, DWORD rect_count, RECT *rects) PURE; + STDMETHOD(SetColors)(THIS_ DWORD) PURE; + STDMETHOD(SetShades)(THIS_ DWORD) PURE; + STDMETHOD(SetDecalSize)(THIS_ D3DVALUE width, D3DVALUE height) PURE; + STDMETHOD(SetDecalOrigin)(THIS_ LONG x, LONG y) PURE; + STDMETHOD(SetDecalScale)(THIS_ DWORD) PURE; + STDMETHOD(SetDecalTransparency)(THIS_ BOOL) PURE; + STDMETHOD(SetDecalTransparentColor)(THIS_ D3DCOLOR) PURE; + STDMETHOD(GetDecalSize)(THIS_ D3DVALUE *width_return, D3DVALUE *height_return) PURE; + STDMETHOD(GetDecalOrigin)(THIS_ LONG *x_return, LONG *y_return) PURE; + STDMETHOD_(D3DRMIMAGE *, GetImage)(THIS) PURE; + STDMETHOD_(DWORD, GetShades)(THIS) PURE; + STDMETHOD_(DWORD, GetColors)(THIS) PURE; + STDMETHOD_(DWORD, GetDecalScale)(THIS) PURE; + STDMETHOD_(BOOL, GetDecalTransparency)(THIS) PURE; + STDMETHOD_(D3DCOLOR, GetDecalTransparentColor)(THIS) PURE; + STDMETHOD(InitFromImage)(THIS_ D3DRMIMAGE *image) PURE; + STDMETHOD(InitFromResource2)(THIS_ HMODULE module, const char *name, const char *type) PURE; + STDMETHOD(GenerateMIPMap)(THIS_ DWORD) PURE; + STDMETHOD(GetSurface)(THIS_ DWORD flags, IDirectDrawSurface **surface) PURE; + STDMETHOD(SetCacheOptions)(THIS_ LONG lImportance, DWORD dwFlags) PURE; + STDMETHOD(GetCacheOptions)(THIS_ LONG *importance, DWORD *flags) PURE; + STDMETHOD(SetDownsampleCallback)(THIS_ D3DRMDOWNSAMPLECALLBACK cb, void *ctx) PURE; + STDMETHOD(SetValidationCallback)(THIS_ D3DRMVALIDATIONCALLBACK cb, void *ctx) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMTexture3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMTexture3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMTexture3_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMTexture3_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMTexture3_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMTexture3_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMTexture3_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMTexture3_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMTexture3_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMTexture3_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMTexture3_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMTexture3 methods ***/ +#define IDirect3DRMTexture3_InitFromFile(p,a) (p)->lpVtbl->InitFromFile(p,a) +#define IDirect3DRMTexture3_InitFromSurface(p,a) (p)->lpVtbl->InitFromSurface(p,a) +#define IDirect3DRMTexture3_InitFromResource(p,a) (p)->lpVtbl->InitFromResource(p,a) +#define IDirect3DRMTexture3_Changed(p,a,b,c) (p)->lpVtbl->Changed(p,a,b,c) +#define IDirect3DRMTexture3_SetColors(p,a) (p)->lpVtbl->SetColors(p,a) +#define IDirect3DRMTexture3_SetShades(p,a) (p)->lpVtbl->SetShades(p,a) +#define IDirect3DRMTexture3_SetDecalSize(p,a,b) (p)->lpVtbl->SetDecalSize(p,a,b) +#define IDirect3DRMTexture3_SetDecalOrigin(p,a,b) (p)->lpVtbl->SetDecalOrigin(p,a,b) +#define IDirect3DRMTexture3_SetDecalScale(p,a) (p)->lpVtbl->SetDecalScale(p,a) +#define IDirect3DRMTexture3_SetDecalTransparency(p,a) (p)->lpVtbl->SetDecalTransparency(p,a) +#define IDirect3DRMTexture3_SetDecalTransparentColor(p,a) (p)->lpVtbl->SetDecalTransparentColor(p,a) +#define IDirect3DRMTexture3_GetDecalSize(p,a,b) (p)->lpVtbl->GetDecalSize(p,a,b) +#define IDirect3DRMTexture3_GetDecalOrigin(p,a,b) (p)->lpVtbl->GetDecalOrigin(p,a,b) +#define IDirect3DRMTexture3_GetImage(p) (p)->lpVtbl->GetImage(p) +#define IDirect3DRMTexture3_GetShades(p) (p)->lpVtbl->GetShades(p) +#define IDirect3DRMTexture3_GetColors(p) (p)->lpVtbl->GetColors(p) +#define IDirect3DRMTexture3_GetDecalScale(p) (p)->lpVtbl->GetDecalScale(p) +#define IDirect3DRMTexture3_GetDecalTransparency(p) (p)->lpVtbl->GetDecalTransparency(p) +#define IDirect3DRMTexture3_GetDecalTransparentColor(p) (p)->lpVtbl->GetDecalTransparentColor(p) +#define IDirect3DRMTexture3_InitFromImage(p,a) (p)->lpVtbl->InitFromImage(p,a) +#define IDirect3DRMTexture3_InitFromResource2(p,a,b,c) (p)->lpVtbl->InitFromResource2(p,a,b,c) +#define IDirect3DRMTexture3_GenerateMIPMap(p,a) (p)->lpVtbl->GenerateMIPMap(p,a) +#define IDirect3DRMTexture3_GetSurface(p,a,b) (p)->lpVtbl->GetSurface(p,a,b) +#define IDirect3DRMTexture3_SetCacheOptions(p,a,b) (p)->lpVtbl->SetCacheOptions(p,a,b) +#define IDirect3DRMTexture3_GetCacheOptions(p,a,b) (p)->lpVtbl->GetCacheOptions(p,a,b) +#define IDirect3DRMTexture3_SetDownsampleCallback(p,a,b) (p)->lpVtbl->SetDownsampleCallback(p,a,b) +#define IDirect3DRMTexture3_SetValidationCallback(p,a,b) (p)->lpVtbl->SetValidationCallback(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMTexture3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMTexture3_AddRef(p) (p)->AddRef() +#define IDirect3DRMTexture3_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMTexture3_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMTexture3_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMTexture3_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMTexture3_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMTexture3_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMTexture3_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMTexture3_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMTexture3_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMTexture3 methods ***/ +#define IDirect3DRMTexture3_InitFromFile(p,a) (p)->InitFromFile(a) +#define IDirect3DRMTexture3_InitFromSurface(p,a) (p)->InitFromSurface(a) +#define IDirect3DRMTexture3_InitFromResource(p,a) (p)->InitFromResource(a) +#define IDirect3DRMTexture3_Changed(p,a,b,c) (p)->Changed(a,b,c) +#define IDirect3DRMTexture3_SetColors(p,a) (p)->SetColors(a) +#define IDirect3DRMTexture3_SetShades(p,a) (p)->SetShades(a) +#define IDirect3DRMTexture3_SetDecalSize(p,a,b) (p)->SetDecalSize(a,b) +#define IDirect3DRMTexture3_SetDecalOrigin(p,a,b) (p)->SetDecalOrigin(a,b) +#define IDirect3DRMTexture3_SetDecalScale(p,a) (p)->SetDecalScale(a) +#define IDirect3DRMTexture3_SetDecalTransparency(p,a) (p)->SetDecalTransparency(a) +#define IDirect3DRMTexture3_SetDecalTransparentColor(p,a) (p)->SetDecalTransparentColor(a) +#define IDirect3DRMTexture3_GetDecalSize(p,a,b) (p)->GetDecalSize(a,b) +#define IDirect3DRMTexture3_GetDecalOrigin(p,a,b) (p)->GetDecalOrigin(a,b) +#define IDirect3DRMTexture3_GetImage(p) (p)->GetImage() +#define IDirect3DRMTexture3_GetShades(p) (p)->GetShades() +#define IDirect3DRMTexture3_GetColors(p) (p)->GetColors() +#define IDirect3DRMTexture3_GetDecalScale(p) (p)->GetDecalScale() +#define IDirect3DRMTexture3_GetDecalTransparency(p) (p)->GetDecalTransparency() +#define IDirect3DRMTexture3_GetDecalTransparencyColor(p) (p)->GetDecalTransparencyColor() +#define IDirect3DRMTexture3_InitFromImage(p,a) (p)->InitFromImage(a) +#define IDirect3DRMTexture3_InitFromResource2(p,a,b,c) (p)->InitFromResource2(a,b,c) +#define IDirect3DRMTexture3_GenerateMIPMap(p,a) (p)->GenerateMIPMap(a) +#define IDirect3DRMTexture3_GetSurface(p,a,b) (p)->GetSurface(a,b) +#define IDirect3DRMTexture3_SetCacheOptions(p,a,b) (p)->SetCacheOptions(a,b) +#define IDirect3DRMTexture3_GetCacheOptions(p,a,b) (p)->GetCacheOptions(a,b) +#define IDirect3DRMTexture3_SetDownsampleCallback(p,a,b) (p)->SetDownsampleCallback(a,b) +#define IDirect3DRMTexture3_SetValidationCallback(p,a,b) (p)->SetValidationCallback(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMWrap interface + */ +#define INTERFACE IDirect3DRMWrap +DECLARE_INTERFACE_(IDirect3DRMWrap, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMWrap methods ***/ + STDMETHOD(Init)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame *reference, D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, + D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, + D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv) PURE; + STDMETHOD(Apply)(THIS_ IDirect3DRMObject *object) PURE; + STDMETHOD(ApplyRelative)(THIS_ IDirect3DRMFrame *frame, IDirect3DRMObject *object) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMWrap_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMWrap_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMWrap_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMWrap_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMWrap_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMWrap_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMWrap_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMWrap_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMWrap_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMWrap_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMWrap_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMWrap methods ***/ +#define IDirect3DRMWrap_Init(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (p)->lpVtbl->Init(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) +#define IDirect3DRMWrap_Apply(p,a) (p)->lpVtbl->Apply(p,a) +#define IDirect3DRMWrap_ApplyRelative(p,a,b) (p)->lpVtbl->ApplyRelative(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMWrap_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMWrap_AddRef(p) (p)->AddRef() +#define IDirect3DRMWrap_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMWrap_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMWrap_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMWrap_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMWrap_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMWrap_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMWrap_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMWrap_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMWrap_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMWrap methods ***/ +#define IDirect3DRMWrap_Init(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (p)->Init(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) +#define IDirect3DRMWrap_Apply(p,a) (p)->Apply(a) +#define IDirect3DRMWrap_ApplyRelative(p,a,b) (p)->ApplyRelative(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMMaterial interface + */ +#define INTERFACE IDirect3DRMMaterial +DECLARE_INTERFACE_(IDirect3DRMMaterial, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMMaterial methods ***/ + STDMETHOD(SetPower)(THIS_ D3DVALUE power) PURE; + STDMETHOD(SetSpecular)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE; + STDMETHOD(SetEmissive)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE; + STDMETHOD_(D3DVALUE, GetPower)(THIS) PURE; + STDMETHOD(GetSpecular)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE; + STDMETHOD(GetEmissive)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMMaterial_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMMaterial_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMMaterial_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMaterial_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMMaterial_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMMaterial_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMMaterial_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMMaterial_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMMaterial_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMMaterial_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMMaterial_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMMaterial methods ***/ +#define IDirect3DRMMaterial_SetPower(p,a) (p)->lpVtbl->SetPower(p,a) +#define IDirect3DRMMaterial_SetSpecular(p,a,b,c) (p)->lpVtbl->SetSpecular(p,a,b,c) +#define IDirect3DRMMaterial_SetEmissive(p,a,b,c) (p)->lpVtbl->SetEmissive(p,a,b,c) +#define IDirect3DRMMaterial_GetPower(p) (p)->lpVtbl->GetPower(p) +#define IDirect3DRMMaterial_GetSpecular(p,a,b,c) (p)->lpVtbl->GetSpecular(p,a,b,c) +#define IDirect3DRMMaterial_GetEmissive(p,a,b,c) (p)->lpVtbl->GetEmissive(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMMaterial_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMMaterial_AddRef(p) (p)->AddRef() +#define IDirect3DRMMaterial_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMaterial_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMMaterial_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMMaterial_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMMaterial_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMMaterial_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMMaterial_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMMaterial_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMMaterial_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMMaterial methods ***/ +#define IDirect3DRMMaterial_SetPower(p,a) (p)->SetPower(a) +#define IDirect3DRMMaterial_SetSpecular(p,a,b,c) (p)->SetSpecular(a,b,c) +#define IDirect3DRMMaterial_SetEmissive(p,a,b,c) (p)->SetEmissive(a,b,c) +#define IDirect3DRMMaterial_GetPower(p) (p)->GetPower() +#define IDirect3DRMMaterial_GetSpecular(p,a,b,c) (p)->GetSpecular(a,b,c) +#define IDirect3DRMMaterial_GetEmissive(p,a,b,c) (p)->GetEmissive(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DRMMaterial2 interface + */ +#define INTERFACE IDirect3DRMMaterial2 +DECLARE_INTERFACE_(IDirect3DRMMaterial2, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMMaterial2 methods ***/ + STDMETHOD(SetPower)(THIS_ D3DVALUE power) PURE; + STDMETHOD(SetSpecular)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE; + STDMETHOD(SetEmissive)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE; + STDMETHOD_(D3DVALUE, GetPower)(THIS) PURE; + STDMETHOD(GetSpecular)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE; + STDMETHOD(GetEmissive)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE; + STDMETHOD(GetAmbient)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE; + STDMETHOD(SetAmbient)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMMaterial2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMMaterial2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMMaterial2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMaterial2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMMaterial2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMMaterial2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMMaterial2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMMaterial2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMMaterial2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMMaterial2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMMaterial2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMMaterial2 methods ***/ +#define IDirect3DRMMaterial2_SetPower(p,a) (p)->lpVtbl->SetPower(p,a) +#define IDirect3DRMMaterial2_SetSpecular(p,a,b,c) (p)->lpVtbl->SetSpecular(p,a,b,c) +#define IDirect3DRMMaterial2_SetEmissive(p,a,b,c) (p)->lpVtbl->SetEmissive(p,a,b,c) +#define IDirect3DRMMaterial2_GetPower(p) (p)->lpVtbl->GetPower(p) +#define IDirect3DRMMaterial2_GetSpecular(p,a,b,c) (p)->lpVtbl->GetSpecular(p,a,b,c) +#define IDirect3DRMMaterial2_GetEmissive(p,a,b,c) (p)->lpVtbl->GetEmissive(p,a,b,c) +#define IDirect3DRMMaterial2_SetAmbient(p,a,b,c) (p)->lpVtbl->SetAmbient(p,a,b,c) +#define IDirect3DRMMaterial2_GetAmbient(p,a,b,c) (p)->lpVtbl->GetAmbient(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMMaterial2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMMaterial2_AddRef(p) (p)->AddRef() +#define IDirect3DRMMaterial2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMMaterial2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMMaterial2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMMaterial2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMMaterial2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMMaterial2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMMaterial2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMMaterial2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMMaterial2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMMaterial2 methods ***/ +#define IDirect3DRMMaterial2_SetPower(p,a) (p)->SetPower(a) +#define IDirect3DRMMaterial2_SetSpecular(p,a,b,c) (p)->SetSpecular(a,b,c) +#define IDirect3DRMMaterial2_SetEmissive(p,a,b,c) (p)->SetEmissive(a,b,c) +#define IDirect3DRMMaterial2_GetPower(p) (p)->GetPower() +#define IDirect3DRMMaterial2_GetSpecular(p,a,b,c) (p)->GetSpecular(a,b,c) +#define IDirect3DRMMaterial2_GetEmissive(p,a,b,c) (p)->GetEmissive(a,b,c) +#define IDirect3DRMMaterial2_SetAmbient(p,a,b,c) (p)->SetAmbient(a,b,c) +#define IDirect3DRMMaterial2_GetAmbient(p,a,b,c) (p)->GetAmbient(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DRMAnimation interface + */ +#define INTERFACE IDirect3DRMAnimation +DECLARE_INTERFACE_(IDirect3DRMAnimation, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMAnimation methods ***/ + STDMETHOD(SetOptions)(THIS_ D3DRMANIMATIONOPTIONS flags) PURE; + STDMETHOD(AddRotateKey)(THIS_ D3DVALUE time, D3DRMQUATERNION *q) PURE; + STDMETHOD(AddPositionKey)(THIS_ D3DVALUE time, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddScaleKey)(THIS_ D3DVALUE time, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(DeleteKey)(THIS_ D3DVALUE time) PURE; + STDMETHOD(SetFrame)(THIS_ IDirect3DRMFrame *frame) PURE; + STDMETHOD(SetTime)(THIS_ D3DVALUE time) PURE; + STDMETHOD_(D3DRMANIMATIONOPTIONS, GetOptions)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMAnimation_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMAnimation_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMAnimation_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimation_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMAnimation_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMAnimation_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMAnimation_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMAnimation_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMAnimation_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMAnimation_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMAnimation_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMAnimation methods ***/ +#define IDirect3DRMAnimation_SetOptions(p,a) (p)->lpVtbl->SetOptions(p,a) +#define IDirect3DRMAnimation_AddRotateKey(p,a,b) (p)->lpVtbl->AddRotateKey(p,a,b) +#define IDirect3DRMAnimation_AddPositionKey(p,a,b,c,d) (p)->lpVtbl->AddPositionKey(p,a,b,c,d) +#define IDirect3DRMAnimation_AddScaleKey(p,a,b,c,d) (p)->lpVtbl->AddScaleKey(p,a,b,c,d) +#define IDirect3DRMAnimation_DeleteKey(p,a) (p)->lpVtbl->DeleteKey(p,a) +#define IDirect3DRMAnimation_SetFrame(p,a) (p)->lpVtbl->SetFrame(p,a) +#define IDirect3DRMAnimation_SetTime(p,a) (p)->lpVtbl->SetTime(p,a) +#define IDirect3DRMAnimation_GetOptions(p) (p)->lpVtbl->GetOptions(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMAnimation_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMAnimation_AddRef(p) (p)->AddRef() +#define IDirect3DRMAnimation_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimation_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMAnimation_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMAnimation_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMAnimation_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMAnimation_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMAnimation_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMAnimation_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMAnimation_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMAnimation methods ***/ +#define IDirect3DRMAnimation_SetOptions(p,a) (p)->SetOptions(a) +#define IDirect3DRMAnimation_AddRotateKey(p,a,b) (p)->AddRotateKey(a,b) +#define IDirect3DRMAnimation_AddPositionKey(p,a,b,c,d) (p)->AddPositionKey(a,b,c,d) +#define IDirect3DRMAnimation_AddScaleKey(p,a,b,c,d) (p)->AddScaleKey(a,b,c,d) +#define IDirect3DRMAnimation_DeleteKey(p,a) (p)->DeleteKey(a) +#define IDirect3DRMAnimation_SetFrame(p,a) (p)->SetFrame(a) +#define IDirect3DRMAnimation_SetTime(p,a) (p)->SetTime(a) +#define IDirect3DRMAnimation_GetOptions(p) (p)->GetOptions() +#endif + +/***************************************************************************** + * IDirect3DRMAnimation2 interface + */ +#define INTERFACE IDirect3DRMAnimation2 +DECLARE_INTERFACE_(IDirect3DRMAnimation2, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMAnimation2 methods ***/ + STDMETHOD(SetOptions)(THIS_ D3DRMANIMATIONOPTIONS flags) PURE; + STDMETHOD(AddRotateKey)(THIS_ D3DVALUE time, D3DRMQUATERNION *q) PURE; + STDMETHOD(AddPositionKey)(THIS_ D3DVALUE time, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(AddScaleKey)(THIS_ D3DVALUE time, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE; + STDMETHOD(DeleteKey)(THIS_ D3DVALUE time) PURE; + STDMETHOD(SetFrame)(THIS_ IDirect3DRMFrame3 *frame) PURE; + STDMETHOD(SetTime)(THIS_ D3DVALUE time) PURE; + STDMETHOD_(D3DRMANIMATIONOPTIONS, GetOptions)(THIS) PURE; + STDMETHOD(GetFrame)(THIS_ IDirect3DRMFrame3 **frame) PURE; + STDMETHOD(DeleteKeyByID)(THIS_ DWORD dwID) PURE; + STDMETHOD(AddKey)(THIS_ D3DRMANIMATIONKEY *key) PURE; + STDMETHOD(ModifyKey)(THIS_ D3DRMANIMATIONKEY *key) PURE; + STDMETHOD(GetKeys)(THIS_ D3DVALUE time_min, D3DVALUE time_max, DWORD *key_count, D3DRMANIMATIONKEY *keys); +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMAnimation2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMAnimation2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMAnimation2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimation2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMAnimation2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMAnimation2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMAnimation2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMAnimation2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMAnimation2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMAnimation2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMAnimation2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMAnimation2 methods ***/ +#define IDirect3DRMAnimation2_SetOptions(p,a) (p)->lpVtbl->SetOptions(p,a) +#define IDirect3DRMAnimation2_AddRotateKey(p,a,b) (p)->lpVtbl->AddRotateKey(p,a,b) +#define IDirect3DRMAnimation2_AddPositionKey(p,a,b,c,d) (p)->lpVtbl->AddPositionKey(p,a,b,c,d) +#define IDirect3DRMAnimation2_AddScaleKey(p,a,b,c,d) (p)->lpVtbl->AddScaleKey(p,a,b,c,d) +#define IDirect3DRMAnimation2_DeleteKey(p,a) (p)->lpVtbl->DeleteKey(p,a) +#define IDirect3DRMAnimation2_SetFrame(p,a) (p)->lpVtbl->SetFrame(p,a) +#define IDirect3DRMAnimation2_SetTime(p,a) (p)->lpVtbl->SetTime(p,a) +#define IDirect3DRMAnimation2_GetOptions(p) (p)->lpVtbl->GetOptions(p) +#define IDirect3DRMAnimation2_GetFrame(p,a) (p)->lpVtbl->GetFrame(p,a) +#define IDirect3DRMAnimation2_DeleteKeyByID(p,a) (p)->lpVtbl->DeleteKeyByID(p,a) +#define IDirect3DRMAnimation2_AddKey(p,a) (p)->lpVtbl->AddKey(p,a) +#define IDirect3DRMAnimation2_ModifyKey(p,a) (p)->lpVtbl->ModifyKey(p,a) +#define IDirect3DRMAnimation2_GetKeys(p,a,b,c,d) (p)->lpVtbl->GetKeys(p,a,b,c,d) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMAnimation2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMAnimation2_AddRef(p) (p)->AddRef() +#define IDirect3DRMAnimation2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimation2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMAnimation2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMAnimation2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMAnimation2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMAnimation2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMAnimation2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMAnimation2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMAnimation2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMAnimation2 methods ***/ +#define IDirect3DRMAnimation2_SetOptions(p,a) (p)->SetOptions(a) +#define IDirect3DRMAnimation2_AddRotateKey(p,a,b) (p)->AddRotateKey(a,b) +#define IDirect3DRMAnimation2_AddPositionKey(p,a,b,c,d) (p)->AddPositionKey(a,b,c,d) +#define IDirect3DRMAnimation2_AddScaleKey(p,a,b,c,d) (p)->AddScaleKey(a,b,c,d) +#define IDirect3DRMAnimation2_DeleteKey(p,a) (p)->DeleteKey(a) +#define IDirect3DRMAnimation2_SetFrame(p,a) (p)->SetFrame(a) +#define IDirect3DRMAnimation2_SetTime(p,a) (p)->SetTime(a) +#define IDirect3DRMAnimation2_GetOptions(p) (p)->GetOptions() +#define IDirect3DRMAnimation2_GetFrame(p,a) (p)->GetFrame(a) +#define IDirect3DRMAnimation2_DeleteKeyByID(p,a) (p)->DeleteKeyByID(a) +#define IDirect3DRMAnimation2_AddKey(p,a) (p)->AddKey(a) +#define IDirect3DRMAnimation2_ModifyKey(p,a) (p)->ModifyKey(a) +#define IDirect3DRMAnimation2_GetKeys(p,a,b,c,d) (p)->GetKeys(a,b,c,d) +#endif + +/***************************************************************************** + * IDirect3DRMAnimationSet interface + */ +#define INTERFACE IDirect3DRMAnimationSet +DECLARE_INTERFACE_(IDirect3DRMAnimationSet, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMAnimationSet methods ***/ + STDMETHOD(AddAnimation)(THIS_ IDirect3DRMAnimation *animation) PURE; + STDMETHOD(Load)(THIS_ void *filename, void *name, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURECALLBACK cb, void *ctx, IDirect3DRMFrame *parent)PURE; + STDMETHOD(DeleteAnimation)(THIS_ IDirect3DRMAnimation *animation) PURE; + STDMETHOD(SetTime)(THIS_ D3DVALUE time) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMAnimationSet_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMAnimationSet_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMAnimationSet_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimationSet_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMAnimationSet_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMAnimationSet_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMAnimationSet_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMAnimationSet_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMAnimationSet_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMAnimationSet_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMAnimationSet_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMAnimationSet methods ***/ +#define IDirect3DRMAnimationSet_AddAnimation(p,a) (p)->lpVtbl->AddAnimation(p,a) +#define IDirect3DRMAnimationSet_Load(p,a,b,c,d,e,f) (p)->lpVtbl->Load(p,a,b,c,d,e,f) +#define IDirect3DRMAnimationSet_DeleteAnimation(p,a) (p)->lpVtbl->DeleteAnimation(p,a) +#define IDirect3DRMAnimationSet_SetTime(p,a) (p)->lpVtbl->SetTime(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMAnimationSet_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMAnimationSet_AddRef(p) (p)->AddRef() +#define IDirect3DRMAnimationSet_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimationSet_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMAnimationSet_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMAnimationSet_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMAnimationSet_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMAnimationSet_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMAnimationSet_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMAnimationSet_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMAnimationSet_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMAnimationSet methods ***/ +#define IDirect3DRMAnimationSet_AddAnimation(p,a) (p)->AddAnimation(a) +#define IDirect3DRMAnimationSet_Load(p,a,b,c,d,e,f) (p)->Load(a,b,c,d,e,f) +#define IDirect3DRMAnimationSet_DeleteAnimation(p,a) (p)->DeleteAnimation(a) +#define IDirect3DRMAnimationSet_SetTime(p,a) (p)->SetTime(a) +#endif + +/***************************************************************************** + * IDirect3DRMAnimationSet2 interface + */ +#define INTERFACE IDirect3DRMAnimationSet2 +DECLARE_INTERFACE_(IDirect3DRMAnimationSet2, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMAnimationSet2 methods ***/ + STDMETHOD(AddAnimation)(THIS_ IDirect3DRMAnimation2 *animation) PURE; + STDMETHOD(Load)(THIS_ void *source, void *object_id, D3DRMLOADOPTIONS flags, + D3DRMLOADTEXTURE3CALLBACK cb, void *ctx, IDirect3DRMFrame3 *parent_frame)PURE; + STDMETHOD(DeleteAnimation)(THIS_ IDirect3DRMAnimation2 *animation) PURE; + STDMETHOD(SetTime)(THIS_ D3DVALUE time) PURE; + STDMETHOD(GetAnimations)(THIS_ struct IDirect3DRMAnimationArray **array) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMAnimationSet2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMAnimationSet2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMAnimationSet2_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimationSet2_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMAnimationSet2_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMAnimationSet2_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMAnimationSet2_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMAnimationSet2_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMAnimationSet2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMAnimationSet2_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMAnimationSet2_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMAnimationSet2 methods ***/ +#define IDirect3DRMAnimationSet2_AddAnimation(p,a) (p)->lpVtbl->AddAnimation(p,a) +#define IDirect3DRMAnimationSet2_Load(p,a,b,c,d,e,f) (p)->lpVtbl->Load(p,a,b,c,d,e,f) +#define IDirect3DRMAnimationSet2_DeleteAnimation(p,a) (p)->lpVtbl->DeleteAnimation(p,a) +#define IDirect3DRMAnimationSet2_SetTime(p,a) (p)->lpVtbl->SetTime(p,a) +#define IDirect3DRMAnimationSet2_GetAnimations(p,a) (p)->lpVtbl->GetAnimations(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMAnimationSet2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMAnimationSet2_AddRef(p) (p)->AddRef() +#define IDirect3DRMAnimationSet2_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMAnimationSet2_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMAnimationSet2_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMAnimationSet2_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMAnimationSet2_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMAnimationSet2_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMAnimationSet2_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMAnimationSet2_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMAnimationSet2_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMAnimationSet2 methods ***/ +#define IDirect3DRMAnimationSet2_AddAnimation(p,a) (p)->AddAnimation(a) +#define IDirect3DRMAnimationSet2_Load(p,a,b,c,d,e,f) (p)->Load(a,b,c,d,e,f) +#define IDirect3DRMAnimationSet2_DeleteAnimation(p,a) (p)->DeleteAnimation(a) +#define IDirect3DRMAnimationSet2_SetTime(p,a) (p)->SetTime(a) +#define IDirect3DRMAnimationSet2_GetAnimations(p,a) (p)->GetAnimations(a) +#endif + +/***************************************************************************** + * IDirect3DRMUserVisual interface + */ +#define INTERFACE IDirect3DRMUserVisual +DECLARE_INTERFACE_(IDirect3DRMUserVisual, IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMUserVisual methods ***/ + STDMETHOD(Init)(THIS_ D3DRMUSERVISUALCALLBACK fn, void *arg) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMUserVisual_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMUserVisual_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMUserVisual_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMUserVisual_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMUserVisual_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMUserVisual_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMUserVisual_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMUserVisual_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMUserVisual_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMUserVisual_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMUserVisual_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMUserVisual methods ***/ +#define IDirect3DRMUserVisual_Init(p,a,b) (p)->lpVtbl->Init(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMUserVisual_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMUserVisual_AddRef(p) (p)->AddRef() +#define IDirect3DRMUserVisual_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMUserVisual_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMUserVisual_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMUserVisual_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMUserVisual_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMUserVisual_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMUserVisual_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMUserVisual_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMUserVisual_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMUserVisual methods ***/ +#define IDirect3DRMUserVisual_Init(p,a,b) (p)->Init(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMArray interface + */ +#define INTERFACE IDirect3DRMArray +DECLARE_INTERFACE_(IDirect3DRMArray, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMArray_GetSize(p) (p)->lpVtbl->GetSize(p) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMArray_GetSize(p) (p)->GetSize() +#endif + +/***************************************************************************** + * IDirect3DRMObjectArray interface + */ +#define INTERFACE IDirect3DRMObjectArray +DECLARE_INTERFACE_(IDirect3DRMObjectArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMObjectArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMObject **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMObjectArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMObjectArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMObjectArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMObjectArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMObjectArray methods ***/ +#define IDirect3DRMObjectArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMObjectArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMObjectArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMObjectArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMObjectArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMObjectArray methods ***/ +#define IDirect3DRMObjectArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMDeviceArray interface + */ +#define INTERFACE IDirect3DRMDeviceArray +DECLARE_INTERFACE_(IDirect3DRMDeviceArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMDeviceArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMDevice **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMDeviceArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMDeviceArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMDeviceArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMDeviceArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMDeviceArray methods ***/ +#define IDirect3DRMDeviceArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMDeviceArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMDeviceArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMDeviceArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMDeviceArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMDeviceArray methods ***/ +#define IDirect3DRMDeviceArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMFrameArray interface + */ +#define INTERFACE IDirect3DRMFrameArray +DECLARE_INTERFACE_(IDirect3DRMFrameArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMFrameArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMFrame **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFrameArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFrameArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFrameArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMFrameArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMFrameArray methods ***/ +#define IDirect3DRMFrameArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFrameArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFrameArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMFrameArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMFrameArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMFrameArray methods ***/ +#define IDirect3DRMFrameArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMViewportArray interface + */ +#define INTERFACE IDirect3DRMViewportArray +DECLARE_INTERFACE_(IDirect3DRMViewportArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMViewportArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMViewport **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMViewportArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMViewportArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMViewportArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMViewportArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMViewportArray methods ***/ +#define IDirect3DRMViewportArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMViewportArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMViewportArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMViewportArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMViewportArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMViewportArray methods ***/ +#define IDirect3DRMviewportArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMVisualArray interface + */ +#define INTERFACE IDirect3DRMVisualArray +DECLARE_INTERFACE_(IDirect3DRMVisualArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMVisualArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMVisual **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMVisualArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMVisualArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMVisualArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMVisualArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMVisualArray methods ***/ +#define IDirect3DRMVisualArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMVisualArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMVisualArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMVisualArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMVisualArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMVisualArray methods ***/ +#define IDirect3DRMVisualArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMAnimationArray interface + */ +#define INTERFACE IDirect3DRMAnimationArray +DECLARE_INTERFACE_(IDirect3DRMAnimationArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMAnimationArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMAnimation2 **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMAnimationArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMAnimationArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMAnimationArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMAnimationArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMAnimationArray methods ***/ +#define IDirect3DRMAnimationArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMAnimationArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMAnimationArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMAnimationArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMAnimationArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMAnimationArray methods ***/ +#define IDirect3DRMAnimationArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMPickedArray interface + */ +#define INTERFACE IDirect3DRMPickedArray +DECLARE_INTERFACE_(IDirect3DRMPickedArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMPickedArray methods ***/ + STDMETHOD(GetPick)(THIS_ DWORD index, IDirect3DRMVisual **visual, + IDirect3DRMFrameArray **frame_array, D3DRMPICKDESC *pick_desc) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMPickedArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMPickedArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMPickedArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMPickedArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMPickedArray methods ***/ +#define IDirect3DRMPickedArray_GetPick(p,a,b,c,d) (p)->lpVtbl->GetPick(p,a,b,c,d) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMPickedArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMPickedArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMPickedArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMPickedArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMPickedArray methods ***/ +#define IDirect3DRMPickedArray_GetPick(p,a,b,c,d) (p)->GetPick(a,b,c,d) +#endif + +/***************************************************************************** + * IDirect3DRMLightArray interface + */ +#define INTERFACE IDirect3DRMLightArray +DECLARE_INTERFACE_(IDirect3DRMLightArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMLightArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMLight **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMLightArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMLightArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMLightArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMLightArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMLightArray methods ***/ +#define IDirect3DRMLightArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMLightArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMLightArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMLightArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMLightArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMLightArray methods ***/ +#define IDirect3DRMLightArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMFaceArray interface + */ +#define INTERFACE IDirect3DRMFaceArray +DECLARE_INTERFACE_(IDirect3DRMFaceArray, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMFaceArray methods ***/ + STDMETHOD(GetElement)(THIS_ DWORD index, IDirect3DRMFace **element) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMFaceArray_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMFaceArray_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMFaceArray_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMFaceArray_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMFaceArray methods ***/ +#define IDirect3DRMFaceArray_GetElement(p,a,b) (p)->lpVtbl->GetElement(p,a,b) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMFaceArray_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMFaceArray_AddRef(p) (p)->AddRef() +#define IDirect3DRMFaceArray_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMFaceArray_GetSize(p) (p)->GetSize() +/*** IDirect3DRMFaceArray methods ***/ +#define IDirect3DRMFaceArray_GetElement(p,a,b) (p)->GetElement(a,b) +#endif + +/***************************************************************************** + * IDirect3DRMPicked2Array interface + */ +#define INTERFACE IDirect3DRMPicked2Array +DECLARE_INTERFACE_(IDirect3DRMPicked2Array, IDirect3DRMArray) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMArray methods ***/ + STDMETHOD_(DWORD, GetSize)(THIS) PURE; + /*** IDirect3DRMPicked2Array methods ***/ + STDMETHOD(GetPick)(THIS_ DWORD index, IDirect3DRMVisual **visual, + IDirect3DRMFrameArray **frame_array, D3DRMPICKDESC2 *pick_desc) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMPicked2Array_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMPicked2Array_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMPicked2Array_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMPicked2Array_GetSize(p) (p)->lpVtbl->GetSize(p) +/*** IDirect3DRMPicked2Array methods ***/ +#define IDirect3DRMPicked2Array_GetPick(p,a,b,c,d) (p)->lpVtbl->GetPick(p,a,b,c,d) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMPicked2Array_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMPicked2Array_AddRef(p) (p)->AddRef() +#define IDirect3DRMPicked2Array_Release(p) (p)->Release() +/*** IDirect3DRMArray methods ***/ +#define IDirect3DRMPicked2Array_GetSize(p) (p)->GetSize() +/*** IDirect3DRMPicked2Array methods ***/ +#define IDirect3DRMPicked2Array_GetPick(p,a,b,c,d) (p)->GetPick(a,b,c,d) +#endif + +/***************************************************************************** + * IDirect3DRMInterpolator interface + */ +#define INTERFACE IDirect3DRMInterpolator +DECLARE_INTERFACE_(IDirect3DRMInterpolator, IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMInterpolator methods ***/ + STDMETHOD(AttachObject)(THIS_ IDirect3DRMObject *object) PURE; + STDMETHOD(GetAttachedObjects)(THIS_ IDirect3DRMObjectArray **array) PURE; + STDMETHOD(DetachObject)(THIS_ IDirect3DRMObject *object) PURE; + STDMETHOD(SetIndex)(THIS_ D3DVALUE) PURE; + STDMETHOD_(D3DVALUE, GetIndex)(THIS) PURE; + STDMETHOD(Interpolate)(THIS_ D3DVALUE index, IDirect3DRMObject *object, D3DRMINTERPOLATIONOPTIONS flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMInterpolator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMInterpolator_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMInterpolator_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMInterpolator_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMInterpolator_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMInterpolator_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMInterpolator_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMInterpolator_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMInterpolator_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMInterpolator_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMInterpolator_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMInterpolator methods ***/ +#define IDirect3DRMInterpolator_AttachObject(p,a) (p)->lpVtbl->AttachObject(p,a) +#define IDirect3DRMInterpolator_GetAttachedObjects(p,a) (p)->lpVtbl->GetAttachedObjects(p,a) +#define IDirect3DRMInterpolator_DetachObject(p,a) (p)->lpVtbl->DetachObject(p,a) +#define IDirect3DRMInterpolator_SetIndex(p,a) (p)->lpVtbl->SetIndex(p,a) +#define IDirect3DRMInterpolator_GetIndex(p) (p)->lpVtbl->GetIndex(p) +#define IDirect3DRMInterpolator_Interpolate(p,a,b,c) (p)->lpVtbl->Interpolate(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMInterpolator_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMInterpolator_AddRef(p) (p)->AddRef() +#define IDirect3DRMInterpolator_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMInterpolator_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMInterpolator_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMInterpolator_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMInterpolator_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMInterpolator_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMInterpolator_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMInterpolator_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMInterpolator_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMInterpolator methods ***/ +#define IDirect3DRMInterpolator_AttachObject(p,a) (p)->AttachObject(a) +#define IDirect3DRMInterpolator_GetAttachedObjects(p,a) (p)->GetAttachedObjects(a) +#define IDirect3DRMInterpolator_DetachObject(p,a) (p)->DetachObject(a) +#define IDirect3DRMInterpolator_SetIndex(p,a) (p)->SetIndex(a) +#define IDirect3DRMInterpolator_GetIndex(p) (p)->GetIndex() +#define IDirect3DRMInterpolator_Interpolate(p,a,b,c) (p)->Interpolate(a,b,c) +#endif + +/***************************************************************************** + * IDirect3DRMClippedVisual interface + */ +#define INTERFACE IDirect3DRMClippedVisual +DECLARE_INTERFACE_(IDirect3DRMClippedVisual, IDirect3DRMVisual) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMClippedVisual methods ***/ + STDMETHOD(Init) (THIS_ IDirect3DRMVisual *visual) PURE; + STDMETHOD(AddPlane) (THIS_ IDirect3DRMFrame3 *reference, D3DVECTOR *point, + D3DVECTOR *normal, DWORD flags, DWORD *id) PURE; + STDMETHOD(DeletePlane)(THIS_ DWORD, DWORD) PURE; + STDMETHOD(GetPlaneIDs)(THIS_ DWORD *count, DWORD *id, DWORD flags) PURE; + STDMETHOD(GetPlane) (THIS_ DWORD id, IDirect3DRMFrame3 *reference, D3DVECTOR *point, + D3DVECTOR *normal, DWORD flags) PURE; + STDMETHOD(SetPlane) (THIS_ DWORD id, IDirect3DRMFrame3 *reference, D3DVECTOR *point, + D3DVECTOR *normal, DWORD flags) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMClippedVisual_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMClippedVisual_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMClippedVisual_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMClippedVisual_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMClippedVisual_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMClippedVisual_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMClippedVisual_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMClippedVisual_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMClippedVisual_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMClippedVisual_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMClippedVisual_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMClippedVisual methods ***/ +#define IDirect3DRMClippedVisual_Init(p,a) (p)->lpVtbl->Init(p,a) +#define IDirect3DRMClippedVisual_AddPlane(p,a,b,c,d,e) (p)->lpVtbl->AddPlane(p,a,b,c,d,e) +#define IDirect3DRMClippedVisual_DeletePlane(p,a,b) (p)->lpVtbl->DeletePlane(p,a,b) +#define IDirect3DRMClippedVisual_GetPlaneIDs(p,a,b,c) (p)->lpVtbl->GetPlaneIDs(p,a,b,c) +#define IDirect3DRMClippedVisual_GetPlane(p,a,b,c,d,e) (p)->lpVtbl->GetPlane(p,a,b,c,d,e) +#define IDirect3DRMClippedVisual_SetPlane(p,a,b,c,d,e) (p)->lpVtbl->SetPlane(p,a,b,c,d,e) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMClippedVisual_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMClippedVisual_AddRef(p) (p)->AddRef() +#define IDirect3DRMClippedVisual_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMClippedVisual_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMClippedVisual_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMClippedVisual_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMClippedVisual_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMClippedVisual_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMClippedVisual_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMClippedVisual_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMClippedVisual_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMClippedVisual methods ***/ +#define IDirect3DRMClippedVisual_Init(p,a) (p)->Init(a) +#define IDirect3DRMClippedVisual_AddPlane(p,a,b,c,d,e) (p)->AddPlane(a,b,c,d,e) +#define IDirect3DRMClippedVisual_DeletePlane(p,a,b) (p)->DeletePlane(a,b) +#define IDirect3DRMClippedVisual_GetPlaneIDs(p,a,b,c) (p)->GetPlaneIDs(a,b,c) +#define IDirect3DRMClippedVisual_GetPlane(p,a,b,c,d,e) (p)->GetPlane(a,b,c,d,e) +#define IDirect3DRMClippedVisual_SetPlane(p,a,b,c,d,e) (p)->SetPlane(a,b,c,d,e) +#endif + +#ifdef __cplusplus +}; +#endif + +#endif /* __D3DRMOBJ_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3drmwin.h b/WineFix/lib/d2d1/include/windows/d3drmwin.h new file mode 100644 index 0000000..bd3a40d --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3drmwin.h @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2010 Vijay Kiran Kamuju + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DRMWIN_H__ +#define __D3DRMWIN_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/***************************************************************************** + * Direct3DRMWinDevice interface GUID + */ + +DEFINE_GUID(IID_IDirect3DRMWinDevice, 0xc5016cc0, 0xd273, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1); + +typedef struct IDirect3DRMWinDevice *LPDIRECT3DRMWINDEVICE, **LPLPDIRECT3DRMWINDEVICE; + +/***************************************************************************** + * IDirect3DRMWinDevice interface + */ +#define INTERFACE IDirect3DRMWinDevice +DECLARE_INTERFACE_(IDirect3DRMWinDevice,IDirect3DRMObject) +{ + /*** IUnknown methods ***/ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** IDirect3DRMObject methods ***/ + STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE; + STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE; + STDMETHOD(SetAppData)(THIS_ DWORD data) PURE; + STDMETHOD_(DWORD, GetAppData)(THIS) PURE; + STDMETHOD(SetName)(THIS_ const char *name) PURE; + STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE; + STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE; + /*** IDirect3DRMWinDevice methods ***/ + STDMETHOD(HandlePaint)(THIS_ HDC) PURE; + STDMETHOD(HandleActivate)(THIS_ WORD) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define IDirect3DRMWinDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DRMWinDevice_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DRMWinDevice_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMWinDevice_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IDirect3DRMWinDevice_AddDestroyCallback(p,a,b) (p)->lpVtbl->AddDestroyCallback(p,a,b) +#define IDirect3DRMWinDevice_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b) +#define IDirect3DRMWinDevice_SetAppData(p,a) (p)->lpVtbl->SetAppData(p,a) +#define IDirect3DRMWinDevice_GetAppData(p) (p)->lpVtbl->GetAppData(p) +#define IDirect3DRMWinDevice_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define IDirect3DRMWinDevice_GetName(p,a,b) (p)->lpVtbl->GetName(p,a,b) +#define IDirect3DRMWinDevice_GetClassName(p,a,b) (p)->lpVtbl->GetClassName(p,a,b) +/*** IDirect3DRMWinDevice methods ***/ +#define IDirect3DRMWinDevice_HandlePaint(p,a) (p)->lpVtbl->HandlePaint(p,a) +#define IDirect3DRMWinDevice_HandleActivate(p,a) (p)->lpVtbl->HandleActivate(p,a) +#else +/*** IUnknown methods ***/ +#define IDirect3DRMWinDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DRMWinDevice_AddRef(p) (p)->AddRef() +#define IDirect3DRMwinDevice_Release(p) (p)->Release() +/*** IDirect3DRMObject methods ***/ +#define IDirect3DRMWinDevice_Clone(p,a,b,c) (p)->Clone(a,b,c) +#define IDirect3DRMWinDevice_AddDestroyCallback(p,a,b) (p)->AddDestroyCallback(a,b) +#define IDirect3DRMWinDevice_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b) +#define IDirect3DRMWinDevice_SetAppData(p,a) (p)->SetAppData(a) +#define IDirect3DRMWinDevice_GetAppData(p) (p)->GetAppData() +#define IDirect3DRMWinDevice_SetName(p,a) (p)->SetName(a) +#define IDirect3DRMWinDevice_GetName(p,a,b) (p)->GetName(a,b) +#define IDirect3DRMWinDevice_GetClassName(p,a,b) (p)->GetClassName(a,b) +/*** IDirect3DRMWinDevice methods ***/ +#define IDirect3DRMWinDevice_HandlePaint(p,a) (p)->HandlePaint(a) +#define IDirect3DRMWinDevice_HandleActivate(p,a) (p)->HandleActivate(a) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __D3DRMWIN_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3dtypes.h b/WineFix/lib/d2d1/include/windows/d3dtypes.h new file mode 100644 index 0000000..06e120d --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dtypes.h @@ -0,0 +1,1370 @@ +/* + * Copyright (C) 2000 Peter Hunnisett + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* FIXME: Need to add C++ code for certain structs for headers - this is going to be a problem + if WINE continues to only use C code - I suppose that we could always inline in + the header file to get around that little problem... */ +/* FIXME: We need to implement versioning on everything directx 5 and up if these headers + are going to be generically useful for directx stuff */ + +#ifndef __WINE_D3DTYPES_H +#define __WINE_D3DTYPES_H + +#include +#include +#include + +#ifdef __i386__ +#pragma pack(push,4) +#endif + +#define D3DVALP(val, prec) ((float)(val)) +#define D3DVAL(val) ((float)(val)) +#define D3DDivide(a, b) (float)((double) (a) / (double) (b)) +#define D3DMultiply(a, b) ((a) * (b)) + +typedef LONG D3DFIXED; + + +#ifndef RGB_MAKE +#define CI_GETALPHA(ci) ((ci) >> 24) +#define CI_GETINDEX(ci) (((ci) >> 8) & 0xffff) +#define CI_GETFRACTION(ci) ((ci) & 0xff) +#define CI_ROUNDINDEX(ci) CI_GETINDEX((ci) + 0x80) +#define CI_MASKALPHA(ci) ((ci) & 0xffffff) +#define CI_MAKE(a, i, f) (((a) << 24) | ((i) << 8) | (f)) + +#define RGBA_GETALPHA(rgb) ((rgb) >> 24) +#define RGBA_GETRED(rgb) (((rgb) >> 16) & 0xff) +#define RGBA_GETGREEN(rgb) (((rgb) >> 8) & 0xff) +#define RGBA_GETBLUE(rgb) ((rgb) & 0xff) +#define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) + +#define D3DRGB(r, g, b) \ + (0xff000000 | ( ((LONG)((r) * 255)) << 16) | (((LONG)((g) * 255)) << 8) | (LONG)((b) * 255)) +#define D3DRGBA(r, g, b, a) \ + ( (((LONG)((a) * 255)) << 24) | (((LONG)((r) * 255)) << 16) \ + | (((LONG)((g) * 255)) << 8) | (LONG)((b) * 255) \ + ) + +#define RGB_GETRED(rgb) (((rgb) >> 16) & 0xff) +#define RGB_GETGREEN(rgb) (((rgb) >> 8) & 0xff) +#define RGB_GETBLUE(rgb) ((rgb) & 0xff) +#define RGBA_SETALPHA(rgba, x) (((x) << 24) | ((rgba) & 0x00ffffff)) +#define RGB_MAKE(r, g, b) ((D3DCOLOR) (((r) << 16) | ((g) << 8) | (b))) +#define RGBA_TORGB(rgba) ((D3DCOLOR) ((rgba) & 0xffffff)) +#define RGB_TORGBA(rgb) ((D3DCOLOR) ((rgb) | 0xff000000)) + +#endif + +#define D3DENUMRET_CANCEL DDENUMRET_CANCEL +#define D3DENUMRET_OK DDENUMRET_OK + +typedef HRESULT (CALLBACK *LPD3DVALIDATECALLBACK)(void *ctx, DWORD offset); +typedef HRESULT (CALLBACK *LPD3DENUMTEXTUREFORMATSCALLBACK)(DDSURFACEDESC *surface_desc, void *ctx); +typedef HRESULT (CALLBACK *LPD3DENUMPIXELFORMATSCALLBACK)(DDPIXELFORMAT *format, void *ctx); + +#ifndef DX_SHARED_DEFINES + +typedef float D3DVALUE,*LPD3DVALUE; + +#ifndef D3DCOLOR_DEFINED +typedef DWORD D3DCOLOR, *LPD3DCOLOR; +#define D3DCOLOR_DEFINED +#endif + +#ifndef D3DVECTOR_DEFINED +typedef struct _D3DVECTOR { + union { + D3DVALUE x; + D3DVALUE dvX; + } DUMMYUNIONNAME1; + union { + D3DVALUE y; + D3DVALUE dvY; + } DUMMYUNIONNAME2; + union { + D3DVALUE z; + D3DVALUE dvZ; + } DUMMYUNIONNAME3; +#if defined(__cplusplus) && defined(D3D_OVERLOADS) + /* the definitions for these methods are in d3dvec.inl */ +public: + /*** constructors ***/ + _D3DVECTOR() {} + _D3DVECTOR(D3DVALUE f); + _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z); + _D3DVECTOR(const D3DVALUE f[3]); + + /*** assignment operators ***/ + _D3DVECTOR& operator += (const _D3DVECTOR& v); + _D3DVECTOR& operator -= (const _D3DVECTOR& v); + _D3DVECTOR& operator *= (const _D3DVECTOR& v); + _D3DVECTOR& operator /= (const _D3DVECTOR& v); + _D3DVECTOR& operator *= (D3DVALUE s); + _D3DVECTOR& operator /= (D3DVALUE s); + + /*** unary operators ***/ + friend _D3DVECTOR operator + (const _D3DVECTOR& v); + friend _D3DVECTOR operator - (const _D3DVECTOR& v); + + /*** binary operators ***/ + friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s); + friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v); + friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s); + + friend D3DVALUE SquareMagnitude(const _D3DVECTOR& v); + friend D3DVALUE Magnitude(const _D3DVECTOR& v); + + friend _D3DVECTOR Normalize(const _D3DVECTOR& v); + + friend D3DVALUE DotProduct(const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR CrossProduct(const _D3DVECTOR& v1, const _D3DVECTOR& v2); +#endif +} D3DVECTOR,*LPD3DVECTOR; +#define D3DVECTOR_DEFINED +#endif + +#define DX_SHARED_DEFINES +#endif /* DX_SHARED_DEFINES */ + +typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE; +typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE; +typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE; + +typedef struct _D3DCOLORVALUE { + union { + D3DVALUE r; + D3DVALUE dvR; + } DUMMYUNIONNAME1; + union { + D3DVALUE g; + D3DVALUE dvG; + } DUMMYUNIONNAME2; + union { + D3DVALUE b; + D3DVALUE dvB; + } DUMMYUNIONNAME3; + union { + D3DVALUE a; + D3DVALUE dvA; + } DUMMYUNIONNAME4; +} D3DCOLORVALUE,*LPD3DCOLORVALUE; + +typedef struct _D3DRECT { + union { + LONG x1; + LONG lX1; + } DUMMYUNIONNAME1; + union { + LONG y1; + LONG lY1; + } DUMMYUNIONNAME2; + union { + LONG x2; + LONG lX2; + } DUMMYUNIONNAME3; + union { + LONG y2; + LONG lY2; + } DUMMYUNIONNAME4; +} D3DRECT, *LPD3DRECT; + +typedef struct _D3DHVERTEX { + DWORD dwFlags; + union { + D3DVALUE hx; + D3DVALUE dvHX; + } DUMMYUNIONNAME1; + union { + D3DVALUE hy; + D3DVALUE dvHY; + } DUMMYUNIONNAME2; + union { + D3DVALUE hz; + D3DVALUE dvHZ; + } DUMMYUNIONNAME3; +} D3DHVERTEX, *LPD3DHVERTEX; + +/* + * Transformed/lit vertices + */ +typedef struct _D3DTLVERTEX { + union { + D3DVALUE sx; + D3DVALUE dvSX; + } DUMMYUNIONNAME1; + union { + D3DVALUE sy; + D3DVALUE dvSY; + } DUMMYUNIONNAME2; + union { + D3DVALUE sz; + D3DVALUE dvSZ; + } DUMMYUNIONNAME3; + union { + D3DVALUE rhw; + D3DVALUE dvRHW; + } DUMMYUNIONNAME4; + union { + D3DCOLOR color; + D3DCOLOR dcColor; + } DUMMYUNIONNAME5; + union { + D3DCOLOR specular; + D3DCOLOR dcSpecular; + } DUMMYUNIONNAME6; + union { + D3DVALUE tu; + D3DVALUE dvTU; + } DUMMYUNIONNAME7; + union { + D3DVALUE tv; + D3DVALUE dvTV; + } DUMMYUNIONNAME8; +#if defined(__cplusplus) && defined(D3D_OVERLOADS) +public: + _D3DTLVERTEX() {} + _D3DTLVERTEX(const D3DVECTOR& v, float _rhw, D3DCOLOR _color, D3DCOLOR _specular, float _tu, float _tv) { + sx = v.x; sy = v.y; sz = v.z; rhw = _rhw; + color = _color; specular = _specular; + tu = _tu; tv = _tv; + } +#endif +} D3DTLVERTEX, *LPD3DTLVERTEX; + +typedef struct _D3DLVERTEX { + union { + D3DVALUE x; + D3DVALUE dvX; + } DUMMYUNIONNAME1; + union { + D3DVALUE y; + D3DVALUE dvY; + } DUMMYUNIONNAME2; + union { + D3DVALUE z; + D3DVALUE dvZ; + } DUMMYUNIONNAME3; + DWORD dwReserved; + union { + D3DCOLOR color; + D3DCOLOR dcColor; + } DUMMYUNIONNAME4; + union { + D3DCOLOR specular; + D3DCOLOR dcSpecular; + } DUMMYUNIONNAME5; + union { + D3DVALUE tu; + D3DVALUE dvTU; + } DUMMYUNIONNAME6; + union { + D3DVALUE tv; + D3DVALUE dvTV; + } DUMMYUNIONNAME7; +} D3DLVERTEX, *LPD3DLVERTEX; + +typedef struct _D3DVERTEX { + union { + D3DVALUE x; + D3DVALUE dvX; + } DUMMYUNIONNAME1; + union { + D3DVALUE y; + D3DVALUE dvY; + } DUMMYUNIONNAME2; + union { + D3DVALUE z; + D3DVALUE dvZ; + } DUMMYUNIONNAME3; + union { + D3DVALUE nx; + D3DVALUE dvNX; + } DUMMYUNIONNAME4; + union { + D3DVALUE ny; + D3DVALUE dvNY; + } DUMMYUNIONNAME5; + union { + D3DVALUE nz; + D3DVALUE dvNZ; + } DUMMYUNIONNAME6; + union { + D3DVALUE tu; + D3DVALUE dvTU; + } DUMMYUNIONNAME7; + union { + D3DVALUE tv; + D3DVALUE dvTV; + } DUMMYUNIONNAME8; +#if defined(__cplusplus) && defined(D3D_OVERLOADS) +public: + _D3DVERTEX() {} + _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv) { + x = v.x; y = v.y; z = v.z; + nx = n.x; ny = n.y; nz = n.z; + tu = _tu; tv = _tv; + } +#endif +} D3DVERTEX, *LPD3DVERTEX; + +typedef struct _D3DMATRIX { + D3DVALUE _11, _12, _13, _14; + D3DVALUE _21, _22, _23, _24; + D3DVALUE _31, _32, _33, _34; + D3DVALUE _41, _42, _43, _44; +#if defined(__cplusplus) && defined(D3D_OVERLOADS) + _D3DMATRIX() { } + + /* This is different from MS, but avoids anonymous structs. */ + D3DVALUE &operator () (int r, int c) + { return (&_11)[r*4 + c]; } + const D3DVALUE &operator() (int r, int c) const + { return (&_11)[r*4 + c]; } +#endif +} D3DMATRIX, *LPD3DMATRIX; + +#if defined(__cplusplus) && defined(D3D_OVERLOADS) +#include +#endif + +typedef struct _D3DVIEWPORT { + DWORD dwSize; + DWORD dwX; + DWORD dwY; + DWORD dwWidth; + DWORD dwHeight; + D3DVALUE dvScaleX; + D3DVALUE dvScaleY; + D3DVALUE dvMaxX; + D3DVALUE dvMaxY; + D3DVALUE dvMinZ; + D3DVALUE dvMaxZ; +} D3DVIEWPORT, *LPD3DVIEWPORT; + +typedef struct _D3DVIEWPORT2 { + DWORD dwSize; + DWORD dwX; + DWORD dwY; + DWORD dwWidth; + DWORD dwHeight; + D3DVALUE dvClipX; + D3DVALUE dvClipY; + D3DVALUE dvClipWidth; + D3DVALUE dvClipHeight; + D3DVALUE dvMinZ; + D3DVALUE dvMaxZ; +} D3DVIEWPORT2, *LPD3DVIEWPORT2; + +typedef struct _D3DVIEWPORT7 { + DWORD dwX; + DWORD dwY; + DWORD dwWidth; + DWORD dwHeight; + D3DVALUE dvMinZ; + D3DVALUE dvMaxZ; +} D3DVIEWPORT7, *LPD3DVIEWPORT7; + +#define D3DMAXUSERCLIPPLANES 32 + +#define D3DCLIPPLANE0 (1 << 0) +#define D3DCLIPPLANE1 (1 << 1) +#define D3DCLIPPLANE2 (1 << 2) +#define D3DCLIPPLANE3 (1 << 3) +#define D3DCLIPPLANE4 (1 << 4) +#define D3DCLIPPLANE5 (1 << 5) + +#define D3DCLIP_LEFT 0x00000001 +#define D3DCLIP_RIGHT 0x00000002 +#define D3DCLIP_TOP 0x00000004 +#define D3DCLIP_BOTTOM 0x00000008 +#define D3DCLIP_FRONT 0x00000010 +#define D3DCLIP_BACK 0x00000020 +#define D3DCLIP_GEN0 0x00000040 +#define D3DCLIP_GEN1 0x00000080 +#define D3DCLIP_GEN2 0x00000100 +#define D3DCLIP_GEN3 0x00000200 +#define D3DCLIP_GEN4 0x00000400 +#define D3DCLIP_GEN5 0x00000800 + +#define D3DSTATUS_CLIPUNIONLEFT D3DCLIP_LEFT +#define D3DSTATUS_CLIPUNIONRIGHT D3DCLIP_RIGHT +#define D3DSTATUS_CLIPUNIONTOP D3DCLIP_TOP +#define D3DSTATUS_CLIPUNIONBOTTOM D3DCLIP_BOTTOM +#define D3DSTATUS_CLIPUNIONFRONT D3DCLIP_FRONT +#define D3DSTATUS_CLIPUNIONBACK D3DCLIP_BACK +#define D3DSTATUS_CLIPUNIONGEN0 D3DCLIP_GEN0 +#define D3DSTATUS_CLIPUNIONGEN1 D3DCLIP_GEN1 +#define D3DSTATUS_CLIPUNIONGEN2 D3DCLIP_GEN2 +#define D3DSTATUS_CLIPUNIONGEN3 D3DCLIP_GEN3 +#define D3DSTATUS_CLIPUNIONGEN4 D3DCLIP_GEN4 +#define D3DSTATUS_CLIPUNIONGEN5 D3DCLIP_GEN5 + +#define D3DSTATUS_CLIPINTERSECTIONLEFT 0x00001000 +#define D3DSTATUS_CLIPINTERSECTIONRIGHT 0x00002000 +#define D3DSTATUS_CLIPINTERSECTIONTOP 0x00004000 +#define D3DSTATUS_CLIPINTERSECTIONBOTTOM 0x00008000 +#define D3DSTATUS_CLIPINTERSECTIONFRONT 0x00010000 +#define D3DSTATUS_CLIPINTERSECTIONBACK 0x00020000 +#define D3DSTATUS_CLIPINTERSECTIONGEN0 0x00040000 +#define D3DSTATUS_CLIPINTERSECTIONGEN1 0x00080000 +#define D3DSTATUS_CLIPINTERSECTIONGEN2 0x00100000 +#define D3DSTATUS_CLIPINTERSECTIONGEN3 0x00200000 +#define D3DSTATUS_CLIPINTERSECTIONGEN4 0x00400000 +#define D3DSTATUS_CLIPINTERSECTIONGEN5 0x00800000 +#define D3DSTATUS_ZNOTVISIBLE 0x01000000 + +#define D3DSTATUS_CLIPUNIONALL ( \ + D3DSTATUS_CLIPUNIONLEFT | \ + D3DSTATUS_CLIPUNIONRIGHT | \ + D3DSTATUS_CLIPUNIONTOP | \ + D3DSTATUS_CLIPUNIONBOTTOM | \ + D3DSTATUS_CLIPUNIONFRONT | \ + D3DSTATUS_CLIPUNIONBACK | \ + D3DSTATUS_CLIPUNIONGEN0 | \ + D3DSTATUS_CLIPUNIONGEN1 | \ + D3DSTATUS_CLIPUNIONGEN2 | \ + D3DSTATUS_CLIPUNIONGEN3 | \ + D3DSTATUS_CLIPUNIONGEN4 | \ + D3DSTATUS_CLIPUNIONGEN5 \ + ) + +#define D3DSTATUS_CLIPINTERSECTIONALL ( \ + D3DSTATUS_CLIPINTERSECTIONLEFT | \ + D3DSTATUS_CLIPINTERSECTIONRIGHT | \ + D3DSTATUS_CLIPINTERSECTIONTOP | \ + D3DSTATUS_CLIPINTERSECTIONBOTTOM | \ + D3DSTATUS_CLIPINTERSECTIONFRONT | \ + D3DSTATUS_CLIPINTERSECTIONBACK | \ + D3DSTATUS_CLIPINTERSECTIONGEN0 | \ + D3DSTATUS_CLIPINTERSECTIONGEN1 | \ + D3DSTATUS_CLIPINTERSECTIONGEN2 | \ + D3DSTATUS_CLIPINTERSECTIONGEN3 | \ + D3DSTATUS_CLIPINTERSECTIONGEN4 | \ + D3DSTATUS_CLIPINTERSECTIONGEN5 \ + ) + +#define D3DSTATUS_DEFAULT ( \ + D3DSTATUS_CLIPINTERSECTIONALL | \ + D3DSTATUS_ZNOTVISIBLE) + +#define D3DTRANSFORM_CLIPPED 0x00000001 +#define D3DTRANSFORM_UNCLIPPED 0x00000002 + +typedef struct _D3DTRANSFORMDATA { + DWORD dwSize; + void *lpIn; + DWORD dwInSize; + void *lpOut; + DWORD dwOutSize; + D3DHVERTEX *lpHOut; + DWORD dwClip; + DWORD dwClipIntersection; + DWORD dwClipUnion; + D3DRECT drExtent; +} D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA; + +typedef struct _D3DLIGHTINGELEMENT { + D3DVECTOR dvPosition; + D3DVECTOR dvNormal; +} D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT; + +typedef struct _D3DMATERIAL { + DWORD dwSize; + union { + D3DCOLORVALUE diffuse; + D3DCOLORVALUE dcvDiffuse; + } DUMMYUNIONNAME; + union { + D3DCOLORVALUE ambient; + D3DCOLORVALUE dcvAmbient; + } DUMMYUNIONNAME1; + union { + D3DCOLORVALUE specular; + D3DCOLORVALUE dcvSpecular; + } DUMMYUNIONNAME2; + union { + D3DCOLORVALUE emissive; + D3DCOLORVALUE dcvEmissive; + } DUMMYUNIONNAME3; + union { + D3DVALUE power; + D3DVALUE dvPower; + } DUMMYUNIONNAME4; + D3DTEXTUREHANDLE hTexture; + DWORD dwRampSize; +} D3DMATERIAL, *LPD3DMATERIAL; + +typedef struct _D3DMATERIAL7 { + union { + D3DCOLORVALUE diffuse; + D3DCOLORVALUE dcvDiffuse; + } DUMMYUNIONNAME; + union { + D3DCOLORVALUE ambient; + D3DCOLORVALUE dcvAmbient; + } DUMMYUNIONNAME1; + union { + D3DCOLORVALUE specular; + D3DCOLORVALUE dcvSpecular; + } DUMMYUNIONNAME2; + union { + D3DCOLORVALUE emissive; + D3DCOLORVALUE dcvEmissive; + } DUMMYUNIONNAME3; + union { + D3DVALUE power; + D3DVALUE dvPower; + } DUMMYUNIONNAME4; +} D3DMATERIAL7, *LPD3DMATERIAL7; + +typedef enum { + D3DLIGHT_POINT = 1, + D3DLIGHT_SPOT = 2, + D3DLIGHT_DIRECTIONAL = 3, + D3DLIGHT_PARALLELPOINT = 4, + D3DLIGHT_GLSPOT = 5, + D3DLIGHT_FORCE_DWORD = 0x7fffffff +} D3DLIGHTTYPE; + +typedef struct _D3DLIGHT { + DWORD dwSize; + D3DLIGHTTYPE dltType; + D3DCOLORVALUE dcvColor; + D3DVECTOR dvPosition; + D3DVECTOR dvDirection; + D3DVALUE dvRange; + D3DVALUE dvFalloff; + D3DVALUE dvAttenuation0; + D3DVALUE dvAttenuation1; + D3DVALUE dvAttenuation2; + D3DVALUE dvTheta; + D3DVALUE dvPhi; +} D3DLIGHT,*LPD3DLIGHT; + +typedef struct _D3DLIGHT7 { + D3DLIGHTTYPE dltType; + D3DCOLORVALUE dcvDiffuse; + D3DCOLORVALUE dcvSpecular; + D3DCOLORVALUE dcvAmbient; + D3DVECTOR dvPosition; + D3DVECTOR dvDirection; + D3DVALUE dvRange; + D3DVALUE dvFalloff; + D3DVALUE dvAttenuation0; + D3DVALUE dvAttenuation1; + D3DVALUE dvAttenuation2; + D3DVALUE dvTheta; + D3DVALUE dvPhi; +} D3DLIGHT7, *LPD3DLIGHT7; + +#define D3DLIGHT_ACTIVE 0x00000001 +#define D3DLIGHT_NO_SPECULAR 0x00000002 +#define D3DLIGHT_ALL (D3DLIGHT_ACTIVE | D3DLIGHT_NO_SPECULAR) /* 0x3 */ + +#define D3DLIGHT_RANGE_MAX ((float)sqrt(FLT_MAX)) + +typedef struct _D3DLIGHT2 { + DWORD dwSize; + D3DLIGHTTYPE dltType; + D3DCOLORVALUE dcvColor; + D3DVECTOR dvPosition; + D3DVECTOR dvDirection; + D3DVALUE dvRange; + D3DVALUE dvFalloff; + D3DVALUE dvAttenuation0; + D3DVALUE dvAttenuation1; + D3DVALUE dvAttenuation2; + D3DVALUE dvTheta; + D3DVALUE dvPhi; + DWORD dwFlags; +} D3DLIGHT2, *LPD3DLIGHT2; + +typedef struct _D3DLIGHTDATA { + DWORD dwSize; + D3DLIGHTINGELEMENT *lpIn; + DWORD dwInSize; + D3DTLVERTEX *lpOut; + DWORD dwOutSize; +} D3DLIGHTDATA, *LPD3DLIGHTDATA; + +#define D3DCOLOR_MONO 1 +#define D3DCOLOR_RGB 2 + +typedef DWORD D3DCOLORMODEL; + + +#define D3DCLEAR_TARGET 0x00000001 +#define D3DCLEAR_ZBUFFER 0x00000002 +#define D3DCLEAR_STENCIL 0x00000004 + +typedef enum _D3DOPCODE { + D3DOP_POINT = 1, + D3DOP_LINE = 2, + D3DOP_TRIANGLE = 3, + D3DOP_MATRIXLOAD = 4, + D3DOP_MATRIXMULTIPLY = 5, + D3DOP_STATETRANSFORM = 6, + D3DOP_STATELIGHT = 7, + D3DOP_STATERENDER = 8, + D3DOP_PROCESSVERTICES = 9, + D3DOP_TEXTURELOAD = 10, + D3DOP_EXIT = 11, + D3DOP_BRANCHFORWARD = 12, + D3DOP_SPAN = 13, + D3DOP_SETSTATUS = 14, + + D3DOP_FORCE_DWORD = 0x7fffffff +} D3DOPCODE; + +typedef struct _D3DINSTRUCTION { + BYTE bOpcode; + BYTE bSize; + WORD wCount; +} D3DINSTRUCTION, *LPD3DINSTRUCTION; + +typedef struct _D3DTEXTURELOAD { + D3DTEXTUREHANDLE hDestTexture; + D3DTEXTUREHANDLE hSrcTexture; +} D3DTEXTURELOAD, *LPD3DTEXTURELOAD; + +typedef struct _D3DPICKRECORD { + BYTE bOpcode; + BYTE bPad; + DWORD dwOffset; + D3DVALUE dvZ; +} D3DPICKRECORD, *LPD3DPICKRECORD; + +typedef enum { + D3DSHADE_FLAT = 1, + D3DSHADE_GOURAUD = 2, + D3DSHADE_PHONG = 3, + D3DSHADE_FORCE_DWORD = 0x7fffffff +} D3DSHADEMODE; + +typedef enum { + D3DFILL_POINT = 1, + D3DFILL_WIREFRAME = 2, + D3DFILL_SOLID = 3, + D3DFILL_FORCE_DWORD = 0x7fffffff +} D3DFILLMODE; + +typedef struct _D3DLINEPATTERN { + WORD wRepeatFactor; + WORD wLinePattern; +} D3DLINEPATTERN; + +typedef enum { + D3DFILTER_NEAREST = 1, + D3DFILTER_LINEAR = 2, + D3DFILTER_MIPNEAREST = 3, + D3DFILTER_MIPLINEAR = 4, + D3DFILTER_LINEARMIPNEAREST = 5, + D3DFILTER_LINEARMIPLINEAR = 6, + D3DFILTER_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREFILTER; + +typedef enum { + D3DBLEND_ZERO = 1, + D3DBLEND_ONE = 2, + D3DBLEND_SRCCOLOR = 3, + D3DBLEND_INVSRCCOLOR = 4, + D3DBLEND_SRCALPHA = 5, + D3DBLEND_INVSRCALPHA = 6, + D3DBLEND_DESTALPHA = 7, + D3DBLEND_INVDESTALPHA = 8, + D3DBLEND_DESTCOLOR = 9, + D3DBLEND_INVDESTCOLOR = 10, + D3DBLEND_SRCALPHASAT = 11, + D3DBLEND_BOTHSRCALPHA = 12, + D3DBLEND_BOTHINVSRCALPHA = 13, + D3DBLEND_FORCE_DWORD = 0x7fffffff +} D3DBLEND; + +typedef enum { + D3DTBLEND_DECAL = 1, + D3DTBLEND_MODULATE = 2, + D3DTBLEND_DECALALPHA = 3, + D3DTBLEND_MODULATEALPHA = 4, + D3DTBLEND_DECALMASK = 5, + D3DTBLEND_MODULATEMASK = 6, + D3DTBLEND_COPY = 7, + D3DTBLEND_ADD = 8, + D3DTBLEND_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREBLEND; + +typedef enum _D3DTEXTUREADDRESS { + D3DTADDRESS_WRAP = 1, + D3DTADDRESS_MIRROR = 2, + D3DTADDRESS_CLAMP = 3, + D3DTADDRESS_BORDER = 4, + D3DTADDRESS_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREADDRESS; + +typedef enum { + D3DCULL_NONE = 1, + D3DCULL_CW = 2, + D3DCULL_CCW = 3, + D3DCULL_FORCE_DWORD = 0x7fffffff +} D3DCULL; + +typedef enum { + D3DCMP_NEVER = 1, + D3DCMP_LESS = 2, + D3DCMP_EQUAL = 3, + D3DCMP_LESSEQUAL = 4, + D3DCMP_GREATER = 5, + D3DCMP_NOTEQUAL = 6, + D3DCMP_GREATEREQUAL = 7, + D3DCMP_ALWAYS = 8, + D3DCMP_FORCE_DWORD = 0x7fffffff +} D3DCMPFUNC; + +typedef enum _D3DSTENCILOP { + D3DSTENCILOP_KEEP = 1, + D3DSTENCILOP_ZERO = 2, + D3DSTENCILOP_REPLACE = 3, + D3DSTENCILOP_INCRSAT = 4, + D3DSTENCILOP_DECRSAT = 5, + D3DSTENCILOP_INVERT = 6, + D3DSTENCILOP_INCR = 7, + D3DSTENCILOP_DECR = 8, + D3DSTENCILOP_FORCE_DWORD = 0x7fffffff +} D3DSTENCILOP; + +typedef enum _D3DFOGMODE { + D3DFOG_NONE = 0, + D3DFOG_EXP = 1, + D3DFOG_EXP2 = 2, + D3DFOG_LINEAR = 3, + D3DFOG_FORCE_DWORD = 0x7fffffff +} D3DFOGMODE; + +typedef enum _D3DZBUFFERTYPE { + D3DZB_FALSE = 0, + D3DZB_TRUE = 1, + D3DZB_USEW = 2, + D3DZB_FORCE_DWORD = 0x7fffffff +} D3DZBUFFERTYPE; + +typedef enum _D3DANTIALIASMODE { + D3DANTIALIAS_NONE = 0, + D3DANTIALIAS_SORTDEPENDENT = 1, + D3DANTIALIAS_SORTINDEPENDENT = 2, + D3DANTIALIAS_FORCE_DWORD = 0x7fffffff +} D3DANTIALIASMODE; + +typedef enum { + D3DVT_VERTEX = 1, + D3DVT_LVERTEX = 2, + D3DVT_TLVERTEX = 3, + D3DVT_FORCE_DWORD = 0x7fffffff +} D3DVERTEXTYPE; + +typedef enum { + D3DPT_POINTLIST = 1, + D3DPT_LINELIST = 2, + D3DPT_LINESTRIP = 3, + D3DPT_TRIANGLELIST = 4, + D3DPT_TRIANGLESTRIP = 5, + D3DPT_TRIANGLEFAN = 6, + D3DPT_FORCE_DWORD = 0x7fffffff +} D3DPRIMITIVETYPE; + +#define D3DSTATE_OVERRIDE_BIAS 256 + +#define D3DSTATE_OVERRIDE(type) (D3DRENDERSTATETYPE)(((DWORD) (type) + D3DSTATE_OVERRIDE_BIAS)) + +typedef enum _D3DTRANSFORMSTATETYPE { + D3DTRANSFORMSTATE_WORLD = 1, + D3DTRANSFORMSTATE_VIEW = 2, + D3DTRANSFORMSTATE_PROJECTION = 3, + D3DTRANSFORMSTATE_WORLD1 = 4, + D3DTRANSFORMSTATE_WORLD2 = 5, + D3DTRANSFORMSTATE_WORLD3 = 6, + D3DTRANSFORMSTATE_TEXTURE0 = 16, + D3DTRANSFORMSTATE_TEXTURE1 = 17, + D3DTRANSFORMSTATE_TEXTURE2 = 18, + D3DTRANSFORMSTATE_TEXTURE3 = 19, + D3DTRANSFORMSTATE_TEXTURE4 = 20, + D3DTRANSFORMSTATE_TEXTURE5 = 21, + D3DTRANSFORMSTATE_TEXTURE6 = 22, + D3DTRANSFORMSTATE_TEXTURE7 = 23, + D3DTRANSFORMSTATE_FORCE_DWORD = 0x7fffffff +} D3DTRANSFORMSTATETYPE; + +typedef enum { + D3DLIGHTSTATE_MATERIAL = 1, + D3DLIGHTSTATE_AMBIENT = 2, + D3DLIGHTSTATE_COLORMODEL = 3, + D3DLIGHTSTATE_FOGMODE = 4, + D3DLIGHTSTATE_FOGSTART = 5, + D3DLIGHTSTATE_FOGEND = 6, + D3DLIGHTSTATE_FOGDENSITY = 7, + D3DLIGHTSTATE_COLORVERTEX = 8, + D3DLIGHTSTATE_FORCE_DWORD = 0x7fffffff +} D3DLIGHTSTATETYPE; + +typedef enum { + D3DRENDERSTATE_TEXTUREHANDLE = 1, + D3DRENDERSTATE_ANTIALIAS = 2, + D3DRENDERSTATE_TEXTUREADDRESS = 3, + D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4, + D3DRENDERSTATE_WRAPU = 5, /* <= d3d6 */ + D3DRENDERSTATE_WRAPV = 6, /* <= d3d6 */ + D3DRENDERSTATE_ZENABLE = 7, + D3DRENDERSTATE_FILLMODE = 8, + D3DRENDERSTATE_SHADEMODE = 9, + D3DRENDERSTATE_LINEPATTERN = 10, + D3DRENDERSTATE_MONOENABLE = 11, /* <= d3d6 */ + D3DRENDERSTATE_ROP2 = 12, /* <= d3d6 */ + D3DRENDERSTATE_PLANEMASK = 13, /* <= d3d6 */ + D3DRENDERSTATE_ZWRITEENABLE = 14, + D3DRENDERSTATE_ALPHATESTENABLE = 15, + D3DRENDERSTATE_LASTPIXEL = 16, + D3DRENDERSTATE_TEXTUREMAG = 17, + D3DRENDERSTATE_TEXTUREMIN = 18, + D3DRENDERSTATE_SRCBLEND = 19, + D3DRENDERSTATE_DESTBLEND = 20, + D3DRENDERSTATE_TEXTUREMAPBLEND = 21, + D3DRENDERSTATE_CULLMODE = 22, + D3DRENDERSTATE_ZFUNC = 23, + D3DRENDERSTATE_ALPHAREF = 24, + D3DRENDERSTATE_ALPHAFUNC = 25, + D3DRENDERSTATE_DITHERENABLE = 26, + D3DRENDERSTATE_ALPHABLENDENABLE = 27, + D3DRENDERSTATE_FOGENABLE = 28, + D3DRENDERSTATE_SPECULARENABLE = 29, + D3DRENDERSTATE_ZVISIBLE = 30, + D3DRENDERSTATE_SUBPIXEL = 31, /* <= d3d6 */ + D3DRENDERSTATE_SUBPIXELX = 32, /* <= d3d6 */ + D3DRENDERSTATE_STIPPLEDALPHA = 33, + D3DRENDERSTATE_FOGCOLOR = 34, + D3DRENDERSTATE_FOGTABLEMODE = 35, + D3DRENDERSTATE_FOGTABLESTART = 36, + D3DRENDERSTATE_FOGTABLEEND = 37, + D3DRENDERSTATE_FOGTABLEDENSITY = 38, + D3DRENDERSTATE_FOGSTART = 36, + D3DRENDERSTATE_FOGEND = 37, + D3DRENDERSTATE_FOGDENSITY = 38, + D3DRENDERSTATE_STIPPLEENABLE = 39, /* <= d3d6 */ + /* d3d5 */ + D3DRENDERSTATE_EDGEANTIALIAS = 40, + D3DRENDERSTATE_COLORKEYENABLE = 41, + D3DRENDERSTATE_BORDERCOLOR = 43, + D3DRENDERSTATE_TEXTUREADDRESSU = 44, + D3DRENDERSTATE_TEXTUREADDRESSV = 45, + D3DRENDERSTATE_MIPMAPLODBIAS = 46, /* <= d3d6 */ + D3DRENDERSTATE_ZBIAS = 47, + D3DRENDERSTATE_RANGEFOGENABLE = 48, + D3DRENDERSTATE_ANISOTROPY = 49, /* <= d3d6 */ + D3DRENDERSTATE_FLUSHBATCH = 50, /* <= d3d6 */ + /* d3d6 */ + D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT = 51, /* <= d3d6 */ + + D3DRENDERSTATE_STENCILENABLE = 52, + D3DRENDERSTATE_STENCILFAIL = 53, + D3DRENDERSTATE_STENCILZFAIL = 54, + D3DRENDERSTATE_STENCILPASS = 55, + D3DRENDERSTATE_STENCILFUNC = 56, + D3DRENDERSTATE_STENCILREF = 57, + D3DRENDERSTATE_STENCILMASK = 58, + D3DRENDERSTATE_STENCILWRITEMASK = 59, + D3DRENDERSTATE_TEXTUREFACTOR = 60, + + D3DRENDERSTATE_STIPPLEPATTERN00 = 64, + D3DRENDERSTATE_STIPPLEPATTERN01 = 65, + D3DRENDERSTATE_STIPPLEPATTERN02 = 66, + D3DRENDERSTATE_STIPPLEPATTERN03 = 67, + D3DRENDERSTATE_STIPPLEPATTERN04 = 68, + D3DRENDERSTATE_STIPPLEPATTERN05 = 69, + D3DRENDERSTATE_STIPPLEPATTERN06 = 70, + D3DRENDERSTATE_STIPPLEPATTERN07 = 71, + D3DRENDERSTATE_STIPPLEPATTERN08 = 72, + D3DRENDERSTATE_STIPPLEPATTERN09 = 73, + D3DRENDERSTATE_STIPPLEPATTERN10 = 74, + D3DRENDERSTATE_STIPPLEPATTERN11 = 75, + D3DRENDERSTATE_STIPPLEPATTERN12 = 76, + D3DRENDERSTATE_STIPPLEPATTERN13 = 77, + D3DRENDERSTATE_STIPPLEPATTERN14 = 78, + D3DRENDERSTATE_STIPPLEPATTERN15 = 79, + D3DRENDERSTATE_STIPPLEPATTERN16 = 80, + D3DRENDERSTATE_STIPPLEPATTERN17 = 81, + D3DRENDERSTATE_STIPPLEPATTERN18 = 82, + D3DRENDERSTATE_STIPPLEPATTERN19 = 83, + D3DRENDERSTATE_STIPPLEPATTERN20 = 84, + D3DRENDERSTATE_STIPPLEPATTERN21 = 85, + D3DRENDERSTATE_STIPPLEPATTERN22 = 86, + D3DRENDERSTATE_STIPPLEPATTERN23 = 87, + D3DRENDERSTATE_STIPPLEPATTERN24 = 88, + D3DRENDERSTATE_STIPPLEPATTERN25 = 89, + D3DRENDERSTATE_STIPPLEPATTERN26 = 90, + D3DRENDERSTATE_STIPPLEPATTERN27 = 91, + D3DRENDERSTATE_STIPPLEPATTERN28 = 92, + D3DRENDERSTATE_STIPPLEPATTERN29 = 93, + D3DRENDERSTATE_STIPPLEPATTERN30 = 94, + D3DRENDERSTATE_STIPPLEPATTERN31 = 95, + + D3DRENDERSTATE_WRAP0 = 128, + D3DRENDERSTATE_WRAP1 = 129, + D3DRENDERSTATE_WRAP2 = 130, + D3DRENDERSTATE_WRAP3 = 131, + D3DRENDERSTATE_WRAP4 = 132, + D3DRENDERSTATE_WRAP5 = 133, + D3DRENDERSTATE_WRAP6 = 134, + D3DRENDERSTATE_WRAP7 = 135, + /* d3d7 */ + D3DRENDERSTATE_CLIPPING = 136, + D3DRENDERSTATE_LIGHTING = 137, + D3DRENDERSTATE_EXTENTS = 138, + D3DRENDERSTATE_AMBIENT = 139, + D3DRENDERSTATE_FOGVERTEXMODE = 140, + D3DRENDERSTATE_COLORVERTEX = 141, + D3DRENDERSTATE_LOCALVIEWER = 142, + D3DRENDERSTATE_NORMALIZENORMALS = 143, + D3DRENDERSTATE_COLORKEYBLENDENABLE = 144, + D3DRENDERSTATE_DIFFUSEMATERIALSOURCE = 145, + D3DRENDERSTATE_SPECULARMATERIALSOURCE = 146, + D3DRENDERSTATE_AMBIENTMATERIALSOURCE = 147, + D3DRENDERSTATE_EMISSIVEMATERIALSOURCE = 148, + D3DRENDERSTATE_VERTEXBLEND = 151, + D3DRENDERSTATE_CLIPPLANEENABLE = 152, + + D3DRENDERSTATE_FORCE_DWORD = 0x7fffffff + + /* FIXME: We have some retired values that are being reused for DirectX 7 */ +} D3DRENDERSTATETYPE; + +typedef enum _D3DMATERIALCOLORSOURCE +{ + D3DMCS_MATERIAL = 0, + D3DMCS_COLOR1 = 1, + D3DMCS_COLOR2 = 2, + D3DMCS_FORCE_DWORD = 0x7fffffff +} D3DMATERIALCOLORSOURCE; + +#define D3DRENDERSTATE_BLENDENABLE D3DRENDERSTATE_ALPHABLENDENABLE +#define D3DRENDERSTATE_WRAPBIAS __MSABI_LONG(128U) +#define D3DWRAP_U __MSABI_LONG(0x00000001) +#define D3DWRAP_V __MSABI_LONG(0x00000002) + +#define D3DWRAPCOORD_0 __MSABI_LONG(0x00000001) +#define D3DWRAPCOORD_1 __MSABI_LONG(0x00000002) +#define D3DWRAPCOORD_2 __MSABI_LONG(0x00000004) +#define D3DWRAPCOORD_3 __MSABI_LONG(0x00000008) + +#define D3DRENDERSTATE_STIPPLEPATTERN(y) (D3DRENDERSTATE_STIPPLEPATTERN00 + (y)) + +typedef struct _D3DSTATE { + union { + D3DTRANSFORMSTATETYPE dtstTransformStateType; + D3DLIGHTSTATETYPE dlstLightStateType; + D3DRENDERSTATETYPE drstRenderStateType; + } DUMMYUNIONNAME1; + union { + DWORD dwArg[1]; + D3DVALUE dvArg[1]; + } DUMMYUNIONNAME2; +} D3DSTATE, *LPD3DSTATE; + +typedef struct _D3DMATRIXLOAD { + D3DMATRIXHANDLE hDestMatrix; + D3DMATRIXHANDLE hSrcMatrix; +} D3DMATRIXLOAD, *LPD3DMATRIXLOAD; + +typedef struct _D3DMATRIXMULTIPLY { + D3DMATRIXHANDLE hDestMatrix; + D3DMATRIXHANDLE hSrcMatrix1; + D3DMATRIXHANDLE hSrcMatrix2; +} D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY; + +typedef struct _D3DPROCESSVERTICES { + DWORD dwFlags; + WORD wStart; + WORD wDest; + DWORD dwCount; + DWORD dwReserved; +} D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES; + +#define D3DPROCESSVERTICES_TRANSFORMLIGHT __MSABI_LONG(0x00000000) +#define D3DPROCESSVERTICES_TRANSFORM __MSABI_LONG(0x00000001) +#define D3DPROCESSVERTICES_COPY __MSABI_LONG(0x00000002) +#define D3DPROCESSVERTICES_OPMASK __MSABI_LONG(0x00000007) + +#define D3DPROCESSVERTICES_UPDATEEXTENTS __MSABI_LONG(0x00000008) +#define D3DPROCESSVERTICES_NOCOLOR __MSABI_LONG(0x00000010) + +typedef enum _D3DTEXTURESTAGESTATETYPE +{ + D3DTSS_COLOROP = 1, + D3DTSS_COLORARG1 = 2, + D3DTSS_COLORARG2 = 3, + D3DTSS_ALPHAOP = 4, + D3DTSS_ALPHAARG1 = 5, + D3DTSS_ALPHAARG2 = 6, + D3DTSS_BUMPENVMAT00 = 7, + D3DTSS_BUMPENVMAT01 = 8, + D3DTSS_BUMPENVMAT10 = 9, + D3DTSS_BUMPENVMAT11 = 10, + D3DTSS_TEXCOORDINDEX = 11, + D3DTSS_ADDRESS = 12, + D3DTSS_ADDRESSU = 13, + D3DTSS_ADDRESSV = 14, + D3DTSS_BORDERCOLOR = 15, + D3DTSS_MAGFILTER = 16, + D3DTSS_MINFILTER = 17, + D3DTSS_MIPFILTER = 18, + D3DTSS_MIPMAPLODBIAS = 19, + D3DTSS_MAXMIPLEVEL = 20, + D3DTSS_MAXANISOTROPY = 21, + D3DTSS_BUMPENVLSCALE = 22, + D3DTSS_BUMPENVLOFFSET = 23, + D3DTSS_TEXTURETRANSFORMFLAGS = 24, + D3DTSS_FORCE_DWORD = 0x7fffffff +} D3DTEXTURESTAGESTATETYPE; + +#define D3DTSS_TCI_PASSTHRU 0x00000000 +#define D3DTSS_TCI_CAMERASPACENORMAL 0x00010000 +#define D3DTSS_TCI_CAMERASPACEPOSITION 0x00020000 +#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x00030000 + +typedef enum _D3DTEXTUREOP +{ + D3DTOP_DISABLE = 1, + D3DTOP_SELECTARG1 = 2, + D3DTOP_SELECTARG2 = 3, + + D3DTOP_MODULATE = 4, + D3DTOP_MODULATE2X = 5, + D3DTOP_MODULATE4X = 6, + + D3DTOP_ADD = 7, + D3DTOP_ADDSIGNED = 8, + D3DTOP_ADDSIGNED2X = 9, + D3DTOP_SUBTRACT = 10, + D3DTOP_ADDSMOOTH = 11, + + D3DTOP_BLENDDIFFUSEALPHA = 12, + D3DTOP_BLENDTEXTUREALPHA = 13, + D3DTOP_BLENDFACTORALPHA = 14, + D3DTOP_BLENDTEXTUREALPHAPM = 15, + D3DTOP_BLENDCURRENTALPHA = 16, + + D3DTOP_PREMODULATE = 17, + D3DTOP_MODULATEALPHA_ADDCOLOR = 18, + D3DTOP_MODULATECOLOR_ADDALPHA = 19, + D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, + D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, + + D3DTOP_BUMPENVMAP = 22, + D3DTOP_BUMPENVMAPLUMINANCE = 23, + D3DTOP_DOTPRODUCT3 = 24, + + D3DTOP_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREOP; + +#define D3DTA_SELECTMASK 0x0000000f +#define D3DTA_DIFFUSE 0x00000000 +#define D3DTA_CURRENT 0x00000001 +#define D3DTA_TEXTURE 0x00000002 +#define D3DTA_TFACTOR 0x00000003 +#define D3DTA_SPECULAR 0x00000004 +#define D3DTA_COMPLEMENT 0x00000010 +#define D3DTA_ALPHAREPLICATE 0x00000020 + +typedef enum _D3DTEXTUREMAGFILTER +{ + D3DTFG_POINT = 1, + D3DTFG_LINEAR = 2, + D3DTFG_FLATCUBIC = 3, + D3DTFG_GAUSSIANCUBIC = 4, + D3DTFG_ANISOTROPIC = 5, + D3DTFG_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREMAGFILTER; + +typedef enum _D3DTEXTUREMINFILTER +{ + D3DTFN_POINT = 1, + D3DTFN_LINEAR = 2, + D3DTFN_ANISOTROPIC = 3, + D3DTFN_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREMINFILTER; + +typedef enum _D3DTEXTUREMIPFILTER +{ + D3DTFP_NONE = 1, + D3DTFP_POINT = 2, + D3DTFP_LINEAR = 3, + D3DTFP_FORCE_DWORD = 0x7fffffff +} D3DTEXTUREMIPFILTER; + +#define D3DTRIFLAG_START __MSABI_LONG(0x00000000) +#define D3DTRIFLAG_STARTFLAT(len) (len) +#define D3DTRIFLAG_ODD __MSABI_LONG(0x0000001e) +#define D3DTRIFLAG_EVEN __MSABI_LONG(0x0000001f) + +#define D3DTRIFLAG_EDGEENABLE1 __MSABI_LONG(0x00000100) +#define D3DTRIFLAG_EDGEENABLE2 __MSABI_LONG(0x00000200) +#define D3DTRIFLAG_EDGEENABLE3 __MSABI_LONG(0x00000400) +#define D3DTRIFLAG_EDGEENABLETRIANGLE \ + (D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE2 | D3DTRIFLAG_EDGEENABLE3) + +typedef struct _D3DTRIANGLE { + union { + WORD v1; + WORD wV1; + } DUMMYUNIONNAME1; + union { + WORD v2; + WORD wV2; + } DUMMYUNIONNAME2; + union { + WORD v3; + WORD wV3; + } DUMMYUNIONNAME3; + WORD wFlags; +} D3DTRIANGLE, *LPD3DTRIANGLE; + +typedef struct _D3DLINE { + union { + WORD v1; + WORD wV1; + } DUMMYUNIONNAME1; + union { + WORD v2; + WORD wV2; + } DUMMYUNIONNAME2; +} D3DLINE, *LPD3DLINE; + +typedef struct _D3DSPAN { + WORD wCount; + WORD wFirst; +} D3DSPAN, *LPD3DSPAN; + +typedef struct _D3DPOINT { + WORD wCount; + WORD wFirst; +} D3DPOINT, *LPD3DPOINT; + +typedef struct _D3DBRANCH { + DWORD dwMask; + DWORD dwValue; + BOOL bNegate; + DWORD dwOffset; +} D3DBRANCH, *LPD3DBRANCH; + +typedef struct _D3DSTATUS { + DWORD dwFlags; + DWORD dwStatus; + D3DRECT drExtent; +} D3DSTATUS, *LPD3DSTATUS; + +#define D3DSETSTATUS_STATUS __MSABI_LONG(0x00000001) +#define D3DSETSTATUS_EXTENTS __MSABI_LONG(0x00000002) +#define D3DSETSTATUS_ALL (D3DSETSTATUS_STATUS | D3DSETSTATUS_EXTENTS) + +typedef struct _D3DCLIPSTATUS { + DWORD dwFlags; + DWORD dwStatus; + float minx, maxx; + float miny, maxy; + float minz, maxz; +} D3DCLIPSTATUS, *LPD3DCLIPSTATUS; + +#define D3DCLIPSTATUS_STATUS __MSABI_LONG(0x00000001) +#define D3DCLIPSTATUS_EXTENTS2 __MSABI_LONG(0x00000002) +#define D3DCLIPSTATUS_EXTENTS3 __MSABI_LONG(0x00000004) + +typedef struct { + DWORD dwSize; + DWORD dwTrianglesDrawn; + DWORD dwLinesDrawn; + DWORD dwPointsDrawn; + DWORD dwSpansDrawn; + DWORD dwVerticesProcessed; +} D3DSTATS, *LPD3DSTATS; + +#define D3DEXECUTE_CLIPPED __MSABI_LONG(0x00000001) +#define D3DEXECUTE_UNCLIPPED __MSABI_LONG(0x00000002) + +typedef struct _D3DEXECUTEDATA { + DWORD dwSize; + DWORD dwVertexOffset; + DWORD dwVertexCount; + DWORD dwInstructionOffset; + DWORD dwInstructionLength; + DWORD dwHVertexOffset; + D3DSTATUS dsStatus; +} D3DEXECUTEDATA, *LPD3DEXECUTEDATA; + +#define D3DPAL_FREE 0x00 +#define D3DPAL_READONLY 0x40 +#define D3DPAL_RESERVED 0x80 + +typedef struct _D3DVERTEXBUFFERDESC { + DWORD dwSize; + DWORD dwCaps; + DWORD dwFVF; + DWORD dwNumVertices; +} D3DVERTEXBUFFERDESC, *LPD3DVERTEXBUFFERDESC; + +#define D3DVBCAPS_SYSTEMMEMORY __MSABI_LONG(0x00000800) +#define D3DVBCAPS_WRITEONLY __MSABI_LONG(0x00010000) +#define D3DVBCAPS_OPTIMIZED __MSABI_LONG(0x80000000) +#define D3DVBCAPS_DONOTCLIP __MSABI_LONG(0x00000001) + +#define D3DVOP_LIGHT (1 << 10) +#define D3DVOP_TRANSFORM (1 << 0) +#define D3DVOP_CLIP (1 << 2) +#define D3DVOP_EXTENTS (1 << 3) + +#define D3DMAXNUMVERTICES ((1<<16) - 1) + +#define D3DMAXNUMPRIMITIVES ((1<<16) - 1) + +#define D3DPV_DONOTCOPYDATA (1 << 0) + +#define D3DFVF_RESERVED0 0x001 +#define D3DFVF_POSITION_MASK 0x00E +#define D3DFVF_XYZ 0x002 +#define D3DFVF_XYZRHW 0x004 +#define D3DFVF_XYZB1 0x006 +#define D3DFVF_XYZB2 0x008 +#define D3DFVF_XYZB3 0x00a +#define D3DFVF_XYZB4 0x00c +#define D3DFVF_XYZB5 0x00e + +#define D3DFVF_NORMAL 0x010 +#define D3DFVF_RESERVED1 0x020 +#define D3DFVF_DIFFUSE 0x040 +#define D3DFVF_SPECULAR 0x080 +#define D3DFVF_TEXCOUNT_MASK 0xf00 +#define D3DFVF_TEXCOUNT_SHIFT 8 +#define D3DFVF_TEX0 0x000 +#define D3DFVF_TEX1 0x100 +#define D3DFVF_TEX2 0x200 +#define D3DFVF_TEX3 0x300 +#define D3DFVF_TEX4 0x400 +#define D3DFVF_TEX5 0x500 +#define D3DFVF_TEX6 0x600 +#define D3DFVF_TEX7 0x700 +#define D3DFVF_TEX8 0x800 + +#define D3DFVF_RESERVED2 0xf000 + +#define D3DFVF_VERTEX ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 ) +#define D3DFVF_LVERTEX ( D3DFVF_XYZ | D3DFVF_RESERVED1 | D3DFVF_DIFFUSE | \ + D3DFVF_SPECULAR | D3DFVF_TEX1 ) +#define D3DFVF_TLVERTEX ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | \ + D3DFVF_TEX1 ) + +typedef struct _D3DDP_PTRSTRIDE +{ + void *lpvData; + DWORD dwStride; +} D3DDP_PTRSTRIDE; + +#define D3DDP_MAXTEXCOORD 8 + +typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA { + D3DDP_PTRSTRIDE position; + D3DDP_PTRSTRIDE normal; + D3DDP_PTRSTRIDE diffuse; + D3DDP_PTRSTRIDE specular; + D3DDP_PTRSTRIDE textureCoords[D3DDP_MAXTEXCOORD]; +} D3DDRAWPRIMITIVESTRIDEDDATA ,*LPD3DDRAWPRIMITIVESTRIDEDDATA; + +#define D3DVIS_INSIDE_FRUSTUM 0 +#define D3DVIS_INTERSECT_FRUSTUM 1 +#define D3DVIS_OUTSIDE_FRUSTUM 2 +#define D3DVIS_INSIDE_LEFT 0 +#define D3DVIS_INTERSECT_LEFT (1 << 2) +#define D3DVIS_OUTSIDE_LEFT (2 << 2) +#define D3DVIS_INSIDE_RIGHT 0 +#define D3DVIS_INTERSECT_RIGHT (1 << 4) +#define D3DVIS_OUTSIDE_RIGHT (2 << 4) +#define D3DVIS_INSIDE_TOP 0 +#define D3DVIS_INTERSECT_TOP (1 << 6) +#define D3DVIS_OUTSIDE_TOP (2 << 6) +#define D3DVIS_INSIDE_BOTTOM 0 +#define D3DVIS_INTERSECT_BOTTOM (1 << 8) +#define D3DVIS_OUTSIDE_BOTTOM (2 << 8) +#define D3DVIS_INSIDE_NEAR 0 +#define D3DVIS_INTERSECT_NEAR (1 << 10) +#define D3DVIS_OUTSIDE_NEAR (2 << 10) +#define D3DVIS_INSIDE_FAR 0 +#define D3DVIS_INTERSECT_FAR (1 << 12) +#define D3DVIS_OUTSIDE_FAR (2 << 12) + +#define D3DVIS_MASK_FRUSTUM (3 << 0) +#define D3DVIS_MASK_LEFT (3 << 2) +#define D3DVIS_MASK_RIGHT (3 << 4) +#define D3DVIS_MASK_TOP (3 << 6) +#define D3DVIS_MASK_BOTTOM (3 << 8) +#define D3DVIS_MASK_NEAR (3 << 10) +#define D3DVIS_MASK_FAR (3 << 12) + +#define D3DDEVINFOID_TEXTUREMANAGER 1 +#define D3DDEVINFOID_D3DTEXTUREMANAGER 2 +#define D3DDEVINFOID_TEXTURING 3 + +typedef enum _D3DSTATEBLOCKTYPE +{ + D3DSBT_ALL = 1, + D3DSBT_PIXELSTATE = 2, + D3DSBT_VERTEXSTATE = 3, + D3DSBT_FORCE_DWORD = 0xffffffff +} D3DSTATEBLOCKTYPE; + +typedef enum _D3DVERTEXBLENDFLAGS +{ + D3DVBLEND_DISABLE = 0, + D3DVBLEND_1WEIGHT = 1, + D3DVBLEND_2WEIGHTS = 2, + D3DVBLEND_3WEIGHTS = 3, +} D3DVERTEXBLENDFLAGS; + +typedef enum _D3DTEXTURETRANSFORMFLAGS { + D3DTTFF_DISABLE = 0, + D3DTTFF_COUNT1 = 1, + D3DTTFF_COUNT2 = 2, + D3DTTFF_COUNT3 = 3, + D3DTTFF_COUNT4 = 4, + D3DTTFF_PROJECTED = 256, + D3DTTFF_FORCE_DWORD = 0x7fffffff +} D3DTEXTURETRANSFORMFLAGS; + +#define D3DFVF_TEXTUREFORMAT2 0 +#define D3DFVF_TEXTUREFORMAT1 3 +#define D3DFVF_TEXTUREFORMAT3 1 +#define D3DFVF_TEXTUREFORMAT4 2 + +#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) +#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) + +#ifdef __i386__ +#pragma pack(pop) +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dukmdt.h b/WineFix/lib/d2d1/include/windows/d3dukmdt.h new file mode 100644 index 0000000..f88771c --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dukmdt.h @@ -0,0 +1,156 @@ +/* + * Copyright 2016 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DUKMDT_H +#define __WINE_D3DUKMDT_H + +#ifndef MAKEFOURCC +#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ + ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24)) +#endif /* MAKEFOURCC */ + +typedef UINT D3DKMT_HANDLE; + +typedef enum _D3DDDIFORMAT +{ + D3DDDIFMT_UNKNOWN = 0, + D3DDDIFMT_R8G8B8 = 0x14, + D3DDDIFMT_A8R8G8B8 = 0x15, + D3DDDIFMT_X8R8G8B8 = 0x16, + D3DDDIFMT_R5G6B5 = 0x17, + D3DDDIFMT_X1R5G5B5 = 0x18, + D3DDDIFMT_A1R5G5B5 = 0x19, + D3DDDIFMT_A4R4G4B4 = 0x1a, + D3DDDIFMT_R3G3B2 = 0x1b, + D3DDDIFMT_A8 = 0x1c, + D3DDDIFMT_A8R3G3B2 = 0x1d, + D3DDDIFMT_X4R4G4B4 = 0x1e, + D3DDDIFMT_A2B10G10R10 = 0x1f, + D3DDDIFMT_A8B8G8R8 = 0x20, + D3DDDIFMT_X8B8G8R8 = 0x21, + D3DDDIFMT_G16R16 = 0x22, + D3DDDIFMT_A2R10G10B10 = 0x23, + D3DDDIFMT_A16B16G16R16 = 0x24, + D3DDDIFMT_A8P8 = 0x28, + D3DDDIFMT_P8 = 0x29, + D3DDDIFMT_L8 = 0x32, + D3DDDIFMT_A8L8 = 0x33, + D3DDDIFMT_A4L4 = 0x34, + D3DDDIFMT_V8U8 = 0x3c, + D3DDDIFMT_L6V5U5 = 0x3d, + D3DDDIFMT_X8L8V8U8 = 0x3e, + D3DDDIFMT_Q8W8V8U8 = 0x3f, + D3DDDIFMT_V16U16 = 0x40, + D3DDDIFMT_W11V11U10 = 0x41, + D3DDDIFMT_A2W10V10U10 = 0x43, + D3DDDIFMT_D16_LOCKABLE = 0x46, + D3DDDIFMT_D32 = 0x47, + D3DDDIFMT_S1D15 = 0x48, + D3DDDIFMT_D15S1 = 0x49, + D3DDDIFMT_S8D24 = 0x4a, + D3DDDIFMT_D24S8 = 0x4b, + D3DDDIFMT_X8D24 = 0x4c, + D3DDDIFMT_D24X8 = 0x4d, + D3DDDIFMT_X4S4D24 = 0x4e, + D3DDDIFMT_D24X4S4 = 0x4f, + D3DDDIFMT_D16 = 0x50, + D3DDDIFMT_L16 = 0x51, + D3DDDIFMT_D32F_LOCKABLE = 0x52, + D3DDDIFMT_D24FS8 = 0x53, + D3DDDIFMT_D32_LOCKABLE = 0x54, + D3DDDIFMT_S8_LOCKABLE = 0x55, + D3DDDIFMT_G8R8 = 0x5b, + D3DDDIFMT_R8 = 0x5c, + D3DDDIFMT_VERTEXDATA = 0x64, + D3DDDIFMT_INDEX16 = 0x65, + D3DDDIFMT_INDEX32 = 0x66, + D3DDDIFMT_Q16W16V16U16 = 0x6e, + D3DDDIFMT_R16F = 0x6f, + D3DDDIFMT_G16R16F = 0x70, + D3DDDIFMT_A16B16G16R16F = 0x71, + D3DDDIFMT_R32F = 0x72, + D3DDDIFMT_G32R32F = 0x73, + D3DDDIFMT_A32B32G32R32F = 0x74, + D3DDDIFMT_CxV8U8 = 0x75, + D3DDDIFMT_A1 = 0x76, + D3DDDIFMT_A2B10G10R10_XR_BIAS = 0x77, + D3DDDIFMT_DXVACOMPBUFFER_BASE = 0x96, + D3DDDIFMT_PICTUREPARAMSDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0, + D3DDDIFMT_MACROBLOCKDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x01, + D3DDDIFMT_RESIDUALDIFFERENCEDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x02, + D3DDDIFMT_DEBLOCKINGDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x03, + D3DDDIFMT_INVERSEQUANTIZATIONDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x04, + D3DDDIFMT_SLICECONTROLDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x05, + D3DDDIFMT_BITSTREAMDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x06, + D3DDDIFMT_MOTIONVECTORBUFFER = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x07, + D3DDDIFMT_FILMGRAINBUFFER = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x08, + D3DDDIFMT_DXVA_RESERVED9 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x09, + D3DDDIFMT_DXVA_RESERVED10 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0a, + D3DDDIFMT_DXVA_RESERVED11 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0b, + D3DDDIFMT_DXVA_RESERVED12 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0c, + D3DDDIFMT_DXVA_RESERVED13 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0d, + D3DDDIFMT_DXVA_RESERVED14 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0e, + D3DDDIFMT_DXVA_RESERVED15 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0f, + D3DDDIFMT_DXVA_RESERVED16 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x10, + D3DDDIFMT_DXVA_RESERVED17 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x11, + D3DDDIFMT_DXVA_RESERVED18 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x12, + D3DDDIFMT_DXVA_RESERVED19 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x13, + D3DDDIFMT_DXVA_RESERVED20 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x14, + D3DDDIFMT_DXVA_RESERVED21 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x15, + D3DDDIFMT_DXVA_RESERVED22 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x16, + D3DDDIFMT_DXVA_RESERVED23 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x17, + D3DDDIFMT_DXVA_RESERVED24 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x18, + D3DDDIFMT_DXVA_RESERVED25 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x19, + D3DDDIFMT_DXVA_RESERVED26 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1a, + D3DDDIFMT_DXVA_RESERVED27 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1b, + D3DDDIFMT_DXVA_RESERVED28 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1c, + D3DDDIFMT_DXVA_RESERVED29 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1d, + D3DDDIFMT_DXVA_RESERVED30 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1e, + D3DDDIFMT_DXVA_RESERVED31 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1f, + D3DDDIFMT_DXVACOMPBUFFER_MAX = D3DDDIFMT_DXVA_RESERVED31, + D3DDDIFMT_BINARYBUFFER = 0xc7, + D3DDDIFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'), + D3DDDIFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'), + D3DDDIFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'), + D3DDDIFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'), + D3DDDIFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'), + D3DDDIFMT_G8R8_G8B8 = MAKEFOURCC('G', 'R', 'G', 'B'), + D3DDDIFMT_MULTI2_ARGB8 = MAKEFOURCC('M', 'E', 'T', '1'), + D3DDDIFMT_R8G8_B8G8 = MAKEFOURCC('R', 'G', 'B', 'G'), + D3DDDIFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), + D3DDDIFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'), + D3DDDIFMT_FORCE_UINT = 0x7fffffff, +} D3DDDIFORMAT; + +typedef UINT D3DDDI_VIDEO_PRESENT_SOURCE_ID; + +typedef struct _D3DDDI_ESCAPEFLAGS +{ + union + { + struct + { + UINT HardwareAccess :1; + UINT Reserved :31; + }; + UINT Value; + }; +} D3DDDI_ESCAPEFLAGS; + +#endif /* __WINE_D3DUKMDT_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx10.h b/WineFix/lib/d2d1/include/windows/d3dx10.h new file mode 100644 index 0000000..0043424 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx10.h @@ -0,0 +1,52 @@ +/* + * Copyright 2015 Andrey Gusev + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DX10_H__ +#define __D3DX10_H__ + +#include +#include + +#define D3DX10_DEFAULT (0xffffffffu) +#define D3DX10_FROM_FILE (0xfffffffdu) +#define DXGI_FORMAT_FROM_FILE ((DXGI_FORMAT)0xfffffffdu) + +#include "d3d10.h" +#include "d3dx10math.h" +#include "d3dx10core.h" +#include "d3dx10tex.h" +#include "d3dx10mesh.h" +#include "d3dx10async.h" + +#define _FACDD 0x876 +#define MAKE_DDHRESULT(code) MAKE_HRESULT(1, _FACDD, code) + +enum _D3DX10_ERR +{ + D3DX10_ERR_CANNOT_MODIFY_INDEX_BUFFER = MAKE_DDHRESULT(2900), + D3DX10_ERR_INVALID_MESH = MAKE_DDHRESULT(2901), + D3DX10_ERR_CANNOT_ATTR_SORT = MAKE_DDHRESULT(2902), + D3DX10_ERR_SKINNING_NOT_SUPPORTED = MAKE_DDHRESULT(2903), + D3DX10_ERR_TOO_MANY_INFLUENCES = MAKE_DDHRESULT(2904), + D3DX10_ERR_INVALID_DATA = MAKE_DDHRESULT(2905), + D3DX10_ERR_LOADED_MESH_HAS_NO_DATA = MAKE_DDHRESULT(2906), + D3DX10_ERR_DUPLICATE_NAMED_FRAGMENT = MAKE_DDHRESULT(2907), + D3DX10_ERR_CANNOT_REMOVE_LAST_ITEM = MAKE_DDHRESULT(2908) +}; + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx10async.h b/WineFix/lib/d2d1/include/windows/d3dx10async.h new file mode 100644 index 0000000..931458f --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx10async.h @@ -0,0 +1,83 @@ +/* + * Copyright 2015 Alistair Leslie-Hughes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DX10ASYNC_H__ +#define __D3DX10ASYNC_H__ + +#include "d3dx10.h" + +HRESULT WINAPI D3DX10CompileFromMemory(const char *data, SIZE_T data_size, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point, + const char *target, UINT sflags, UINT eflags, ID3DX10ThreadPump *pump, ID3D10Blob **shader, + ID3D10Blob **error_messages, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines, + ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, + ID3D10EffectPool *effectpool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, + HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines, + ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, + ID3D10EffectPool *effectpool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, + HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectFromMemory(const void *data, SIZE_T datasize, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, + UINT fxflags, ID3D10Device *device, ID3D10EffectPool *effectpool, ID3DX10ThreadPump *pump, + ID3D10Effect **effect, ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectPoolFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines, + ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, + ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectPoolFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines, + ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, + ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectPoolFromMemory(const void *data, SIZE_T datasize, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, + UINT fxflags, ID3D10Device *device, ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, + ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10PreprocessShaderFromMemory(const char *data, SIZE_T data_size, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3DInclude *include, ID3DX10ThreadPump *pump, ID3D10Blob **shader_text, + ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectFromResourceA(HMODULE module, const char *resource_name, + const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, + const char *profile, UINT shader_flags, UINT effect_flags, ID3D10Device *device, + ID3D10EffectPool *effect_pool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, + ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateEffectFromResourceW(HMODULE module, const WCHAR *resource_name, + const WCHAR *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, + const char *profile, UINT shader_flags, UINT effect_flags, ID3D10Device *device, + ID3D10EffectPool *effect_pool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, + ID3D10Blob **errors, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateAsyncFileLoaderW(const WCHAR *filename, ID3DX10DataLoader **loader); +HRESULT WINAPI D3DX10CreateAsyncFileLoaderA(const char *filename, ID3DX10DataLoader **loader); +HRESULT WINAPI D3DX10CreateAsyncMemoryLoader(const void *data, SIZE_T datasize, ID3DX10DataLoader **loader); +HRESULT WINAPI D3DX10CreateAsyncResourceLoaderA(HMODULE module, const char *resource, ID3DX10DataLoader **loader); +HRESULT WINAPI D3DX10CreateAsyncResourceLoaderW(HMODULE module, const WCHAR *resource, ID3DX10DataLoader **loader); + +HRESULT WINAPI D3DX10CreateAsyncTextureProcessor(ID3D10Device *device, + D3DX10_IMAGE_LOAD_INFO *info, ID3DX10DataProcessor **processor); +HRESULT WINAPI D3DX10CreateAsyncTextureInfoProcessor(D3DX10_IMAGE_INFO *info, ID3DX10DataProcessor **processor); + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx10core.h b/WineFix/lib/d2d1/include/windows/d3dx10core.h new file mode 100644 index 0000000..c8c5e97 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx10core.h @@ -0,0 +1,301 @@ +/* + * Copyright 2015 Alistair Leslie-Hughes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx10.h" + +DEFINE_GUID(IID_ID3DX10Font, 0xd79dbb70, 0x5f21, 0x4d36, 0xbb, 0xc2, 0xff, 0x52, 0x5c, 0x21, 0x3c, 0xdc); +DEFINE_GUID(IID_ID3DX10Sprite, 0xba0b762d, 0x8d28, 0x43ec, 0xb9, 0xdc, 0x2f, 0x84, 0x44, 0x3b, 0x06, 0x14); +DEFINE_GUID(IID_ID3DX10ThreadPump, 0xc93fecfa, 0x6967, 0x478a, 0xab, 0xbc, 0x40, 0x2d, 0x90, 0x62, 0x1f, 0xcb); + +typedef enum _D3DX10_SPRITE_FLAG +{ + D3DX10_SPRITE_SORT_TEXTURE = 0x01, + D3DX10_SPRITE_SORT_DEPTH_BACK_TO_FRONT = 0x02, + D3DX10_SPRITE_SORT_DEPTH_FRONT_TO_BACK = 0x04, + D3DX10_SPRITE_SAVE_STATE = 0x08, + D3DX10_SPRITE_ADDREF_TEXTURES = 0x10, +} D3DX10_SPRITE_FLAG; + +typedef struct _D3DX10_SPRITE +{ + D3DXMATRIX matWorld; + D3DXVECTOR2 TexCoord; + D3DXVECTOR2 TexSize; + D3DXCOLOR ColorModulate; + ID3D10ShaderResourceView *pTexture; + UINT TextureIndex; +} D3DX10_SPRITE; + +typedef struct _D3DX10_FONT_DESCA +{ + INT Height; + UINT Width; + UINT Weight; + UINT MipLevels; + BOOL Italic; + BYTE CharSet; + BYTE OutputPrecision; + BYTE Quality; + BYTE PitchAndFamily; + CHAR FaceName[LF_FACESIZE]; +} D3DX10_FONT_DESCA, *LPD3DX10_FONT_DESCA; + +typedef struct _D3DX10_FONT_DESCW +{ + INT Height; + UINT Width; + UINT Weight; + UINT MipLevels; + BOOL Italic; + BYTE CharSet; + BYTE OutputPrecision; + BYTE Quality; + BYTE PitchAndFamily; + WCHAR FaceName[LF_FACESIZE]; +} D3DX10_FONT_DESCW, *LPD3DX10_FONT_DESCW; + +DECL_WINELIB_TYPE_AW(D3DX10_FONT_DESC) +DECL_WINELIB_TYPE_AW(LPD3DX10_FONT_DESC) + +#define INTERFACE ID3DX10DataLoader +DECLARE_INTERFACE(ID3DX10DataLoader) +{ + STDMETHOD(Load)(THIS) PURE; + STDMETHOD(Decompress)(THIS_ void **data, SIZE_T *bytes) PURE; + STDMETHOD(Destroy)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** ID3DX10DataLoader methods ***/ +#define ID3DX10DataLoader_Load(p) (p)->lpVtbl->Load(p) +#define ID3DX10DataLoader_Decompress(p,a,b) (p)->lpVtbl->Decompress(p,a,b) +#define ID3DX10DataLoader_Destroy(p) (p)->lpVtbl->Destroy(p) +#else +/*** ID3DX10DataLoader methods ***/ +#define ID3DX10DataLoader_Load(p) (p)->Load() +#define ID3DX10DataLoader_Decompress(p,a,b) (p)->Decompress(a,b) +#define ID3DX10DataLoader_Destroy(p) (p)->Destroy() +#endif + +#define INTERFACE ID3DX10DataProcessor +DECLARE_INTERFACE(ID3DX10DataProcessor) +{ + STDMETHOD(Process)(THIS_ void *data, SIZE_T bytes) PURE; + STDMETHOD(CreateDeviceObject)(THIS_ void **dataobject) PURE; + STDMETHOD(Destroy)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** ID3DX10DataProcessor methods ***/ +#define ID3DX10DataProcessor_Process(p,a,b) (p)->lpVtbl->Process(p,a,b) +#define ID3DX10DataProcessor_CreateDeviceObject(p,a) (p)->lpVtbl->CreateDeviceObject(p,a) +#define ID3DX10DataProcessor_Destroy(p) (p)->lpVtbl->Destroy(p) +#else +/*** ID3DX10DataProcessor methods ***/ +#define ID3DX10DataProcessor_Process(p,a,b) (p)->Process(a,b) +#define ID3DX10DataProcessor_CreateDeviceObject(p,a) (p)->CreateDeviceObject(a) +#define ID3DX10DataProcessor_Destroy(p) (p)->Destroy() +#endif + +#define INTERFACE ID3DX10ThreadPump +DECLARE_INTERFACE_(ID3DX10ThreadPump, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DX10ThreadPump methods ***/ + STDMETHOD(AddWorkItem)(THIS_ ID3DX10DataLoader *loader, ID3DX10DataProcessor *processor, + HRESULT *result, void **object) PURE; + STDMETHOD_(UINT, GetWorkItemCount)(THIS) PURE; + STDMETHOD(WaitForAllItems)(THIS) PURE; + STDMETHOD(ProcessDeviceWorkItems)(THIS_ UINT count) PURE; + STDMETHOD(PurgeAllItems)(THIS) PURE; + STDMETHOD(GetQueueStatus)(THIS_ UINT *queue, UINT *processqueue, UINT *devicequeue) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DX10ThreadPump_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DX10ThreadPump_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DX10ThreadPump_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DX10ThreadPump methods ***/ +#define ID3DX10ThreadPump_AddWorkItem(p,a,b,c,d) (p)->lpVtbl->AddWorkItem(p,a,b,c,d) +#define ID3DX10ThreadPump_GetWorkItemCount(p) (p)->lpVtbl->GetWorkItemCount(p) +#define ID3DX10ThreadPump_WaitForAllItems(p) (p)->lpVtbl->WaitForAllItems(p) +#define ID3DX10ThreadPump_ProcessDeviceWorkItems(p,a) (p)->lpVtbl->ProcessDeviceWorkItems(p,a) +#define ID3DX10ThreadPump_PurgeAllItems(p) (p)->lpVtbl->PurgeAllItems(p) +#define ID3DX10ThreadPump_GetQueueStatus(p,a,b,c) (p)->lpVtbl->GetQueueStatus(p,a,b,c) +#else +/*** IUnknown methods ***/ +#define ID3DX10ThreadPump_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DX10ThreadPump_AddRef(p) (p)->AddRef() +#define ID3DX10ThreadPump_Release(p) (p)->Release() +/*** ID3DX10ThreadPump methods ***/ +#define ID3DX10ThreadPump_AddWorkItem(p,a,b,c,d) (p)->AddWorkItem(a,b,c,d) +#define ID3DX10ThreadPump_GetWorkItemCount(p) (p)->GetWorkItemCount() +#define ID3DX10ThreadPump_WaitForAllItems(p) (p)->WaitForAllItems() +#define ID3DX10ThreadPump_ProcessDeviceWorkItems(p,a) (p)->ProcessDeviceWorkItems(a) +#define ID3DX10ThreadPump_PurgeAllItems(p) (p)->PurgeAllItems() +#define ID3DX10ThreadPump_GetQueueStatus(p,a,b,c) (p)->GetQueueStatus(a,b,c) +#endif + +#define INTERFACE ID3DX10Sprite +DECLARE_INTERFACE_(ID3DX10Sprite, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DX10Sprite methods ***/ + STDMETHOD(Begin)(THIS_ UINT flags) PURE; + STDMETHOD(DrawSpritesBuffered)(THIS_ D3DX10_SPRITE *sprites, UINT count) PURE; + STDMETHOD(Flush)(THIS) PURE; + STDMETHOD(DrawSpritesImmediate)(THIS_ D3DX10_SPRITE *sprites, + UINT count, UINT size, UINT flags) PURE; + STDMETHOD(End)(THIS) PURE; + STDMETHOD(GetViewTransform)(THIS_ D3DXMATRIX *transform) PURE; + STDMETHOD(SetViewTransform)(THIS_ D3DXMATRIX *transform) PURE; + STDMETHOD(GetProjectionTransform)(THIS_ D3DXMATRIX *transform) PURE; + STDMETHOD(SetProjectionTransform)(THIS_ D3DXMATRIX *transform) PURE; + STDMETHOD(GetDevice)(THIS_ ID3D10Device **device) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DX10Sprite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DX10Sprite_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DX10Sprite_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DX10Sprite methods ***/ +#define ID3DX10Sprite_Begin(p,a) (p)->lpVtbl->Begin(p,a) +#define ID3DX10Sprite_DrawSpritesBuffered(p,a,b) (p)->lpVtbl->DrawSpritesBuffered(p,a,b) +#define ID3DX10Sprite_Flush(p) (p)->lpVtbl->Flush(p) +#define ID3DX10Sprite_DrawSpritesImmediate(p,a,b,c,d) (p)->lpVtbl->DrawSpritesImmediate(p,a,b,c,d) +#define ID3DX10Sprite_End(p) (p)->lpVtbl->End(p) +#define ID3DX10Sprite_GetViewTransform(p,a) (p)->lpVtbl->GetViewTransform(p,a) +#define ID3DX10Sprite_SetViewTransform(p,a) (p)->lpVtbl->SetViewTransform(p,a) +#define ID3DX10Sprite_GetProjectionTransform(p,a) (p)->lpVtbl->GetProjectionTransform(p,a) +#define ID3DX10Sprite_SetProjectionTransform(p,a) (p)->lpVtbl->SetProjectionTransform(p,a) +#define ID3DX10Sprite_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#else +/*** IUnknown methods ***/ +#define ID3DX10Sprite_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DX10Sprite_AddRef(p) (p)->AddRef() +#define ID3DX10Sprite_Release(p) (p)->Release() +/*** ID3DX10Sprite methods ***/ +#define ID3DX10Sprite_Begin(p,a) (p)->Begin(a) +#define ID3DX10Sprite_DrawSpritesBuffered(p,a,b) (p)->DrawSpritesBuffered(a,b) +#define ID3DX10Sprite_Flush(p) (p)->Flush() +#define ID3DX10Sprite_DrawSpritesImmediate(p,a,b,c,d) (p)->DrawSpritesImmediate(a,b,c,d) +#define ID3DX10Sprite_End(p) (p)->End() +#define ID3DX10Sprite_GetViewTransform(p,a) (p)->GetViewTransform(a) +#define ID3DX10Sprite_SetViewTransform(p,a) (p)->SetViewTransform(a) +#define ID3DX10Sprite_GetProjectionTransform(p,a) (p)->GetProjectionTransform(a) +#define ID3DX10Sprite_SetProjectionTransform(p,a) (p)->SetProjectionTransform(a) +#define ID3DX10Sprite_GetDevice(p,a) (p)->GetDevice(a) +#endif + +#define INTERFACE ID3DX10Font +DECLARE_INTERFACE_(ID3DX10Font, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DX10Font methods ***/ + STDMETHOD(GetDevice)(THIS_ ID3D10Device **device) PURE; + STDMETHOD(GetDescA)(THIS_ D3DX10_FONT_DESCA *desc) PURE; + STDMETHOD(GetDescW)(THIS_ D3DX10_FONT_DESCW *desc) PURE; + STDMETHOD_(BOOL, GetTextMetricsA)(THIS_ TEXTMETRICA *metrics) PURE; + STDMETHOD_(BOOL, GetTextMetricsW)(THIS_ TEXTMETRICW *metrics) PURE; + STDMETHOD_(HDC, GetDC)(THIS) PURE; + STDMETHOD(GetGlyphData)(THIS_ UINT glyph, ID3D10ShaderResourceView **texture, + RECT *blackbox, POINT *cellinc) PURE; + STDMETHOD(PreloadCharacters)(THIS_ UINT first, UINT last) PURE; + STDMETHOD(PreloadGlyphs)(THIS_ UINT first, UINT last) PURE; + STDMETHOD(PreloadTextA)(THIS_ const char *text, INT count) PURE; + STDMETHOD(PreloadTextW)(THIS_ const WCHAR *text, INT count) PURE; + STDMETHOD_(INT, DrawTextA)(THIS_ ID3DX10Sprite *sprite, const char *text, + INT count, RECT *rect, UINT format, D3DXCOLOR color) PURE; + STDMETHOD_(INT, DrawTextW)(THIS_ ID3DX10Sprite *sprite, const WCHAR *text, + INT count, RECT *rect, UINT format, D3DXCOLOR color) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DX10Font_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DX10Font_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DX10Font_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DX10Font methods ***/ +#define ID3DX10Font_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define ID3DX10Font_GetDescA(p,a) (p)->lpVtbl->GetDescA(p,a) +#define ID3DX10Font_GetDescW(p,a) (p)->lpVtbl->GetDescW(p,a) +#define ID3DX10Font_GetTextMetricsA(p,a) (p)->lpVtbl->GetTextMetricsA(p,a) +#define ID3DX10Font_GetTextMetricsW(p,a) (p)->lpVtbl->GetTextMetricsW(p,a) +#define ID3DX10Font_GetDC(p) (p)->lpVtbl->GetDC(p) +#define ID3DX10Font_GetGlyphData(p,a,b,c,d) (p)->lpVtbl->GetGlyphData(p,a,b,c,d) +#define ID3DX10Font_PreloadCharacters(p,a,b) (p)->lpVtbl->PreloadCharacters(p,a,b) +#define ID3DX10Font_PreloadGlyphs(p,a,b) (p)->lpVtbl->PreloadGlyphs(p,a,b) +#define ID3DX10Font_PreloadTextA(p,a,b) (p)->lpVtbl->PreloadTextA(p,a,b) +#define ID3DX10Font_PreloadTextW(p,a,b) (p)->lpVtbl->PreloadTextW(p,a,b) +#define ID3DX10Font_DrawTextA(p,a,b,c,d,e,f) (p)->lpVtbl->DrawTextA(p,a,b,c,d,e,f) +#define ID3DX10Font_DrawTextW(p,a,b,c,d,e,f) (p)->lpVtbl->DrawTextW(p,a,b,c,d,e,f) +#else +/*** IUnknown methods ***/ +#define ID3DX10Font_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DX10Font_AddRef(p) (p)->AddRef() +#define ID3DX10Font_Release(p) (p)->Release() +/*** ID3DX10Font methods ***/ +#define ID3DX10Font_GetDevice(p,a) (p)->GetDevice(a) +#define ID3DX10Font_GetDescA(p,a) (p)->GetDescA(a) +#define ID3DX10Font_GetDescW(p,a) (p)->GetDescW(a) +#define ID3DX10Font_GetTextMetricsA(p,a) (p)->GetTextMetricsA(a) +#define ID3DX10Font_GetTextMetricsW(p,a) (p)->GetTextMetricsW(a) +#define ID3DX10Font_GetDC(p) (p)->GetDC() +#define ID3DX10Font_GetGlyphData(p,a,b,c,d) (p)->GetGlyphData(a,b,c,d) +#define ID3DX10Font_PreloadCharacters(p,a,b) (p)->PreloadCharacters(a,b) +#define ID3DX10Font_PreloadGlyphs(p,a,b) (p)->PreloadGlyphs(a,b) +#define ID3DX10Font_PreloadTextA(p,a,b) (p)->PreloadTextA(a,b) +#define ID3DX10Font_PreloadTextW(p,a,b) (p)->PreloadTextW(a,b) +#define ID3DX10Font_DrawTextA(p,a,b,c,d,e,f) (p)->DrawTextA(a,b,c,d,e,f) +#define ID3DX10Font_DrawTextW(p,a,b,c,d,e,f) (p)->DrawTextW(a,b,c,d,e,f) +#endif + +HRESULT WINAPI D3DX10UnsetAllDeviceObjects(ID3D10Device *device); +HRESULT WINAPI D3DX10CreateDevice(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, + HMODULE swrast, unsigned int flags, ID3D10Device **device); +HRESULT WINAPI D3DX10CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, + HMODULE swrast, unsigned int flags, DXGI_SWAP_CHAIN_DESC *desc, IDXGISwapChain **swapchain, + ID3D10Device **device); +interface ID3D10Device1; +HRESULT WINAPI D3DX10GetFeatureLevel1(ID3D10Device *device, interface ID3D10Device1 **device1); +HRESULT WINAPI D3DX10CreateFontIndirectA(ID3D10Device *device, const D3DX10_FONT_DESCA *desc, ID3DX10Font **font); +HRESULT WINAPI D3DX10CreateFontIndirectW(ID3D10Device *device, const D3DX10_FONT_DESCW *desc, ID3DX10Font **font); +HRESULT WINAPI D3DX10CreateFontA(ID3D10Device *device, INT height, UINT width, UINT weight, + UINT miplevels, BOOL italic, UINT charset, UINT precision, UINT quality, + UINT pitchandfamily, const char *facename, ID3DX10Font **font); +HRESULT WINAPI D3DX10CreateFontW(ID3D10Device *device, INT height, UINT width, UINT weight, + UINT miplevels, BOOL italic, UINT charset, UINT precision, UINT quality, + UINT pitchandfamily, const WCHAR *facename, ID3DX10Font **font); +HRESULT WINAPI D3DX10CreateSprite(ID3D10Device *device, UINT size, ID3DX10Sprite **sprite); +HRESULT WINAPI D3DX10CreateThreadPump(UINT io_threads, UINT proc_threads, ID3DX10ThreadPump **pump); diff --git a/WineFix/lib/d2d1/include/windows/d3dx10math.h b/WineFix/lib/d2d1/include/windows/d3dx10math.h new file mode 100644 index 0000000..5790fbd --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx10math.h @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2016 Alistair Leslie-Hughes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx10.h" + +/* This guard is the same as D3DX9 to prevent double-inclusion */ +#ifndef __D3DX9MATH_H__ +#define __D3DX9MATH_H__ + +#include + +#ifndef D3DVECTOR_DEFINED +#define D3DVECTOR_DEFINED +typedef struct _D3DVECTOR +{ + float x; + float y; + float z; +} D3DVECTOR; +#endif + +#ifndef D3DMATRIX_DEFINED +#define D3DMATRIX_DEFINED +typedef struct _D3DMATRIX +{ + union + { + struct + { + float _11, _12, _13, _14; + float _21, _22, _23, _24; + float _31, _32, _33, _34; + float _41, _42, _43, _44; + }; + float m[4][4]; + }; +} D3DMATRIX; +#endif + +typedef enum _D3DX_CPU_OPTIMIZATION +{ + D3DX_NOT_OPTIMIZED, + D3DX_3DNOW_OPTIMIZED, + D3DX_SSE2_OPTIMIZED, + D3DX_SSE_OPTIMIZED +} D3DX_CPU_OPTIMIZATION; + +typedef struct D3DXFLOAT16 +{ +#ifdef __cplusplus + D3DXFLOAT16(); + D3DXFLOAT16(float f); + D3DXFLOAT16(const D3DXFLOAT16 &f); + + operator float(); + + BOOL operator==(const D3DXFLOAT16 &f) const; + BOOL operator!=(const D3DXFLOAT16 &f) const; +#endif + WORD value; +} D3DXFLOAT16, *LPD3DXFLOAT16; + +typedef struct D3DXCOLOR +{ +#ifdef __cplusplus +public: + D3DXCOLOR(){}; + D3DXCOLOR(UINT color); + D3DXCOLOR(const float *color); + D3DXCOLOR(const D3DXFLOAT16 *color); + D3DXCOLOR(float r, float g, float b, float a); + + operator UINT() const; + operator float *(); + operator const float *() const; + + D3DXCOLOR & operator+=(const D3DXCOLOR &color); + D3DXCOLOR & operator-=(const D3DXCOLOR &color); + D3DXCOLOR & operator*=(float n); + D3DXCOLOR & operator/=(float n); + + D3DXCOLOR operator+() const; + D3DXCOLOR operator-() const; + + D3DXCOLOR operator+(const D3DXCOLOR &color) const; + D3DXCOLOR operator-(const D3DXCOLOR &color) const; + D3DXCOLOR operator*(float n) const; + D3DXCOLOR operator/(float n) const; + + friend D3DXCOLOR operator*(float n, const D3DXCOLOR &color); + + BOOL operator==(const D3DXCOLOR &color) const; + BOOL operator!=(const D3DXCOLOR &color) const; +#endif + float r, g, b, a; +} D3DXCOLOR, *LPD3DXCOLOR; + +typedef struct D3DXVECTOR2 +{ +#ifdef __cplusplus + D3DXVECTOR2() {}; + D3DXVECTOR2(const float *pf); + D3DXVECTOR2(float fx, float fy); + + operator float* (); + operator const float* () const; + + D3DXVECTOR2& operator += (const D3DXVECTOR2&); + D3DXVECTOR2& operator -= (const D3DXVECTOR2&); + D3DXVECTOR2& operator *= (float); + D3DXVECTOR2& operator /= (float); + + D3DXVECTOR2 operator + () const; + D3DXVECTOR2 operator - () const; + + D3DXVECTOR2 operator + (const D3DXVECTOR2&) const; + D3DXVECTOR2 operator - (const D3DXVECTOR2&) const; + D3DXVECTOR2 operator * (float) const; + D3DXVECTOR2 operator / (float) const; + + friend D3DXVECTOR2 operator * (float, const D3DXVECTOR2&); + + BOOL operator == (const D3DXVECTOR2&) const; + BOOL operator != (const D3DXVECTOR2&) const; +#endif /* __cplusplus */ + float x, y; +} D3DXVECTOR2, *LPD3DXVECTOR2; + +#ifdef __cplusplus +typedef struct D3DXVECTOR3 : public D3DVECTOR +{ + D3DXVECTOR3() {}; + D3DXVECTOR3(const float *pf); + D3DXVECTOR3(const D3DVECTOR& v); + D3DXVECTOR3(float fx, float fy, float fz); + + operator float* (); + operator const float* () const; + + D3DXVECTOR3& operator += (const D3DXVECTOR3&); + D3DXVECTOR3& operator -= (const D3DXVECTOR3&); + D3DXVECTOR3& operator *= (float); + D3DXVECTOR3& operator /= (float); + + D3DXVECTOR3 operator + () const; + D3DXVECTOR3 operator - () const; + + D3DXVECTOR3 operator + (const D3DXVECTOR3&) const; + D3DXVECTOR3 operator - (const D3DXVECTOR3&) const; + D3DXVECTOR3 operator * (float) const; + D3DXVECTOR3 operator / (float) const; + + friend D3DXVECTOR3 operator * (float, const struct D3DXVECTOR3&); + + BOOL operator == (const D3DXVECTOR3&) const; + BOOL operator != (const D3DXVECTOR3&) const; +} D3DXVECTOR3, *LPD3DXVECTOR3; +#else /* !__cplusplus */ +typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3; +#endif /* !__cplusplus */ + +typedef struct D3DXVECTOR4 +{ +#ifdef __cplusplus + D3DXVECTOR4() {}; + D3DXVECTOR4(const float *pf); + D3DXVECTOR4(float fx, float fy, float fz, float fw); + + operator float* (); + operator const float* () const; + + D3DXVECTOR4& operator += (const D3DXVECTOR4&); + D3DXVECTOR4& operator -= (const D3DXVECTOR4&); + D3DXVECTOR4& operator *= (float); + D3DXVECTOR4& operator /= (float); + + D3DXVECTOR4 operator + () const; + D3DXVECTOR4 operator - () const; + + D3DXVECTOR4 operator + (const D3DXVECTOR4&) const; + D3DXVECTOR4 operator - (const D3DXVECTOR4&) const; + D3DXVECTOR4 operator * (float) const; + D3DXVECTOR4 operator / (float) const; + + friend D3DXVECTOR4 operator * (float, const D3DXVECTOR4&); + + BOOL operator == (const D3DXVECTOR4&) const; + BOOL operator != (const D3DXVECTOR4&) const; +#endif /* __cplusplus */ + float x, y, z, w; +} D3DXVECTOR4, *LPD3DXVECTOR4; + +#ifdef __cplusplus +typedef struct D3DXMATRIX : public D3DMATRIX +{ + D3DXMATRIX() {}; + D3DXMATRIX(const float *pf); + D3DXMATRIX(const D3DMATRIX& mat); + D3DXMATRIX(float f11, float f12, float f13, float f14, + float f21, float f22, float f23, float f24, + float f31, float f32, float f33, float f34, + float f41, float f42, float f43, float f44); + + float& operator () (UINT row, UINT col); + float operator () (UINT row, UINT col) const; + + operator float* (); + operator const float* () const; + + D3DXMATRIX& operator *= (const D3DXMATRIX&); + D3DXMATRIX& operator += (const D3DXMATRIX&); + D3DXMATRIX& operator -= (const D3DXMATRIX&); + D3DXMATRIX& operator *= (float); + D3DXMATRIX& operator /= (float); + + D3DXMATRIX operator + () const; + D3DXMATRIX operator - () const; + + D3DXMATRIX operator * (const D3DXMATRIX&) const; + D3DXMATRIX operator + (const D3DXMATRIX&) const; + D3DXMATRIX operator - (const D3DXMATRIX&) const; + D3DXMATRIX operator * (float) const; + D3DXMATRIX operator / (float) const; + + friend D3DXMATRIX operator * (float, const D3DXMATRIX&); + + BOOL operator == (const D3DXMATRIX&) const; + BOOL operator != (const D3DXMATRIX&) const; +} D3DXMATRIX, *LPD3DXMATRIX; +#else /* !__cplusplus */ +typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX; +#endif /* !__cplusplus */ + +#ifdef __cplusplus +extern "C" { +#endif + +D3DXCOLOR *D3DXColorAdd(D3DXCOLOR *out, D3DXCOLOR c1, D3DXCOLOR c2); +D3DXCOLOR *D3DXColorLerp(D3DXCOLOR *out, D3DXCOLOR c1, D3DXCOLOR c2, float s); +D3DXCOLOR *D3DXColorModulate(D3DXCOLOR *out, D3DXCOLOR c1, D3DXCOLOR c2); +D3DXCOLOR *D3DXColorScale(D3DXCOLOR *out, D3DXCOLOR c, float s); +D3DXCOLOR *D3DXColorSubtract(D3DXCOLOR *out, D3DXCOLOR c1, D3DXCOLOR c2); +D3DX_CPU_OPTIMIZATION WINAPI D3DXCpuOptimizations(BOOL enable); + +#ifdef __cplusplus +} +#endif + +#endif /* __D3DX9MATH_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx10mesh.h b/WineFix/lib/d2d1/include/windows/d3dx10mesh.h new file mode 100644 index 0000000..d813ef6 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx10mesh.h @@ -0,0 +1,99 @@ +/* + * Copyright 2021 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx10.h" + +DEFINE_GUID(IID_ID3DX10Mesh, 0x4020e5c2, 0x1403, 0x4929, 0x88, 0x3f, 0xe2, 0xe8, 0x49, 0xfa, 0xc1, 0x95); +DEFINE_GUID(IID_ID3DX10MeshBuffer, 0x4b0d117, 0x1041, 0x46b1, 0xaa, 0x8a, 0x39, 0x52, 0x84, 0x8b, 0xa2, 0x2e); + +typedef enum _D3DX10_MESH_DISCARD_FLAGS +{ + D3DX10_MESH_DISCARD_ATTRIBUTE_BUFFER = 0x01, + D3DX10_MESH_DISCARD_ATTRIBUTE_TABLE = 0x02, + D3DX10_MESH_DISCARD_POINTREPS = 0x04, + D3DX10_MESH_DISCARD_ADJACENCY = 0x08, + D3DX10_MESH_DISCARD_DEVICE_BUFFERS = 0x10, +} D3DX10_MESH_DISCARD_FLAGS; + +typedef struct _D3DX10_ATTRIBUTE_RANGE +{ + UINT AttribId; + UINT FaceStart; + UINT FaceCount; + UINT VertexStart; + UINT VertexCount; +} D3DX10_ATTRIBUTE_RANGE; +typedef D3DX10_ATTRIBUTE_RANGE* LPD3DX10_ATTRIBUTE_RANGE; + +#define INTERFACE ID3DX10MeshBuffer +DECLARE_INTERFACE_(ID3DX10MeshBuffer, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DX10MeshBuffer methods ***/ + STDMETHOD(Map)(THIS_ void **data, SIZE_T *size) PURE; + STDMETHOD(Unmap)(THIS) PURE; + STDMETHOD_(SIZE_T, GetSize)(THIS) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DX10Mesh +DECLARE_INTERFACE_(ID3DX10Mesh, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DX10Mesh methods ***/ + STDMETHOD_(UINT, GetFaceCount)(THIS) PURE; + STDMETHOD_(UINT, GetVertexCount)(THIS) PURE; + STDMETHOD_(UINT, GetVertexBufferCount)(THIS) PURE; + STDMETHOD_(UINT, GetFlags)(THIS) PURE; + STDMETHOD(GetVertexDescription)(THIS_ const D3D10_INPUT_ELEMENT_DESC **desc, UINT *count) PURE; + STDMETHOD(SetVertexData)(THIS_ UINT index, const void *data) PURE; + STDMETHOD(GetVertexBuffer)(THIS_ UINT index, ID3DX10MeshBuffer **buffer) PURE; + STDMETHOD(SetIndexData)(THIS_ const void *data, UINT count) PURE; + STDMETHOD(GetIndexBuffer)(THIS_ ID3DX10MeshBuffer **buffer) PURE; + STDMETHOD(SetAttributeData)(THIS_ const UINT *data) PURE; + STDMETHOD(GetAttributeBuffer)(THIS_ ID3DX10MeshBuffer **buffer) PURE; + STDMETHOD(SetAttributeTable)(THIS_ const D3DX10_ATTRIBUTE_RANGE *table, UINT size) PURE; + STDMETHOD(GetAttributeTable)(THIS_ D3DX10_ATTRIBUTE_RANGE *table, UINT *size) PURE; + STDMETHOD(GenerateAdjacencyAndPointReps)(THIS_ float epsilon) PURE; + STDMETHOD(GenerateGSAdjacency)(THIS) PURE; + STDMETHOD(SetAdjacencyData)(THIS_ const UINT *adjacency) PURE; + STDMETHOD(GetAdjacenctBuffer)(THIS_ ID3DX10MeshBuffer **buffer) PURE; + STDMETHOD(SetPointRepData)(THIS_ const UINT *pointreps) PURE; + STDMETHOD(GetPointRepBuffer)(THIS_ ID3DX10MeshBuffer **buffer) PURE; + STDMETHOD(Discard)(THIS_ D3DX10_MESH_DISCARD_FLAGS flags) PURE; + STDMETHOD(CloneMesh)(THIS_ UINT flags, const char *pos_semantic, const D3D10_INPUT_ELEMENT_DESC *desc, + UINT decl_count, ID3DX10Mesh **cloned_mesh); + STDMETHOD(Optimize)(THIS_ UINT flags, UINT *face_remap, ID3D10Blob **vertex_remap) PURE; + STDMETHOD(GenerateAttributeBufferFromTable)(THIS) PURE; + STDMETHOD(Intersect)(THIS_ D3DXVECTOR3 *ray_pos, D3DXVECTOR3 *ray_dir, UINT *hit_count, UINT *face_index, + float *u, float *v, float *dist, ID3D10Blob **all_hits) PURE; + STDMETHOD(IntersectSubset)(THIS_ UINT attr_id, D3DXVECTOR3 *ray_pos, D3DXVECTOR3 *ray_dir, UINT *hit_count, + float *u, float *v, float *dist, ID3D10Blob **all_hits) PURE; + STDMETHOD(CommitToDevice)(THIS) PURE; + STDMETHOD(DrawSubset)(THIS_ UINT attr_id) PURE; + STDMETHOD(DrawSubsetInstanced)(THIS_ UINT attr_id, UINT instance_count, UINT start_instance) PURE; + STDMETHOD(GetDeviceVertexBuffer)(THIS_ UINT index, ID3D10Buffer **buffer) PURE; + STDMETHOD(GetDeviceIndexBuffer)(THIS_ ID3D10Buffer **buffer) PURE; +}; +#undef INTERFACE diff --git a/WineFix/lib/d2d1/include/windows/d3dx10tex.h b/WineFix/lib/d2d1/include/windows/d3dx10tex.h new file mode 100644 index 0000000..33e41e5 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx10tex.h @@ -0,0 +1,178 @@ +/* + * Copyright 2016 Alistair Leslie-Hughes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx10.h" + +#ifndef __D3DX10TEX_H__ +#define __D3DX10TEX_H__ + +typedef enum D3DX10_FILTER_FLAG +{ + D3DX10_FILTER_NONE = 0x00000001, + D3DX10_FILTER_POINT = 0x00000002, + D3DX10_FILTER_LINEAR = 0x00000003, + D3DX10_FILTER_TRIANGLE = 0x00000004, + D3DX10_FILTER_BOX = 0x00000005, + + D3DX10_FILTER_MIRROR_U = 0x00010000, + D3DX10_FILTER_MIRROR_V = 0x00020000, + D3DX10_FILTER_MIRROR_W = 0x00040000, + D3DX10_FILTER_MIRROR = 0x00070000, + + D3DX10_FILTER_DITHER = 0x00080000, + D3DX10_FILTER_DITHER_DIFFUSION = 0x00100000, + + D3DX10_FILTER_SRGB_IN = 0x00200000, + D3DX10_FILTER_SRGB_OUT = 0x00400000, + D3DX10_FILTER_SRGB = 0x00600000, +} D3DX10_FILTER_FLAG; + +typedef enum D3DX10_IMAGE_FILE_FORMAT +{ + D3DX10_IFF_BMP = 0, + D3DX10_IFF_JPG = 1, + D3DX10_IFF_PNG = 3, + D3DX10_IFF_DDS = 4, + D3DX10_IFF_TIFF = 10, + D3DX10_IFF_GIF = 11, + D3DX10_IFF_WMP = 12, + D3DX10_IFF_FORCE_DWORD = 0x7fffffff +} D3DX10_IMAGE_FILE_FORMAT; + +typedef struct D3DX10_IMAGE_INFO +{ + UINT Width; + UINT Height; + UINT Depth; + UINT ArraySize; + UINT MipLevels; + UINT MiscFlags; + DXGI_FORMAT Format; + D3D10_RESOURCE_DIMENSION ResourceDimension; + D3DX10_IMAGE_FILE_FORMAT ImageFileFormat; +} D3DX10_IMAGE_INFO; + +typedef struct D3DX10_IMAGE_LOAD_INFO +{ + UINT Width; + UINT Height; + UINT Depth; + UINT FirstMipLevel; + UINT MipLevels; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CpuAccessFlags; + UINT MiscFlags; + DXGI_FORMAT Format; + UINT Filter; + UINT MipFilter; + D3DX10_IMAGE_INFO *pSrcInfo; + +#ifdef __cplusplus + D3DX10_IMAGE_LOAD_INFO() + { + Width = D3DX10_DEFAULT; + Height = D3DX10_DEFAULT; + Depth = D3DX10_DEFAULT; + FirstMipLevel = D3DX10_DEFAULT; + MipLevels = D3DX10_DEFAULT; + Usage = (D3D10_USAGE)D3DX10_DEFAULT; + BindFlags = D3DX10_DEFAULT; + CpuAccessFlags = D3DX10_DEFAULT; + MiscFlags = D3DX10_DEFAULT; + Format = DXGI_FORMAT_FROM_FILE; + Filter = D3DX10_DEFAULT; + MipFilter = D3DX10_DEFAULT; + pSrcInfo = NULL; + } +#endif +} D3DX10_IMAGE_LOAD_INFO; + +typedef struct _D3DX10_TEXTURE_LOAD_INFO +{ + D3D10_BOX *pSrcBox; + D3D10_BOX *pDstBox; + UINT SrcFirstMip; + UINT DstFirstMip; + UINT NumMips; + UINT SrcFirstElement; + UINT DstFirstElement; + UINT NumElements; + UINT Filter; + UINT MipFilter; + +#ifdef __cplusplus + _D3DX10_TEXTURE_LOAD_INFO() + { + pSrcBox = NULL; + pDstBox = NULL; + SrcFirstMip = 0; + DstFirstMip = 0; + NumMips = D3DX10_DEFAULT; + SrcFirstElement = 0; + DstFirstElement = 0; + NumElements = D3DX10_DEFAULT; + Filter = D3DX10_DEFAULT; + MipFilter = D3DX10_DEFAULT; + } +#endif +} D3DX10_TEXTURE_LOAD_INFO; + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DX10CreateTextureFromMemory(ID3D10Device *device, const void *src_data, SIZE_T src_data_size, + D3DX10_IMAGE_LOAD_INFO *loadinfo, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult); +HRESULT WINAPI D3DX10FilterTexture(ID3D10Resource *texture, UINT src_level, UINT filter); + +HRESULT WINAPI D3DX10GetImageInfoFromFileA(const char *src_file, ID3DX10ThreadPump *pump, D3DX10_IMAGE_INFO *info, + HRESULT *result); +HRESULT WINAPI D3DX10GetImageInfoFromFileW(const WCHAR *src_file, ID3DX10ThreadPump *pump, D3DX10_IMAGE_INFO *info, + HRESULT *result); +#define D3DX10GetImageInfoFromFile WINELIB_NAME_AW(D3DX10GetImageInfoFromFile) + +HRESULT WINAPI D3DX10GetImageInfoFromResourceA(HMODULE module, const char *resource, ID3DX10ThreadPump *pump, + D3DX10_IMAGE_INFO *info, HRESULT *result); +HRESULT WINAPI D3DX10GetImageInfoFromResourceW(HMODULE module, const WCHAR *resource, ID3DX10ThreadPump *pump, + D3DX10_IMAGE_INFO *info, HRESULT *result); +#define D3DX10GetImageInfoFromResource WINELIB_NAME_AW(D3DX10GetImageInfoFromResource) + +HRESULT WINAPI D3DX10GetImageInfoFromMemory(const void *src_data, SIZE_T src_data_size, ID3DX10ThreadPump *pump, + D3DX10_IMAGE_INFO *img_info, HRESULT *hresult); + +HRESULT WINAPI D3DX10CreateTextureFromFileA(ID3D10Device *device, const char *src_file, + D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult); +HRESULT WINAPI D3DX10CreateTextureFromFileW(ID3D10Device *device, const WCHAR *src_file, + D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult); +#define D3DX10CreateTextureFromFile WINELIB_NAME_AW(D3DX10CreateTextureFromFile) + +HRESULT WINAPI D3DX10CreateTextureFromResourceA(ID3D10Device *device, HMODULE module, const char *resource, + D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult); +HRESULT WINAPI D3DX10CreateTextureFromResourceW(ID3D10Device *device, HMODULE module, const WCHAR *resource, + D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult); +#define D3DX10CreateTextureFromResource WINELIB_NAME_AW(D3DX10CreateTextureFromResource) + +HRESULT WINAPI D3DX10LoadTextureFromTexture(ID3D10Resource *src_texture, D3DX10_TEXTURE_LOAD_INFO *load_info, + ID3D10Resource *dst_texture); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx11.h b/WineFix/lib/d2d1/include/windows/d3dx11.h new file mode 100644 index 0000000..e155785 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx11.h @@ -0,0 +1,50 @@ +/* + * Copyright 2016 Andrey Gusev + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DX11_H__ +#define __D3DX11_H__ + +#include +#include + +#define D3DX11_DEFAULT (0xffffffffu) +#define D3DX11_FROM_FILE (0xfffffffdu) +#define DXGI_FORMAT_FROM_FILE ((DXGI_FORMAT)0xfffffffdu) + +#include "d3d11.h" +#include "d3dx11core.h" +#include "d3dx11async.h" +#include "d3dx11tex.h" + +#define _FACDD 0x876 +#define MAKE_DDHRESULT(code) MAKE_HRESULT(SEVERITY_ERROR, _FACDD, code) + +enum _D3DX11_ERR +{ + D3DX11_ERR_CANNOT_MODIFY_INDEX_BUFFER = MAKE_DDHRESULT(2900), + D3DX11_ERR_INVALID_MESH = MAKE_DDHRESULT(2901), + D3DX11_ERR_CANNOT_ATTR_SORT = MAKE_DDHRESULT(2902), + D3DX11_ERR_SKINNING_NOT_SUPPORTED = MAKE_DDHRESULT(2903), + D3DX11_ERR_TOO_MANY_INFLUENCES = MAKE_DDHRESULT(2904), + D3DX11_ERR_INVALID_DATA = MAKE_DDHRESULT(2905), + D3DX11_ERR_LOADED_MESH_HAS_NO_DATA = MAKE_DDHRESULT(2906), + D3DX11_ERR_DUPLICATE_NAMED_FRAGMENT = MAKE_DDHRESULT(2907), + D3DX11_ERR_CANNOT_REMOVE_LAST_ITEM = MAKE_DDHRESULT(2908) +}; + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx11async.h b/WineFix/lib/d2d1/include/windows/d3dx11async.h new file mode 100644 index 0000000..2d85e4a --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx11async.h @@ -0,0 +1,51 @@ +/* + * Copyright 2016 Matteo Bruni for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DX11ASYNC_H__ +#define __D3DX11ASYNC_H__ + +#include "d3dx11.h" + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DX11CreateAsyncFileLoaderA(const char *file_name, ID3DX11DataLoader **loader); +HRESULT WINAPI D3DX11CreateAsyncFileLoaderW(const WCHAR *file_name, ID3DX11DataLoader **loader); +HRESULT WINAPI D3DX11CreateAsyncResourceLoaderA(HMODULE module, const char *resource, ID3DX11DataLoader **loader); +HRESULT WINAPI D3DX11CreateAsyncResourceLoaderW(HMODULE module, const WCHAR *resource, ID3DX11DataLoader **loader); +HRESULT WINAPI D3DX11CreateAsyncMemoryLoader(const void *data, SIZE_T data_size, ID3DX11DataLoader **loader); + +HRESULT WINAPI D3DX11CompileFromMemory(const char *data, SIZE_T data_size, const char *filename, + const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point, + const char *target, UINT sflags, UINT eflags, ID3DX11ThreadPump *pump, ID3D10Blob **shader, + ID3D10Blob **error_messages, HRESULT *hresult); + +HRESULT WINAPI D3DX11CompileFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines, + ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags, + ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult); + +HRESULT WINAPI D3DX11CompileFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines, + ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags, + ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx11core.idl b/WineFix/lib/d2d1/include/windows/d3dx11core.idl new file mode 100644 index 0000000..f619e3b --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx11core.idl @@ -0,0 +1,65 @@ +/* + * Copyright 2016 Andrey Gusev + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi.idl"; +import "d3dcommon.idl"; + +[ + object, + local, + pointer_default(unique) +] +interface ID3DX11DataLoader +{ + HRESULT Load(); + HRESULT Decompress([out] void **data, [in] SIZE_T *bytes); + HRESULT Destroy(); +} + +[ + object, + local, + pointer_default(unique) +] +interface ID3DX11DataProcessor +{ + HRESULT Process([in] void *data, [in] SIZE_T bytes); + HRESULT CreateDeviceObject([out] void **data_object); + HRESULT Destroy(); +} + +[ + object, + local, + pointer_default(unique), + uuid(c93fecfa-6967-478a-abbc-402d90621fcb) +] +interface ID3DX11ThreadPump : IUnknown +{ + HRESULT AddWorkItem([in] ID3DX11DataLoader *loader, [in] ID3DX11DataProcessor *processor, + [in] HRESULT *hresult, [out] void **device_object); + UINT GetWorkItemCount(); + + HRESULT WaitForAllItems(); + HRESULT ProcessDeviceWorkItems([in] UINT count); + + HRESULT PurgeAllItems(); + HRESULT GetQueueStatus([in] UINT *io_queue, [in] UINT *process_queue, [in] UINT *device_queue); +} diff --git a/WineFix/lib/d2d1/include/windows/d3dx11tex.h b/WineFix/lib/d2d1/include/windows/d3dx11tex.h new file mode 100644 index 0000000..fae5ee9 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx11tex.h @@ -0,0 +1,171 @@ +/* + * Copyright 2016 Andrey Gusev + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx11.h" + +#ifndef __D3DX11TEX_H__ +#define __D3DX11TEX_H__ + +typedef enum D3DX11_FILTER_FLAG +{ + D3DX11_FILTER_NONE = 0x00000001, + D3DX11_FILTER_POINT = 0x00000002, + D3DX11_FILTER_LINEAR = 0x00000003, + D3DX11_FILTER_TRIANGLE = 0x00000004, + D3DX11_FILTER_BOX = 0x00000005, + + D3DX11_FILTER_MIRROR_U = 0x00010000, + D3DX11_FILTER_MIRROR_V = 0x00020000, + D3DX11_FILTER_MIRROR_W = 0x00040000, + D3DX11_FILTER_MIRROR = 0x00070000, + + D3DX11_FILTER_DITHER = 0x00080000, + D3DX11_FILTER_DITHER_DIFFUSION = 0x00100000, + + D3DX11_FILTER_SRGB_IN = 0x00200000, + D3DX11_FILTER_SRGB_OUT = 0x00400000, + D3DX11_FILTER_SRGB = 0x00600000, +} D3DX11_FILTER_FLAG; + +typedef enum D3DX11_IMAGE_FILE_FORMAT +{ + D3DX11_IFF_BMP = 0, + D3DX11_IFF_JPG = 1, + D3DX11_IFF_PNG = 3, + D3DX11_IFF_DDS = 4, + D3DX11_IFF_TIFF = 10, + D3DX11_IFF_GIF = 11, + D3DX11_IFF_WMP = 12, + D3DX11_IFF_FORCE_DWORD = 0x7fffffff +} D3DX11_IMAGE_FILE_FORMAT; + +typedef struct D3DX11_IMAGE_INFO +{ + UINT Width; + UINT Height; + UINT Depth; + UINT ArraySize; + UINT MipLevels; + UINT MiscFlags; + DXGI_FORMAT Format; + D3D11_RESOURCE_DIMENSION ResourceDimension; + D3DX11_IMAGE_FILE_FORMAT ImageFileFormat; +} D3DX11_IMAGE_INFO; + +typedef struct D3DX11_IMAGE_LOAD_INFO +{ + UINT Width; + UINT Height; + UINT Depth; + UINT FirstMipLevel; + UINT MipLevels; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CpuAccessFlags; + UINT MiscFlags; + DXGI_FORMAT Format; + UINT Filter; + UINT MipFilter; + D3DX11_IMAGE_INFO *pSrcInfo; + +#ifdef __cplusplus + D3DX11_IMAGE_LOAD_INFO() + { + Width = D3DX11_DEFAULT; + Height = D3DX11_DEFAULT; + Depth = D3DX11_DEFAULT; + FirstMipLevel = D3DX11_DEFAULT; + MipLevels = D3DX11_DEFAULT; + Usage = (D3D11_USAGE)D3DX11_DEFAULT; + BindFlags = D3DX11_DEFAULT; + CpuAccessFlags = D3DX11_DEFAULT; + MiscFlags = D3DX11_DEFAULT; + Format = DXGI_FORMAT_FROM_FILE; + Filter = D3DX11_DEFAULT; + MipFilter = D3DX11_DEFAULT; + pSrcInfo = NULL; + } +#endif +} D3DX11_IMAGE_LOAD_INFO; + +typedef struct _D3DX11_TEXTURE_LOAD_INFO +{ + D3D11_BOX *pSrcBox; + D3D11_BOX *pDstBox; + UINT SrcFirstMip; + UINT DstFirstMip; + UINT NumMips; + UINT SrcFirstElement; + UINT DstFirstElement; + UINT NumElements; + UINT Filter; + UINT MipFilter; + +#ifdef __cplusplus + _D3DX11_TEXTURE_LOAD_INFO() + { + pSrcBox = NULL; + pDstBox = NULL; + SrcFirstMip = 0; + DstFirstMip = 0; + NumMips = D3DX11_DEFAULT; + SrcFirstElement = 0; + DstFirstElement = 0; + NumElements = D3DX11_DEFAULT; + Filter = D3DX11_DEFAULT; + MipFilter = D3DX11_DEFAULT; + } +#endif +} D3DX11_TEXTURE_LOAD_INFO; + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DX11CreateShaderResourceViewFromMemory(ID3D11Device *device, const void *data, + SIZE_T data_size, D3DX11_IMAGE_LOAD_INFO *load_info, ID3DX11ThreadPump *pump, + ID3D11ShaderResourceView **view, HRESULT *hresult); +HRESULT WINAPI D3DX11CreateTextureFromFileA(ID3D11Device *device, const char *filename, + D3DX11_IMAGE_LOAD_INFO *load_info, ID3DX11ThreadPump *pump, ID3D11Resource **texture, + HRESULT *hresult); +HRESULT WINAPI D3DX11CreateTextureFromFileW(ID3D11Device *device, const WCHAR *filename, + D3DX11_IMAGE_LOAD_INFO *load_info, ID3DX11ThreadPump *pump, ID3D11Resource **texture, + HRESULT *hresult); +HRESULT WINAPI D3DX11CreateTextureFromMemory(ID3D11Device *device, const void *src_data, SIZE_T src_data_size, + D3DX11_IMAGE_LOAD_INFO *loadinfo, ID3DX11ThreadPump *pump, ID3D11Resource **texture, HRESULT *hresult); +HRESULT WINAPI D3DX11FilterTexture(ID3D11DeviceContext *context, ID3D11Resource *texture, UINT src_level, UINT filter); +HRESULT WINAPI D3DX11GetImageInfoFromFileA(const char *filename, ID3DX11ThreadPump *pump, D3DX11_IMAGE_INFO *img_info, + HRESULT *hresult); +HRESULT WINAPI D3DX11GetImageInfoFromFileW(const WCHAR *filename, ID3DX11ThreadPump *pump, D3DX11_IMAGE_INFO *img_info, + HRESULT *hresult); +HRESULT WINAPI D3DX11GetImageInfoFromMemory(const void *src_data, SIZE_T src_data_size, ID3DX11ThreadPump *pump, + D3DX11_IMAGE_INFO *img_info, HRESULT *hresult); +HRESULT WINAPI D3DX11LoadTextureFromTexture(ID3D11DeviceContext *context, ID3D11Resource *src_texture, + D3DX11_TEXTURE_LOAD_INFO *info, ID3D11Resource *dst_texture); +HRESULT WINAPI D3DX11SaveTextureToFileA(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, const char *filename); +HRESULT WINAPI D3DX11SaveTextureToFileW(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, const WCHAR *filename); +HRESULT WINAPI D3DX11SaveTextureToMemory(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, ID3D10Blob **buffer, UINT flags); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx9.h b/WineFix/lib/d2d1/include/windows/d3dx9.h new file mode 100644 index 0000000..97d4234 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2007 David Adam + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __D3DX9_H__ +#define __D3DX9_H__ + +#include + +#define D3DX_DEFAULT ((UINT)-1) +#define D3DX_DEFAULT_NONPOW2 ((UINT)-2) +#define D3DX_DEFAULT_FLOAT FLT_MAX +#define D3DX_FROM_FILE ((UINT)-3) +#define D3DFMT_FROM_FILE ((D3DFORMAT)-3) + +#include "d3d9.h" +#include "d3dx9math.h" +#include "d3dx9core.h" +#include "d3dx9xof.h" +#include "d3dx9mesh.h" +#include "d3dx9shader.h" +#include "d3dx9effect.h" +#include "d3dx9shape.h" +#include "d3dx9anim.h" +#include "d3dx9tex.h" + +#define _FACDD 0x876 +#define MAKE_DDHRESULT(code) MAKE_HRESULT(1, _FACDD, code) + +enum _D3DXERR { + D3DXERR_CANNOTMODIFYINDEXBUFFER = MAKE_DDHRESULT(2900), + D3DXERR_INVALIDMESH = MAKE_DDHRESULT(2901), + D3DXERR_CANNOTATTRSORT = MAKE_DDHRESULT(2902), + D3DXERR_SKINNINGNOTSUPPORTED = MAKE_DDHRESULT(2903), + D3DXERR_TOOMANYINFLUENCES = MAKE_DDHRESULT(2904), + D3DXERR_INVALIDDATA = MAKE_DDHRESULT(2905), + D3DXERR_LOADEDMESHASNODATA = MAKE_DDHRESULT(2906), + D3DXERR_DUPLICATENAMEDFRAGMENT = MAKE_DDHRESULT(2907), + D3DXERR_CANNOTREMOVELASTITEM = MAKE_DDHRESULT(2908), +}; + +#endif diff --git a/WineFix/lib/d2d1/include/windows/d3dx9anim.h b/WineFix/lib/d2d1/include/windows/d3dx9anim.h new file mode 100644 index 0000000..54f7ce9 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9anim.h @@ -0,0 +1,410 @@ +/* + * Copyright 2011 Dylan Smith + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DX9ANIM_H +#define __WINE_D3DX9ANIM_H + +DEFINE_GUID(IID_ID3DXAnimationSet, 0x698cfb3f, 0x9289, 0x4d95, 0x9a, 0x57, 0x33, 0xa9, 0x4b, 0x5a, 0x65, 0xf9); +DEFINE_GUID(IID_ID3DXKeyframedAnimationSet, 0xfa4e8e3a, 0x9786, 0x407d, 0x8b, 0x4c, 0x59, 0x95, 0x89, 0x37, 0x64, 0xaf); +DEFINE_GUID(IID_ID3DXCompressedAnimationSet, 0x6cc2480d, 0x3808, 0x4739, 0x9f, 0x88, 0xde, 0x49, 0xfa, 0xcd, 0x8d, 0x4c); +DEFINE_GUID(IID_ID3DXAnimationController, 0xac8948ec, 0xf86d, 0x43e2, 0x96, 0xde, 0x31, 0xfc, 0x35, 0xf9, 0x6d, 0x9e); + +typedef enum _D3DXMESHDATATYPE +{ + D3DXMESHTYPE_MESH = 1, + D3DXMESHTYPE_PMESH = 2, + D3DXMESHTYPE_PATCHMESH = 3, + D3DXMESHTYPE_FORCE_DWORD = 0x7fffffff, +} D3DXMESHDATATYPE; + +typedef enum _D3DXCALLBACK_SEARCH_FLAGS +{ + D3DXCALLBACK_SEARCH_EXCLUDING_INITIAL_POSITION = 0x00000001, + D3DXCALLBACK_SEARCH_BEHIND_INITIAL_POSITION = 0x00000002, + D3DXCALLBACK_SEARCH_FORCE_DWORD = 0x7fffffff, +} D3DXCALLBACK_SEARCH_FLAGS; + +typedef enum _D3DXPLAYBACK_TYPE +{ + D3DXPLAY_LOOP = 0, + D3DXPLAY_ONCE = 1, + D3DXPLAY_PINGPONG = 2, + D3DXPLAY_FORCE_DWORD = 0x7fffffff, +} D3DXPLAYBACK_TYPE; + +typedef enum _D3DXCOMPRESSION_FLAGS +{ + D3DXCOMPRESSION_DEFAULT = 0x00000000, + D3DXCOMPRESSION_FORCE_DWORD = 0x7fffffff, +} D3DXCOMPRESSION_FLAGS; + +typedef enum _D3DXPRIORITY_TYPE +{ + D3DXPRIORITY_LOW = 0, + D3DXPRIORITY_HIGH = 1, + D3DXPRIORITY_FORCE_DWORD = 0x7fffffff, +} D3DXPRIORITY_TYPE; + +typedef enum _D3DXEVENT_TYPE +{ + D3DXEVENT_TRACKSPEED = 0, + D3DXEVENT_TRACKWEIGHT = 1, + D3DXEVENT_TRACKPOSITION = 2, + D3DXEVENT_TRACKENABLE = 3, + D3DXEVENT_PRIORITYBLEND = 4, + D3DXEVENT_FORCE_DWORD = 0x7fffffff, +} D3DXEVENT_TYPE; + +typedef enum _D3DXTRANSITION_TYPE +{ + D3DXTRANSITION_LINEAR = 0, + D3DXTRANSITION_EASEINEASEOUT = 1, + D3DXTRANSITION_FORCE_DWORD = 0x7fffffff, +} D3DXTRANSITION_TYPE; + + +typedef struct _D3DXMESHDATA +{ + D3DXMESHDATATYPE Type; + + union + { + ID3DXMesh *pMesh; + ID3DXPMesh *pPMesh; + ID3DXPatchMesh *pPatchMesh; + } DUMMYUNIONNAME; +} D3DXMESHDATA, *LPD3DXMESHDATA; + +typedef struct _D3DXMESHCONTAINER +{ + char *Name; + D3DXMESHDATA MeshData; + LPD3DXMATERIAL pMaterials; + LPD3DXEFFECTINSTANCE pEffects; + DWORD NumMaterials; + DWORD *pAdjacency; + ID3DXSkinInfo *pSkinInfo; + struct _D3DXMESHCONTAINER *pNextMeshContainer; +} D3DXMESHCONTAINER, *LPD3DXMESHCONTAINER; + +typedef struct _D3DXFRAME +{ + char *Name; + D3DXMATRIX TransformationMatrix; + LPD3DXMESHCONTAINER pMeshContainer; + struct _D3DXFRAME *pFrameSibling; + struct _D3DXFRAME *pFrameFirstChild; +} D3DXFRAME, *LPD3DXFRAME; + +typedef struct _D3DXKEY_VECTOR3 +{ + FLOAT Time; + D3DXVECTOR3 Value; +} D3DXKEY_VECTOR3, *LPD3DXKEY_VECTOR3; + +typedef struct _D3DXKEY_QUATERNION +{ + FLOAT Time; + D3DXQUATERNION Value; +} D3DXKEY_QUATERNION, *LPD3DXKEY_QUATERNION; + +typedef struct _D3DXKEY_CALLBACK +{ + float Time; + void *pCallbackData; +} D3DXKEY_CALLBACK, *LPD3DXKEY_CALLBACK; + +typedef struct _D3DXTRACK_DESC +{ + D3DXPRIORITY_TYPE Priority; + FLOAT Weight; + FLOAT Speed; + DOUBLE Position; + BOOL Enable; +} D3DXTRACK_DESC, *LPD3DXTRACK_DESC; + +typedef struct _D3DXEVENT_DESC +{ + D3DXEVENT_TYPE Type; + UINT Track; + DOUBLE StartTime; + DOUBLE Duration; + D3DXTRANSITION_TYPE Transition; + union + { + FLOAT Weight; + FLOAT Speed; + DOUBLE Position; + BOOL Enable; + } DUMMYUNIONNAME; +} D3DXEVENT_DESC, *LPD3DXEVENT_DESC; + +typedef DWORD D3DXEVENTHANDLE, *LPD3DXEVENTHANDLE; + +typedef interface ID3DXAllocateHierarchy *LPD3DXALLOCATEHIERARCHY; +typedef interface ID3DXLoadUserData *LPD3DXLOADUSERDATA; +typedef interface ID3DXSaveUserData *LPD3DXSAVEUSERDATA; +typedef interface ID3DXAnimationSet *LPD3DXANIMATIONSET; +typedef interface ID3DXKeyframedAnimationSet *LPD3DXKEYFRAMEDANIMATIONSET; +typedef interface ID3DXCompressedAnimationSet *LPD3DXCOMPRESSEDANIMATIONSET; +typedef interface ID3DXAnimationCallbackHandler *LPD3DXANIMATIONCALLBACKHANDLER; +typedef interface ID3DXAnimationController *LPD3DXANIMATIONCONTROLLER; + +#undef INTERFACE + +#define INTERFACE ID3DXAllocateHierarchy +DECLARE_INTERFACE(ID3DXAllocateHierarchy) +{ + STDMETHOD(CreateFrame)(THIS_ const char *name, D3DXFRAME **new_frame) PURE; + STDMETHOD(CreateMeshContainer)(THIS_ const char *name, const D3DXMESHDATA *mesh_data, + const D3DXMATERIAL *materials, const D3DXEFFECTINSTANCE *effect_instances, + DWORD num_materials, const DWORD *adjacency, ID3DXSkinInfo *skin_info, + D3DXMESHCONTAINER **new_mesh_container) PURE; + STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME frame) PURE; + STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER mesh_container) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXLoadUserData +DECLARE_INTERFACE(ID3DXLoadUserData) +{ + /* MS DirectX SDK headers define these methods without 'this' parameter. */ + STDMETHOD(LoadTopLevelData)(THIS_ ID3DXFileData *child_data) PURE; + STDMETHOD(LoadFrameChildData)(THIS_ D3DXFRAME *frame, ID3DXFileData *child_data) PURE; + STDMETHOD(LoadMeshChildData)(THIS_ D3DXMESHCONTAINER *mesh_container, ID3DXFileData *child_data) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXSaveUserData +DECLARE_INTERFACE(ID3DXSaveUserData) +{ + /* MS DirectX SDK headers define these methods without 'this' parameter. */ + STDMETHOD(AddFrameChildData)(THIS_ const D3DXFRAME *frame, + ID3DXFileSaveObject *save_obj, ID3DXFileSaveData *frame_data) PURE; + STDMETHOD(AddMeshChildData)(THIS_ const D3DXMESHCONTAINER *mesh_container, + ID3DXFileSaveObject *save_obj, ID3DXFileSaveData *mesh_data) PURE; + STDMETHOD(AddTopLevelDataObjectsPre)(THIS_ ID3DXFileSaveObject *save_obj) PURE; + STDMETHOD(AddTopLevelDataObjectsPost)(THIS_ ID3DXFileSaveObject *save_obj) PURE; + STDMETHOD(RegisterTemplates)(THIS_ ID3DXFile *file) PURE; + STDMETHOD(SaveTemplates)(THIS_ ID3DXFileSaveObject *save_obj) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXAnimationSet +DECLARE_INTERFACE_(ID3DXAnimationSet, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXAnimationSet methods ***/ + STDMETHOD_(const char *, GetName)(THIS) PURE; + STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE; + STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE position) PURE; + STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE; + STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, const char **name) PURE; + STDMETHOD(GetAnimationIndexByName)(THIS_ const char *name, UINT *index) PURE; + STDMETHOD(GetSRT)(THIS_ DOUBLE periodic_position, UINT animation, D3DXVECTOR3 *scale, + D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE; + STDMETHOD(GetCallback)(THIS_ double position, DWORD flags, double *callback_position, + void **callback_data) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXKeyframedAnimationSet +DECLARE_INTERFACE_(ID3DXKeyframedAnimationSet, ID3DXAnimationSet) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXAnimationSet methods ***/ + STDMETHOD_(const char *, GetName)(THIS) PURE; + STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE; + STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE position) PURE; + STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE; + STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, const char **name) PURE; + STDMETHOD(GetAnimationIndexByName)(THIS_ const char *name, UINT *index) PURE; + STDMETHOD(GetSRT)(THIS_ DOUBLE periodic_position, UINT animation, D3DXVECTOR3 *scale, + D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE; + STDMETHOD(GetCallback)(THIS_ double position, DWORD flags, double *callback_position, + void **callback_data) PURE; + /*** ID3DXKeyframedAnimationSet methods ***/ + STDMETHOD_(D3DXPLAYBACK_TYPE, GetPlaybackType)(THIS) PURE; + STDMETHOD_(DOUBLE, GetSourceTicksPerSecond)(THIS) PURE; + STDMETHOD_(UINT, GetNumScaleKeys)(THIS_ UINT animation) PURE; + STDMETHOD(GetScaleKeys)(THIS_ UINT animation, LPD3DXKEY_VECTOR3 scale_keys) PURE; + STDMETHOD(GetScaleKey)(THIS_ UINT animation, UINT key, LPD3DXKEY_VECTOR3 scale_key) PURE; + STDMETHOD(SetScaleKey)(THIS_ UINT animation, UINT key, LPD3DXKEY_VECTOR3 scale_key) PURE; + STDMETHOD_(UINT, GetNumRotationKeys)(THIS_ UINT animation) PURE; + STDMETHOD(GetRotationKeys)(THIS_ UINT animation, LPD3DXKEY_QUATERNION rotation_keys) PURE; + STDMETHOD(GetRotationKey)(THIS_ UINT animation, UINT key, LPD3DXKEY_QUATERNION rotation_key) PURE; + STDMETHOD(SetRotationKey)(THIS_ UINT animation, UINT key, LPD3DXKEY_QUATERNION rotation_key) PURE; + STDMETHOD_(UINT, GetNumTranslationKeys)(THIS_ UINT animation) PURE; + STDMETHOD(GetTranslationKeys)(THIS_ UINT animation, LPD3DXKEY_VECTOR3 translation_keys) PURE; + STDMETHOD(GetTranslationKey)(THIS_ UINT animation, UINT key, LPD3DXKEY_VECTOR3 translation_key) PURE; + STDMETHOD(SetTranslationKey)(THIS_ UINT animation, UINT key, LPD3DXKEY_VECTOR3 translation_key) PURE; + STDMETHOD_(UINT, GetNumCallbackKeys)(THIS) PURE; + STDMETHOD(GetCallbackKeys)(THIS_ LPD3DXKEY_CALLBACK callback_keys) PURE; + STDMETHOD(GetCallbackKey)(THIS_ UINT key, LPD3DXKEY_CALLBACK callback_key) PURE; + STDMETHOD(SetCallbackKey)(THIS_ UINT key, LPD3DXKEY_CALLBACK callback_key) PURE; + STDMETHOD(UnregisterScaleKey)(THIS_ UINT animation, UINT key) PURE; + STDMETHOD(UnregisterRotationKey)(THIS_ UINT animation, UINT key) PURE; + STDMETHOD(UnregisterTranslationKey)(THIS_ UINT animation, UINT key) PURE; + STDMETHOD(RegisterAnimationSRTKeys)(THIS_ const char *name, UINT num_scale_keys, + UINT num_rotation_keys, UINT num_translation_keys, const D3DXKEY_VECTOR3 *scale_keys, + const D3DXKEY_QUATERNION *rotation_keys, const D3DXKEY_VECTOR3 *translation_keys, + DWORD *animation_index) PURE; + STDMETHOD(Compress)(THIS_ DWORD flags, float lossiness, D3DXFRAME *hierarchy, + ID3DXBuffer **compressed_data) PURE; + STDMETHOD(UnregisterAnimation)(THIS_ UINT index) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXCompressedAnimationSet +DECLARE_INTERFACE_(ID3DXCompressedAnimationSet, ID3DXAnimationSet) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXAnimationSet methods ***/ + STDMETHOD_(const char *, GetName)(THIS) PURE; + STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE; + STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE position) PURE; + STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE; + STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, const char **name) PURE; + STDMETHOD(GetAnimationIndexByName)(THIS_ const char *name, UINT *index) PURE; + STDMETHOD(GetSRT)(THIS_ DOUBLE periodic_position, UINT animation, D3DXVECTOR3 *scale, + D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE; + STDMETHOD(GetCallback)(THIS_ double position, DWORD flags, double *callback_position, + void **callback_data) PURE; + /*** ID3DXCompressedAnimationSet methods ***/ + STDMETHOD_(D3DXPLAYBACK_TYPE, GetPlaybackType)(THIS) PURE; + STDMETHOD_(DOUBLE, GetSourceTicksPerSecond)(THIS) PURE; + STDMETHOD(GetCompressedData)(THIS_ ID3DXBuffer **compressed_data) PURE; + STDMETHOD_(UINT, GetNumCallbackKeys)(THIS) PURE; + STDMETHOD(GetCallbackKeys)(THIS_ LPD3DXKEY_CALLBACK callback_keys) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXAnimationCallbackHandler +DECLARE_INTERFACE(ID3DXAnimationCallbackHandler) +{ + STDMETHOD(HandleCallback)(THIS_ UINT track, void *callback_data) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXAnimationController +DECLARE_INTERFACE_(ID3DXAnimationController, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXAnimationController methods ***/ + STDMETHOD_(UINT, GetMaxNumAnimationOutputs)(THIS) PURE; + STDMETHOD_(UINT, GetMaxNumAnimationSets)(THIS) PURE; + STDMETHOD_(UINT, GetMaxNumTracks)(THIS) PURE; + STDMETHOD_(UINT, GetMaxNumEvents)(THIS) PURE; + STDMETHOD(RegisterAnimationOutput)(THIS_ const char *name, D3DXMATRIX *matrix, + D3DXVECTOR3 *scale, D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE; + STDMETHOD(RegisterAnimationSet)(THIS_ ID3DXAnimationSet *anim_set) PURE; + STDMETHOD(UnregisterAnimationSet)(THIS_ ID3DXAnimationSet *anim_set) PURE; + STDMETHOD_(UINT, GetNumAnimationSets)(THIS) PURE; + STDMETHOD(GetAnimationSet)(THIS_ UINT index, ID3DXAnimationSet **anim_set) PURE; + STDMETHOD(GetAnimationSetByName)(THIS_ const char *name, ID3DXAnimationSet **anim_set) PURE; + STDMETHOD(AdvanceTime)(THIS_ double time_delta, ID3DXAnimationCallbackHandler *callback_handler) PURE; + STDMETHOD(ResetTime)(THIS) PURE; + STDMETHOD_(double, GetTime)(THIS) PURE; + STDMETHOD(SetTrackAnimationSet)(THIS_ UINT track, ID3DXAnimationSet *anim_set) PURE; + STDMETHOD(GetTrackAnimationSet)(THIS_ UINT track, ID3DXAnimationSet **anim_set) PURE; + STDMETHOD(SetTrackPriority)(THIS_ UINT track, D3DXPRIORITY_TYPE priority) PURE; + STDMETHOD(SetTrackSpeed)(THIS_ UINT track, float speed) PURE; + STDMETHOD(SetTrackWeight)(THIS_ UINT track, float weight) PURE; + STDMETHOD(SetTrackPosition)(THIS_ UINT track, double position) PURE; + STDMETHOD(SetTrackEnable)(THIS_ UINT track, BOOL enable) PURE; + STDMETHOD(SetTrackDesc)(THIS_ UINT track, D3DXTRACK_DESC *desc) PURE; + STDMETHOD(GetTrackDesc)(THIS_ UINT track, D3DXTRACK_DESC *desc) PURE; + STDMETHOD(SetPriorityBlend)(THIS_ float blend_weight) PURE; + STDMETHOD_(float, GetPriorityBlend)(THIS) PURE; + STDMETHOD_(D3DXEVENTHANDLE, KeyTrackSpeed)(THIS_ UINT track, float new_speed, + double start_time, double duration, D3DXTRANSITION_TYPE transition) PURE; + STDMETHOD_(D3DXEVENTHANDLE, KeyTrackWeight)(THIS_ UINT track, float new_weight, + double start_time, double duration, D3DXTRANSITION_TYPE transition) PURE; + STDMETHOD_(D3DXEVENTHANDLE, KeyTrackPosition)(THIS_ UINT track, double new_position, double start_time) PURE; + STDMETHOD_(D3DXEVENTHANDLE, KeyTrackEnable)(THIS_ UINT track, BOOL new_enable, double start_time) PURE; + STDMETHOD_(D3DXEVENTHANDLE, KeyPriorityBlend)(THIS_ float new_blend_weight, + double start_time, double duration, D3DXTRANSITION_TYPE transition) PURE; + STDMETHOD(UnkeyEvent)(THIS_ D3DXEVENTHANDLE event) PURE; + STDMETHOD(UnkeyAllTrackEvents)(THIS_ UINT track) PURE; + STDMETHOD(UnkeyAllPriorityBlends)(THIS) PURE; + STDMETHOD_(D3DXEVENTHANDLE, GetCurrentTrackEvent)(THIS_ UINT track, D3DXEVENT_TYPE event_type) PURE; + STDMETHOD_(D3DXEVENTHANDLE, GetCurrentPriorityBlend)(THIS) PURE; + STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingTrackEvent)(THIS_ UINT track, D3DXEVENTHANDLE event) PURE; + STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingPriorityBlend)(THIS_ D3DXEVENTHANDLE event) PURE; + STDMETHOD(ValidateEvent)(THIS_ D3DXEVENTHANDLE event) PURE; + STDMETHOD(GetEventDesc)(THIS_ D3DXEVENTHANDLE event, D3DXEVENT_DESC *desc) PURE; + STDMETHOD(CloneAnimationController)(THIS_ UINT max_num_anim_outputs, UINT max_num_anim_sets, + UINT max_num_tracks, UINT max_num_events, ID3DXAnimationController **anim_controller) PURE; +}; +#undef INTERFACE + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DXLoadMeshHierarchyFromXA(const char *filename, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXAllocateHierarchy *alloc, struct ID3DXLoadUserData *user_data_loader, + D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **animation_controller); +HRESULT WINAPI D3DXLoadMeshHierarchyFromXW(const WCHAR *filename, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXAllocateHierarchy *alloc, struct ID3DXLoadUserData *user_data_loader, + D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **animation_controller); +#define D3DXLoadMeshHierarchyFromX WINELIB_NAME_AW(D3DXLoadMeshHierarchyFromX) +HRESULT WINAPI D3DXLoadMeshHierarchyFromXInMemory(const void *data, DWORD data_size, DWORD flags, + struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc, + struct ID3DXLoadUserData *user_data_loader, D3DXFRAME **frame_hierarchy, + struct ID3DXAnimationController **animation_controller); +HRESULT WINAPI D3DXSaveMeshHierarchyToFileA(const char *filename, DWORD format, + const D3DXFRAME *frame_root, ID3DXAnimationController *animation_controller, + ID3DXSaveUserData *user_data_saver); +HRESULT WINAPI D3DXSaveMeshHierarchyToFileW(const WCHAR *filename, DWORD format, + const D3DXFRAME *frame_root, ID3DXAnimationController *animation_controller, + ID3DXSaveUserData *user_data_saver); +#define D3DXSaveMeshHierarchyToFile WINELIB_NAME_AW(D3DXSaveMeshHierarchyToFile) +HRESULT WINAPI D3DXFrameDestroy(D3DXFRAME *frame_root, ID3DXAllocateHierarchy *alloc); +HRESULT WINAPI D3DXFrameAppendChild(D3DXFRAME *parent, const D3DXFRAME *child); +D3DXFRAME * WINAPI D3DXFrameFind(const D3DXFRAME *root, const char *name); +HRESULT WINAPI D3DXFrameRegisterNamedMatrices(D3DXFRAME *frame_root, ID3DXAnimationController *animation_controller); +UINT WINAPI D3DXFrameNumNamedMatrices(const D3DXFRAME *frame_root); +HRESULT WINAPI D3DXFrameCalculateBoundingSphere(const D3DXFRAME *frame_root, D3DXVECTOR3 *center, + FLOAT *radius); +HRESULT WINAPI D3DXCreateKeyframedAnimationSet(const char *name, double ticks_per_second, + D3DXPLAYBACK_TYPE playback_type, UINT animation_count, UINT callback_key_count, + const D3DXKEY_CALLBACK *callback_keys, ID3DXKeyframedAnimationSet **animation_set); +HRESULT WINAPI D3DXCreateCompressedAnimationSet(const char *name, double ticks_per_second, + D3DXPLAYBACK_TYPE playback_type, ID3DXBuffer *compressed_data, UINT callback_key_count, + const D3DXKEY_CALLBACK *callback_keys, ID3DXCompressedAnimationSet **animation_set); +HRESULT WINAPI D3DXCreateAnimationController(UINT max_animation_output_count, UINT max_animation_set_count, + UINT max_track_count, UINT max_event_count, ID3DXAnimationController **animation_controller); + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_D3DX9ANIM_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9core.h b/WineFix/lib/d2d1/include/windows/d3dx9core.h new file mode 100644 index 0000000..e66afc4 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9core.h @@ -0,0 +1,505 @@ +/* + * Copyright (C) 2007, 2008 Tony Wasserka + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __WINE_D3DX9CORE_H +#define __WINE_D3DX9CORE_H + +/********************************************** + ***************** Definitions **************** + **********************************************/ +#define D3DX_VERSION 0x0902 +#ifndef D3DX_SDK_VERSION +#define D3DX_SDK_VERSION 43 +#endif +#define D3DXSPRITE_DONOTSAVESTATE 0x00000001 +#define D3DXSPRITE_DONOTMODIFY_RENDERSTATE 0x00000002 +#define D3DXSPRITE_OBJECTSPACE 0x00000004 +#define D3DXSPRITE_BILLBOARD 0x00000008 +#define D3DXSPRITE_ALPHABLEND 0x00000010 +#define D3DXSPRITE_SORT_TEXTURE 0x00000020 +#define D3DXSPRITE_SORT_DEPTH_FRONTTOBACK 0x00000040 +#define D3DXSPRITE_SORT_DEPTH_BACKTOFRONT 0x00000080 +#define D3DXSPRITE_DO_NOT_ADDREF_TEXTURE 0x00000100 + +/********************************************** + ******************** GUIDs ******************* + **********************************************/ +DEFINE_GUID(IID_ID3DXBuffer, 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0x1, 0x2); +DEFINE_GUID(IID_ID3DXFont, 0xd79dbb70, 0x5f21, 0x4d36, 0xbb, 0xc2, 0xff, 0x52, 0x5c, 0x21, 0x3c, 0xdc); +DEFINE_GUID(IID_ID3DXLine, 0xd379ba7f, 0x9042, 0x4ac4, 0x9f, 0x5e, 0x58, 0x19, 0x2a, 0x4c, 0x6b, 0xd8); +DEFINE_GUID(IID_ID3DXRenderToEnvMap, 0x313f1b4b, 0xc7b0, 0x4fa2, 0x9d, 0x9d, 0x8d, 0x38, 0xb, 0x64, 0x38, 0x5e); +DEFINE_GUID(IID_ID3DXRenderToSurface, 0x6985f346, 0x2c3d, 0x43b3, 0xbe, 0x8b, 0xda, 0xae, 0x8a, 0x3, 0xd8, 0x94); +DEFINE_GUID(IID_ID3DXSprite, 0xba0b762d, 0x7d28, 0x43ec, 0xb9, 0xdc, 0x2f, 0x84, 0x44, 0x3b, 0x6, 0x14); + +/********************************************** + ****************** typedefs ****************** + **********************************************/ +typedef struct ID3DXBuffer *LPD3DXBUFFER; +typedef struct ID3DXFont *LPD3DXFONT; +typedef struct ID3DXLine *LPD3DXLINE; +typedef struct ID3DXRenderToEnvMap *LPD3DXRenderToEnvMap; +typedef struct ID3DXRenderToSurface *LPD3DXRENDERTOSURFACE; +typedef struct ID3DXSprite *LPD3DXSPRITE; + +/********************************************** + *********** interface declarations *********** + **********************************************/ +#define INTERFACE ID3DXBuffer +DECLARE_INTERFACE_(ID3DXBuffer, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBuffer methods ***/ + STDMETHOD_(void *, GetBufferPointer)(THIS) PURE; + STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DXBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXBuffer methods ***/ +#define ID3DXBuffer_GetBufferPointer(p) (p)->lpVtbl->GetBufferPointer(p) +#define ID3DXBuffer_GetBufferSize(p) (p)->lpVtbl->GetBufferSize(p) +#else +/*** IUnknown methods ***/ +#define ID3DXBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXBuffer_AddRef(p) (p)->AddRef() +#define ID3DXBuffer_Release(p) (p)->Release() +/*** ID3DXBuffer methods ***/ +#define ID3DXBuffer_GetBufferPointer(p) (p)->GetBufferPointer() +#define ID3DXBuffer_GetBufferSize(p) (p)->GetBufferSize() +#endif + +typedef struct _D3DXFONT_DESCA +{ + INT Height; + UINT Width; + UINT Weight; + UINT MipLevels; + BOOL Italic; + BYTE CharSet; + BYTE OutputPrecision; + BYTE Quality; + BYTE PitchAndFamily; + CHAR FaceName[LF_FACESIZE]; +} D3DXFONT_DESCA, *LPD3DXFONT_DESCA; + +typedef struct _D3DXFONT_DESCW +{ + INT Height; + UINT Width; + UINT Weight; + UINT MipLevels; + BOOL Italic; + BYTE CharSet; + BYTE OutputPrecision; + BYTE Quality; + BYTE PitchAndFamily; + WCHAR FaceName[LF_FACESIZE]; +} D3DXFONT_DESCW, *LPD3DXFONT_DESCW; + +DECL_WINELIB_TYPE_AW(D3DXFONT_DESC) +DECL_WINELIB_TYPE_AW(LPD3DXFONT_DESC) + +#define INTERFACE ID3DXFont +DECLARE_INTERFACE_(ID3DXFont, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXFont methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(GetDescA)(THIS_ D3DXFONT_DESCA *desc) PURE; + STDMETHOD(GetDescW)(THIS_ D3DXFONT_DESCW *desc) PURE; + STDMETHOD_(BOOL, GetTextMetricsA)(THIS_ TEXTMETRICA *metrics) PURE; + STDMETHOD_(BOOL, GetTextMetricsW)(THIS_ TEXTMETRICW *metrics) PURE; + + STDMETHOD_(HDC, GetDC)(THIS) PURE; + STDMETHOD(GetGlyphData)(THIS_ UINT glyph, struct IDirect3DTexture9 **texture, + RECT *blackbox, POINT *cellinc) PURE; + + STDMETHOD(PreloadCharacters)(THIS_ UINT first, UINT last) PURE; + STDMETHOD(PreloadGlyphs)(THIS_ UINT first, UINT last) PURE; + STDMETHOD(PreloadTextA)(THIS_ const char *string, INT count) PURE; + STDMETHOD(PreloadTextW)(THIS_ const WCHAR *string, INT count) PURE; + + STDMETHOD_(INT, DrawTextA)(THIS_ struct ID3DXSprite *sprite, const char *string, + INT count, RECT *rect, DWORD format, D3DCOLOR color) PURE; + STDMETHOD_(INT, DrawTextW)(THIS_ struct ID3DXSprite *sprite, const WCHAR *string, + INT count, RECT *rect, DWORD format, D3DCOLOR color) PURE; + + STDMETHOD(OnLostDevice)(THIS) PURE; + STDMETHOD(OnResetDevice)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) + +/*** IUnknown methods ***/ +#define ID3DXFont_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXFont_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXFont_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXFont methods ***/ +#define ID3DXFont_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define ID3DXFont_GetDescA(p,a) (p)->lpVtbl->GetDescA(p,a) +#define ID3DXFont_GetDescW(p,a) (p)->lpVtbl->GetDescW(p,a) +#define ID3DXFont_GetTextMetricsA(p,a) (p)->lpVtbl->GetTextMetricsA(p,a) +#define ID3DXFont_GetTextMetricsW(p,a) (p)->lpVtbl->GetTextMetricsW(p,a) +#define ID3DXFont_GetDC(p) (p)->lpVtbl->GetDC(p) +#define ID3DXFont_GetGlyphData(p,a,b,c,d) (p)->lpVtbl->GetGlyphData(p,a,b,c,d) +#define ID3DXFont_PreloadCharacters(p,a,b) (p)->lpVtbl->PreloadCharacters(p,a,b) +#define ID3DXFont_PreloadGlyphs(p,a,b) (p)->lpVtbl->PreloadGlyphs(p,a,b) +#define ID3DXFont_PreloadTextA(p,a,b) (p)->lpVtbl->PreloadTextA(p,a,b) +#define ID3DXFont_PreloadTextW(p,a,b) (p)->lpVtbl->PreloadTextW(p,a,b) +#define ID3DXFont_DrawTextA(p,a,b,c,d,e,f) (p)->lpVtbl->DrawTextA(p,a,b,c,d,e,f) +#define ID3DXFont_DrawTextW(p,a,b,c,d,e,f) (p)->lpVtbl->DrawTextW(p,a,b,c,d,e,f) +#define ID3DXFont_OnLostDevice(p) (p)->lpVtbl->OnLostDevice(p) +#define ID3DXFont_OnResetDevice(p) (p)->lpVtbl->OnResetDevice(p) +#else +/*** IUnknown methods ***/ +#define ID3DXFont_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXFont_AddRef(p) (p)->AddRef() +#define ID3DXFont_Release(p) (p)->Release() +/*** ID3DXFont methods ***/ +#define ID3DXFont_GetDevice(p,a) (p)->GetDevice(a) +#define ID3DXFont_GetDescA(p,a) (p)->GetDescA(a) +#define ID3DXFont_GetDescW(p,a) (p)->GetDescW(a) +#define ID3DXFont_GetTextMetricsA(p,a) (p)->GetTextMetricsA(a) +#define ID3DXFont_GetTextMetricsW(p,a) (p)->GetTextMetricsW(a) +#define ID3DXFont_GetDC(p) (p)->GetDC() +#define ID3DXFont_GetGlyphData(p,a,b,c,d) (p)->GetGlyphData(a,b,c,d) +#define ID3DXFont_PreloadCharacters(p,a,b) (p)->PreloadCharacters(a,b) +#define ID3DXFont_PreloadGlyphs(p,a,b) (p)->PreloadGlyphs(a,b) +#define ID3DXFont_PreloadTextA(p,a,b) (p)->PreloadTextA(a,b) +#define ID3DXFont_PreloadTextW(p,a,b) (p)->PreloadTextW(a,b) +#define ID3DXFont_DrawTextA(p,a,b,c,d,e,f) (p)->DrawTextA(a,b,c,d,e,f) +#define ID3DXFont_DrawTextW(p,a,b,c,d,e,f) (p)->DrawTextW(a,b,c,d,e,f) +#define ID3DXFont_OnLostDevice(p) (p)->OnLostDevice() +#define ID3DXFont_OnResetDevice(p) (p)->OnResetDevice() +#endif +#define ID3DXFont_DrawText WINELIB_NAME_AW(ID3DXFont_DrawText) +#define ID3DXFont_GetDesc WINELIB_NAME_AW(ID3DXFont_GetDesc) +#define ID3DXFont_GetTextMetrics WINELIB_NAME_AW(ID3DXFont_GetTextMetrics) +#define ID3DXFont_PreloadText WINELIB_NAME_AW(ID3DXFont_PreloadText) + +#define INTERFACE ID3DXLine +DECLARE_INTERFACE_(ID3DXLine, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /*** ID3DXLine methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + + STDMETHOD(Begin)(THIS) PURE; + STDMETHOD(Draw)(THIS_ const D3DXVECTOR2 *vertexlist, DWORD vertexlistcount, D3DCOLOR color) PURE; + STDMETHOD(DrawTransform)(THIS_ const D3DXVECTOR3 *vertexlist, DWORD vertexlistcount, + const D3DXMATRIX *transform, D3DCOLOR color) PURE; + STDMETHOD(SetPattern)(THIS_ DWORD pattern) PURE; + STDMETHOD_(DWORD, GetPattern)(THIS) PURE; + STDMETHOD(SetPatternScale)(THIS_ FLOAT scale) PURE; + STDMETHOD_(FLOAT, GetPatternScale)(THIS) PURE; + STDMETHOD(SetWidth)(THIS_ FLOAT width) PURE; + STDMETHOD_(FLOAT, GetWidth)(THIS) PURE; + STDMETHOD(SetAntialias)(THIS_ BOOL antialias) PURE; + STDMETHOD_(BOOL, GetAntialias)(THIS) PURE; + STDMETHOD(SetGLLines)(THIS_ BOOL gl_lines) PURE; + STDMETHOD_(BOOL, GetGLLines)(THIS) PURE; + STDMETHOD(End)(THIS) PURE; + + STDMETHOD(OnLostDevice)(THIS) PURE; + STDMETHOD(OnResetDevice)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DXLine_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXLine_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXLine_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXLine methods ***/ +#define ID3DXLine_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define ID3DXLine_Begin(p) (p)->lpVtbl->Begin(p) +#define ID3DXLine_Draw(p,a,b,c) (p)->lpVtbl->Draw(p,a,b,c) +#define ID3DXLine_DrawTransform(p,a,b,c,d) (p)->lpVtbl->DrawTransform(p,a,b,c,d) +#define ID3DXLine_SetPattern(p,a) (p)->lpVtbl->SetPattern(p,a) +#define ID3DXLine_GetPattern(p) (p)->lpVtbl->GetPattern(p) +#define ID3DXLine_SetPatternScale(p,a) (p)->lpVtbl->SetPatternScale(p,a) +#define ID3DXLine_GetPatternScale(p) (p)->lpVtbl->GetPatternScale(p) +#define ID3DXLine_SetWidth(p,a) (p)->lpVtbl->SetWidth(p,a) +#define ID3DXLine_GetWidth(p) (p)->lpVtbl->GetWidth(p) +#define ID3DXLine_SetAntialias(p,a) (p)->lpVtbl->SetAntialias(p,a) +#define ID3DXLine_GetAntialias(p) (p)->lpVtbl->GetAntialias(p) +#define ID3DXLine_SetGLLines(p,a) (p)->lpVtbl->SetGLLines(p,a) +#define ID3DXLine_GetGLLines(p) (p)->lpVtbl->GetGLLines(p) +#define ID3DXLine_End(p) (p)->lpVtbl->End(p) +#define ID3DXLine_OnLostDevice(p) (p)->lpVtbl->OnLostDevice(p) +#define ID3DXLine_OnResetDevice(p) (p)->lpVtbl->OnResetDevice(p) +#else +/*** IUnknown methods ***/ +#define ID3DXLine_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXLine_AddRef(p) (p)->AddRef() +#define ID3DXLine_Release(p) (p)->Release() +/*** ID3DXLine methods ***/ +#define ID3DXLine_GetDevice(p,a) (p)->GetDevice(a) +#define ID3DXLine_Begin(p) (p)->Begin() +#define ID3DXLine_Draw(p,a,b,c) (p)->Draw(a,b,c) +#define ID3DXLine_DrawTransform(p,a,b,c,d) (p)->DrawTransform(a,b,c,d) +#define ID3DXLine_SetPattern(p,a) (p)->SetPattern(a) +#define ID3DXLine_GetPattern(p) (p)->GetPattern() +#define ID3DXLine_SetPatternScale(p,a) (p)->SetPatternScale(a) +#define ID3DXLine_GetPatternScale(p) (p)->GetPatternScale() +#define ID3DXLine_SetWidth(p,a) (p)->SetWidth(a) +#define ID3DXLine_GetWidth(p) (p)->GetWidth() +#define ID3DXLine_SetAntialias(p,a) (p)->SetAntialias(a) +#define ID3DXLine_GetAntialias(p) (p)->GetAntialias() +#define ID3DXLine_SetGLLines(p,a) (p)->SetGLLines(a) +#define ID3DXLine_GetGLLines(p) (p)->GetGLLines() +#define ID3DXLine_End(p) (p)->End() +#define ID3DXLine_OnLostDevice(p) (p)->OnLostDevice() +#define ID3DXLine_OnResetDevice(p) (p)->OnResetDevice() +#endif + +typedef struct _D3DXRTE_DESC +{ + UINT Size; + UINT MipLevels; + D3DFORMAT Format; + BOOL DepthStencil; + D3DFORMAT DepthStencilFormat; +} D3DXRTE_DESC; + +#define INTERFACE ID3DXRenderToEnvMap +DECLARE_INTERFACE_(ID3DXRenderToEnvMap, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /*** ID3DXRenderToEnvMap methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(GetDesc)(THIS_ D3DXRTE_DESC *desc) PURE; + + STDMETHOD(BeginCube)(THIS_ struct IDirect3DCubeTexture9 *cubetex) PURE; + STDMETHOD(BeginSphere)(THIS_ struct IDirect3DTexture9 *tex) PURE; + STDMETHOD(BeginHemisphere)(THIS_ struct IDirect3DTexture9 *texzpos, struct IDirect3DTexture9 *texzneg) PURE; + STDMETHOD(BeginParabolic)(THIS_ struct IDirect3DTexture9 *texzpos, struct IDirect3DTexture9 *texzneg) PURE; + + STDMETHOD(Face)(THIS_ D3DCUBEMAP_FACES face, DWORD mipfilter) PURE; + STDMETHOD(End)(THIS_ DWORD mipfilter) PURE; + + STDMETHOD(OnLostDevice)(THIS) PURE; + STDMETHOD(OnResetDevice)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DXRenderToEnvMap_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXRenderToEnvMap_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXRenderToEnvMap_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXRenderToEnvMap methods ***/ +#define ID3DXRenderToEnvMap_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define ID3DXRenderToEnvMap_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define ID3DXRenderToEnvMap_BeginCube(p,a) (p)->lpVtbl->BeginCube(p,a) +#define ID3DXRenderToEnvMap_BeginSphere(p,a) (p)->lpVtbl->BeginSphere(p,a) +#define ID3DXRenderToEnvMap_BeginHemisphere(p,a,b) (p)->lpVtbl->BeginHemisphere(p,a,b) +#define ID3DXRenderToEnvMap_BeginParabolic(p,a,b) (p)->lpVtbl->BeginParabolic(p,a,b) +#define ID3DXRenderToEnvMap_Face(p,a,b) (p)->lpVtbl->Face(p,a,b) +#define ID3DXRenderToEnvMap_End(p,a) (p)->lpVtbl->End(p,a) +#define ID3DXRenderToEnvMap_OnLostDevice(p) (p)->lpVtbl->OnLostDevice(p) +#define ID3DXRenderToEnvMap_OnLostDevice(p) (p)->lpVtbl->OnLostDevice(p) +#else +/*** IUnknown methods ***/ +#define ID3DXRenderToEnvMap_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXRenderToEnvMap_AddRef(p) (p)->AddRef() +#define ID3DXRenderToEnvMap_Release(p) (p)->Release() +/*** ID3DXRenderToEnvMap methods ***/ +#define ID3DXRenderToEnvMap_GetDevice(p,a) (p)->GetDevice(a) +#define ID3DXRenderToEnvMap_GetDesc(p,a) (p)->GetDesc(a) +#define ID3DXRenderToEnvMap_BeginCube(p,a) (p)->BeginCube(a) +#define ID3DXRenderToEnvMap_BeginSphere(p,a) (p)->BeginSphere(a) +#define ID3DXRenderToEnvMap_BeginHemisphere(p,a,b) (p)->BeginHemisphere(a,b) +#define ID3DXRenderToEnvMap_BeginParabolic(p,a,b) (p)->BeginParabolic(a,b) +#define ID3DXRenderToEnvMap_Face(p,a,b) (p)->Face(a,b) +#define ID3DXRenderToEnvMap_End(p,a) (p)->End(a) +#define ID3DXRenderToEnvMap_OnLostDevice(p) (p)->OnLostDevice() +#define ID3DXRenderToEnvMap_OnLostDevice(p) (p)->OnLostDevice() +#endif + +typedef struct _D3DXRTS_DESC +{ + UINT Width; + UINT Height; + D3DFORMAT Format; + BOOL DepthStencil; + D3DFORMAT DepthStencilFormat; +} D3DXRTS_DESC; + +#define INTERFACE ID3DXRenderToSurface +DECLARE_INTERFACE_(ID3DXRenderToSurface, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXRenderToSurface methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(GetDesc)(THIS_ D3DXRTS_DESC *desc) PURE; + + STDMETHOD(BeginScene)(THIS_ struct IDirect3DSurface9 *surface, const D3DVIEWPORT9 *viewport) PURE; + STDMETHOD(EndScene)(THIS_ DWORD mipfilter) PURE; + + STDMETHOD(OnLostDevice)(THIS) PURE; + STDMETHOD(OnResetDevice)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DXRenderToSurface_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXRenderToSurface_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXRenderToSurface_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXRenderToSurface methods ***/ +#define ID3DXRenderToSurface_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define ID3DXRenderToSurface_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define ID3DXRenderToSurface_BeginScene(p,a,b) (p)->lpVtbl->BeginScene(p,a,b) +#define ID3DXRenderToSurface_EndScene(p,a) (p)->lpVtbl->EndScene(p,a) +#define ID3DXRenderToSurface_OnLostDevice(p) (p)->lpVtbl->OnLostDevice(p) +#define ID3DXRenderToSurface_OnResetDevice(p) (p)->lpVtbl->OnResetDevice(p) +#else +/*** IUnknown methods ***/ +#define ID3DXRenderToSurface_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXRenderToSurface_AddRef(p) (p)->AddRef() +#define ID3DXRenderToSurface_Release(p) (p)->Release() +/*** ID3DXRenderToSurface methods ***/ +#define ID3DXRenderToSurface_GetDevice(p,a) (p)->GetDevice(a) +#define ID3DXRenderToSurface_GetDesc(p,a) (p)->GetDesc(a) +#define ID3DXRenderToSurface_BeginScene(p,a,b) (p)->BeginScene(a,b) +#define ID3DXRenderToSurface_EndScene(p,a) (p)->EndScene(a) +#define ID3DXRenderToSurface_OnLostDevice(p) (p)->OnLostDevice() +#define ID3DXRenderToSurface_OnResetDevice(p) (p)->OnResetDevice() +#endif + +#define INTERFACE ID3DXSprite +DECLARE_INTERFACE_(ID3DXSprite, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **object) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXSprite methods ***/ + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + + STDMETHOD(GetTransform)(THIS_ D3DXMATRIX *transform) PURE; + STDMETHOD(SetTransform)(THIS_ const D3DXMATRIX *transform) PURE; + STDMETHOD(SetWorldViewRH)(THIS_ const D3DXMATRIX *world, const D3DXMATRIX *view) PURE; + STDMETHOD(SetWorldViewLH)(THIS_ const D3DXMATRIX *world, const D3DXMATRIX *view) PURE; + + STDMETHOD(Begin)(THIS_ DWORD flags) PURE; + STDMETHOD(Draw)(THIS_ struct IDirect3DTexture9 *texture, const RECT *rect, + const D3DXVECTOR3 *center, const D3DXVECTOR3 *position, D3DCOLOR color) PURE; + STDMETHOD(Flush)(THIS) PURE; + STDMETHOD(End)(THIS) PURE; + + STDMETHOD(OnLostDevice)(THIS) PURE; + STDMETHOD(OnResetDevice)(THIS) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DXSprite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXSprite_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXSprite_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXSprite methods ***/ +#define ID3DXSprite_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define ID3DXSprite_GetTransform(p,a) (p)->lpVtbl->GetTransform(p,a) +#define ID3DXSprite_SetTransform(p,a) (p)->lpVtbl->SetTransform(p,a) +#define ID3DXSprite_SetWorldViewRH(p,a,b) (p)->lpVtbl->SetWorldViewRH(p,a,b) +#define ID3DXSprite_SetWorldViewLH(p,a,b) (p)->lpVtbl->SetWorldViewLH(p,a,b) +#define ID3DXSprite_Begin(p,a) (p)->lpVtbl->Begin(p,a) +#define ID3DXSprite_Draw(p,a,b,c,d,e) (p)->lpVtbl->Draw(p,a,b,c,d,e) +#define ID3DXSprite_Flush(p) (p)->lpVtbl->Flush(p) +#define ID3DXSprite_End(p) (p)->lpVtbl->End(p) +#define ID3DXSprite_OnLostDevice(p) (p)->lpVtbl->OnLostDevice(p) +#define ID3DXSprite_OnResetDevice(p) (p)->lpVtbl->OnResetDevice(p) +#else +/*** IUnknown methods ***/ +#define ID3DXSprite_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXSprite_AddRef(p) (p)->AddRef() +#define ID3DXSprite_Release(p) (p)->Release() +/*** ID3DXSprite methods ***/ +#define ID3DXSprite_GetDevice(p,a) (p)->GetDevice(a) +#define ID3DXSprite_GetTransform(p,a) (p)->GetTransform(a) +#define ID3DXSprite_SetTransform(p,a) (p)->SetTransform(a) +#define ID3DXSprite_SetWorldViewRH(p,a,b) (p)->SetWorldViewRH(a,b) +#define ID3DXSprite_SetWorldViewLH(p,a,b) (p)->SetWorldViewLH(a,b) +#define ID3DXSprite_Begin(p,a) (p)->Begin(a) +#define ID3DXSprite_Draw(p,a,b,c,d,e) (p)->Draw(a,b,c,d,e) +#define ID3DXSprite_Flush(p) (p)->Flush() +#define ID3DXSprite_End(p) (p)->End() +#define ID3DXSprite_OnLostDevice(p) (p)->OnLostDevice() +#define ID3DXSprite_OnResetDevice(p) (p)->OnResetDevice() +#endif + +/********************************************** + ****************** functions ***************** + **********************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +BOOL WINAPI D3DXCheckVersion(UINT d3dsdkvers, UINT d3dxsdkvers); +HRESULT WINAPI D3DXCreateFontA(struct IDirect3DDevice9 *device, INT height, UINT width, UINT weight, + UINT miplevels, BOOL italic, DWORD charset, DWORD precision, DWORD quality, DWORD pitchandfamily, + const char *facename, struct ID3DXFont **font); +HRESULT WINAPI D3DXCreateFontW(struct IDirect3DDevice9 *device, INT height, UINT width, UINT weight, + UINT miplevels, BOOL italic, DWORD charset, DWORD precision, DWORD quality, DWORD pitchandfamily, + const WCHAR *facename, struct ID3DXFont **font); +#define D3DXCreateFont WINELIB_NAME_AW(D3DXCreateFont) +HRESULT WINAPI D3DXCreateFontIndirectA(struct IDirect3DDevice9 *device, + const D3DXFONT_DESCA *desc, struct ID3DXFont **font); +HRESULT WINAPI D3DXCreateFontIndirectW(struct IDirect3DDevice9 *device, + const D3DXFONT_DESCW *desc, struct ID3DXFont **font); +#define D3DXCreateFontIndirect WINELIB_NAME_AW(D3DXCreateFontIndirect) +HRESULT WINAPI D3DXCreateLine(struct IDirect3DDevice9 *device, struct ID3DXLine **line); +HRESULT WINAPI D3DXCreateRenderToEnvMap(struct IDirect3DDevice9 *device, UINT size, UINT miplevels, + D3DFORMAT format, BOOL stencil, D3DFORMAT stencil_format, struct ID3DXRenderToEnvMap **rtem); +HRESULT WINAPI D3DXCreateRenderToSurface(struct IDirect3DDevice9 *device, UINT width, UINT height, + D3DFORMAT format, BOOL stencil, D3DFORMAT stencil_format, struct ID3DXRenderToSurface **rts); +HRESULT WINAPI D3DXCreateSprite(struct IDirect3DDevice9 *device, struct ID3DXSprite **sprite); +BOOL WINAPI D3DXDebugMute(BOOL mute); +UINT WINAPI D3DXGetDriverLevel(struct IDirect3DDevice9 *device); + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_D3DX9CORE_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9effect.h b/WineFix/lib/d2d1/include/windows/d3dx9effect.h new file mode 100644 index 0000000..5dd1e75 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9effect.h @@ -0,0 +1,445 @@ +/* + * Copyright 2010 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __D3DX9EFFECT_H__ +#define __D3DX9EFFECT_H__ + +#define D3DXFX_DONOTSAVESTATE (1 << 0) +#define D3DXFX_DONOTSAVESHADERSTATE (1 << 1) +#define D3DXFX_DONOTSAVESAMPLERSTATE (1 << 2) +#define D3DXFX_NOT_CLONEABLE (1 << 11) +#define D3DXFX_LARGEADDRESSAWARE (1 << 17) + +#define D3DX_PARAMETER_SHARED 1 +#define D3DX_PARAMETER_LITERAL 2 +#define D3DX_PARAMETER_ANNOTATION 4 + +typedef struct _D3DXEFFECT_DESC +{ + const char *Creator; + UINT Parameters; + UINT Techniques; + UINT Functions; +} D3DXEFFECT_DESC; + +typedef struct _D3DXPARAMETER_DESC +{ + const char *Name; + const char *Semantic; + D3DXPARAMETER_CLASS Class; + D3DXPARAMETER_TYPE Type; + UINT Rows; + UINT Columns; + UINT Elements; + UINT Annotations; + UINT StructMembers; + DWORD Flags; + UINT Bytes; +} D3DXPARAMETER_DESC; + +typedef struct _D3DXTECHNIQUE_DESC +{ + const char *Name; + UINT Passes; + UINT Annotations; +} D3DXTECHNIQUE_DESC; + +typedef struct _D3DXPASS_DESC +{ + const char *Name; + UINT Annotations; + const DWORD *pVertexShaderFunction; + const DWORD *pPixelShaderFunction; +} D3DXPASS_DESC; + +typedef struct _D3DXFUNCTION_DESC +{ + const char *Name; + UINT Annotations; +} D3DXFUNCTION_DESC; + +typedef struct ID3DXEffectPool *LPD3DXEFFECTPOOL; + +DEFINE_GUID(IID_ID3DXEffectPool, 0x9537ab04, 0x3250, 0x412e, 0x82, 0x13, 0xfc, 0xd2, 0xf8, 0x67, 0x79, 0x33); + +#undef INTERFACE +#define INTERFACE ID3DXEffectPool + +DECLARE_INTERFACE_(ID3DXEffectPool, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; +}; +#undef INTERFACE + +typedef struct ID3DXBaseEffect *LPD3DXBASEEFFECT; + +DEFINE_GUID(IID_ID3DXBaseEffect, 0x17c18ac, 0x103f, 0x4417, 0x8c, 0x51, 0x6b, 0xf6, 0xef, 0x1e, 0x56, 0xbe); + +#define INTERFACE ID3DXBaseEffect + +DECLARE_INTERFACE_(ID3DXBaseEffect, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBaseEffect methods ***/ + STDMETHOD(GetDesc)(THIS_ D3DXEFFECT_DESC* desc) PURE; + STDMETHOD(GetParameterDesc)(THIS_ D3DXHANDLE parameter, D3DXPARAMETER_DESC* desc) PURE; + STDMETHOD(GetTechniqueDesc)(THIS_ D3DXHANDLE technique, D3DXTECHNIQUE_DESC* desc) PURE; + STDMETHOD(GetPassDesc)(THIS_ D3DXHANDLE pass, D3DXPASS_DESC* desc) PURE; + STDMETHOD(GetFunctionDesc)(THIS_ D3DXHANDLE shader, D3DXFUNCTION_DESC* desc) PURE; + STDMETHOD_(D3DXHANDLE, GetParameter)(THIS_ D3DXHANDLE parameter, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, const char *semantic) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterElement)(THIS_ D3DXHANDLE parameter, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetTechnique)(THIS_ UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetPass)(THIS_ D3DXHANDLE technique, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetFunction)(THIS_ UINT index); + STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ const char *name); + STDMETHOD_(D3DXHANDLE, GetAnnotation)(THIS_ D3DXHANDLE object, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, const char *name) PURE; + STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT bytes) PURE; + STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, void *data, UINT bytes) PURE; + STDMETHOD(SetBool)(THIS_ D3DXHANDLE parameter, BOOL b) PURE; + STDMETHOD(GetBool)(THIS_ D3DXHANDLE parameter, BOOL* b) PURE; + STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, const BOOL *b, UINT count) PURE; + STDMETHOD(GetBoolArray)(THIS_ D3DXHANDLE parameter, BOOL* b, UINT count) PURE; + STDMETHOD(SetInt)(THIS_ D3DXHANDLE parameter, INT n) PURE; + STDMETHOD(GetInt)(THIS_ D3DXHANDLE parameter, INT* n) PURE; + STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, const INT *n, UINT count) PURE; + STDMETHOD(GetIntArray)(THIS_ D3DXHANDLE parameter, INT* n, UINT count) PURE; + STDMETHOD(SetFloat)(THIS_ D3DXHANDLE parameter, FLOAT f) PURE; + STDMETHOD(GetFloat)(THIS_ D3DXHANDLE parameter, FLOAT* f) PURE; + STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, const FLOAT *f, UINT count) PURE; + STDMETHOD(GetFloatArray)(THIS_ D3DXHANDLE parameter, FLOAT* f, UINT count) PURE; + STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector) PURE; + STDMETHOD(GetVector)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector) PURE; + STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count) PURE; + STDMETHOD(GetVectorArray)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count) PURE; + STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE; + STDMETHOD(GetMatrix)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE; + STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE; + STDMETHOD(GetMatrixArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE; + STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE; + STDMETHOD(GetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE; + STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE; + STDMETHOD(GetMatrixTranspose)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE; + STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE; + STDMETHOD(GetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE; + STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE; + STDMETHOD(GetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE; + STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, const char *string) PURE; + STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, const char **string) PURE; + STDMETHOD(SetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture) PURE; + STDMETHOD(GetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture) PURE; + STDMETHOD(GetPixelShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader) PURE; + STDMETHOD(GetVertexShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DVertexShader9 **shader) PURE; + STDMETHOD(SetArrayRange)(THIS_ D3DXHANDLE parameter, UINT start, UINT end) PURE; +}; +#undef INTERFACE + +typedef struct ID3DXEffectStateManager *LPD3DXEFFECTSTATEMANAGER; + +DEFINE_GUID(IID_ID3DXEffectStateManager, 0x79aab587, 0x6dbc, 0x4fa7, 0x82, 0xde, 0x37, 0xfa, 0x17, 0x81, 0xc5, 0xce); + +#define INTERFACE ID3DXEffectStateManager + +DECLARE_INTERFACE_(ID3DXEffectStateManager, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXEffectStateManager methods ***/ + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE; + STDMETHOD(SetMaterial)(THIS_ const D3DMATERIAL9 *material) PURE; + STDMETHOD(SetLight)(THIS_ DWORD index, const D3DLIGHT9 *light) PURE; + STDMETHOD(LightEnable)(THIS_ DWORD index, BOOL enable) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE state, DWORD value) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD stage, struct IDirect3DBaseTexture9 *texture) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value) PURE; + STDMETHOD(SetSamplerState)(THIS_ DWORD sampler, D3DSAMPLERSTATETYPE type, DWORD value) PURE; + STDMETHOD(SetNPatchMode)(THIS_ FLOAT num_segments) PURE; + STDMETHOD(SetFVF)(THIS_ DWORD format) PURE; + STDMETHOD(SetVertexShader)(THIS_ struct IDirect3DVertexShader9 *shader) PURE; + STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT register_index, const FLOAT *constant_data, UINT register_count) PURE; + STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT register_index, const INT *constant_data, UINT register_count) PURE; + STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT register_index, const BOOL *constant_data, UINT register_count) PURE; + STDMETHOD(SetPixelShader)(THIS_ struct IDirect3DPixelShader9 *shader) PURE; + STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT register_index, const FLOAT *constant_data, UINT register_count) PURE; + STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT register_index, const INT *constant_data, UINT register_count) PURE; + STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT register_index, const BOOL *constant_data, UINT register_count) PURE; +}; +#undef INTERFACE + +typedef struct ID3DXEffect *LPD3DXEFFECT; + +#if D3DX_SDK_VERSION <= 25 +DEFINE_GUID(IID_ID3DXEffect, 0xd165ccb1, 0x62b0, 0x4a33, 0xb3, 0xfa, 0xa9, 0x23, 0x00, 0x30, 0x5a, 0x11); +#elif D3DX_SDK_VERSION == 26 +DEFINE_GUID(IID_ID3DXEffect, 0xc7b17651, 0x5420, 0x490e, 0x8a, 0x7f, 0x92, 0x36, 0x75, 0xa2, 0xd6, 0x87); +#else +DEFINE_GUID(IID_ID3DXEffect, 0xf6ceb4b3, 0x4e4c, 0x40dd, 0xb8, 0x83, 0x8d, 0x8d, 0xe5, 0xea, 0x0c, 0xd5); +#endif + +#define INTERFACE ID3DXEffect + +DECLARE_INTERFACE_(ID3DXEffect, ID3DXBaseEffect) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBaseEffect methods ***/ + STDMETHOD(GetDesc)(THIS_ D3DXEFFECT_DESC* desc) PURE; + STDMETHOD(GetParameterDesc)(THIS_ D3DXHANDLE parameter, D3DXPARAMETER_DESC* desc) PURE; + STDMETHOD(GetTechniqueDesc)(THIS_ D3DXHANDLE technique, D3DXTECHNIQUE_DESC* desc) PURE; + STDMETHOD(GetPassDesc)(THIS_ D3DXHANDLE pass, D3DXPASS_DESC* desc) PURE; + STDMETHOD(GetFunctionDesc)(THIS_ D3DXHANDLE shader, D3DXFUNCTION_DESC* desc) PURE; + STDMETHOD_(D3DXHANDLE, GetParameter)(THIS_ D3DXHANDLE parameter, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, const char *semantic) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterElement)(THIS_ D3DXHANDLE parameter, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetTechnique)(THIS_ UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetPass)(THIS_ D3DXHANDLE technique, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetFunction)(THIS_ UINT index); + STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ const char *name); + STDMETHOD_(D3DXHANDLE, GetAnnotation)(THIS_ D3DXHANDLE object, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, const char *name) PURE; + STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT bytes) PURE; + STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, void *data, UINT bytes) PURE; + STDMETHOD(SetBool)(THIS_ D3DXHANDLE parameter, BOOL b) PURE; + STDMETHOD(GetBool)(THIS_ D3DXHANDLE parameter, BOOL* b) PURE; + STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, const BOOL *b, UINT count) PURE; + STDMETHOD(GetBoolArray)(THIS_ D3DXHANDLE parameter, BOOL* b, UINT count) PURE; + STDMETHOD(SetInt)(THIS_ D3DXHANDLE parameter, INT n) PURE; + STDMETHOD(GetInt)(THIS_ D3DXHANDLE parameter, INT* n) PURE; + STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, const INT *n, UINT count) PURE; + STDMETHOD(GetIntArray)(THIS_ D3DXHANDLE parameter, INT* n, UINT count) PURE; + STDMETHOD(SetFloat)(THIS_ D3DXHANDLE parameter, FLOAT f) PURE; + STDMETHOD(GetFloat)(THIS_ D3DXHANDLE parameter, FLOAT* f) PURE; + STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, const FLOAT *f, UINT count) PURE; + STDMETHOD(GetFloatArray)(THIS_ D3DXHANDLE parameter, FLOAT* f, UINT count) PURE; + STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector) PURE; + STDMETHOD(GetVector)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector) PURE; + STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count) PURE; + STDMETHOD(GetVectorArray)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count) PURE; + STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE; + STDMETHOD(GetMatrix)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE; + STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE; + STDMETHOD(GetMatrixArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE; + STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE; + STDMETHOD(GetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE; + STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE; + STDMETHOD(GetMatrixTranspose)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE; + STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE; + STDMETHOD(GetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE; + STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE; + STDMETHOD(GetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE; + STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, const char *string) PURE; + STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, const char **string) PURE; + STDMETHOD(SetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture) PURE; + STDMETHOD(GetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture) PURE; + STDMETHOD(GetPixelShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader) PURE; + STDMETHOD(GetVertexShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DVertexShader9 **shader) PURE; + STDMETHOD(SetArrayRange)(THIS_ D3DXHANDLE parameter, UINT start, UINT end) PURE; + /*** ID3DXEffect methods ***/ + STDMETHOD(GetPool)(THIS_ ID3DXEffectPool **pool) PURE; + STDMETHOD(SetTechnique)(THIS_ D3DXHANDLE technique) PURE; + STDMETHOD_(D3DXHANDLE, GetCurrentTechnique)(THIS) PURE; + STDMETHOD(ValidateTechnique)(THIS_ D3DXHANDLE technique) PURE; + STDMETHOD(FindNextValidTechnique)(THIS_ D3DXHANDLE technique, D3DXHANDLE* next_technique) PURE; + STDMETHOD_(BOOL, IsParameterUsed)(THIS_ D3DXHANDLE parameter, D3DXHANDLE technique) PURE; + STDMETHOD(Begin)(THIS_ UINT *passes, DWORD flags) PURE; + STDMETHOD(BeginPass)(THIS_ UINT pass) PURE; + STDMETHOD(CommitChanges)(THIS) PURE; + STDMETHOD(EndPass)(THIS) PURE; + STDMETHOD(End)(THIS) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(OnLostDevice)(THIS) PURE; + STDMETHOD(OnResetDevice)(THIS) PURE; + STDMETHOD(SetStateManager)(THIS_ ID3DXEffectStateManager *manager) PURE; + STDMETHOD(GetStateManager)(THIS_ ID3DXEffectStateManager **manager) PURE; + STDMETHOD(BeginParameterBlock)(THIS) PURE; + STDMETHOD_(D3DXHANDLE, EndParameterBlock)(THIS) PURE; + STDMETHOD(ApplyParameterBlock)(THIS_ D3DXHANDLE parameter_block) PURE; +#if D3DX_SDK_VERSION >= 26 + STDMETHOD(DeleteParameterBlock)(THIS_ D3DXHANDLE parameter_block) PURE; +#endif + STDMETHOD(CloneEffect)(THIS_ struct IDirect3DDevice9 *device, struct ID3DXEffect **effect) PURE; +#if D3DX_SDK_VERSION >= 27 + STDMETHOD(SetRawValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT byte_offset, UINT bytes) PURE; +#endif +}; + +#undef INTERFACE + +typedef struct ID3DXEffectCompiler *LPD3DXEFFECTCOMPILER; + +DEFINE_GUID(IID_ID3DXEffectCompiler, 0x51b8a949, 0x1a31, 0x47e6, 0xbe, 0xa0, 0x4b, 0x30, 0xdb, 0x53, 0xf1, 0xe0); + +#define INTERFACE ID3DXEffectCompiler + +DECLARE_INTERFACE_(ID3DXEffectCompiler, ID3DXBaseEffect) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBaseEffect methods ***/ + STDMETHOD(GetDesc)(THIS_ D3DXEFFECT_DESC* desc) PURE; + STDMETHOD(GetParameterDesc)(THIS_ D3DXHANDLE parameter, D3DXPARAMETER_DESC* desc) PURE; + STDMETHOD(GetTechniqueDesc)(THIS_ D3DXHANDLE technique, D3DXTECHNIQUE_DESC* desc) PURE; + STDMETHOD(GetPassDesc)(THIS_ D3DXHANDLE pass, D3DXPASS_DESC* desc) PURE; + STDMETHOD(GetFunctionDesc)(THIS_ D3DXHANDLE shader, D3DXFUNCTION_DESC* desc) PURE; + STDMETHOD_(D3DXHANDLE, GetParameter)(THIS_ D3DXHANDLE parameter, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, const char *semantic) PURE; + STDMETHOD_(D3DXHANDLE, GetParameterElement)(THIS_ D3DXHANDLE parameter, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetTechnique)(THIS_ UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetPass)(THIS_ D3DXHANDLE technique, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetFunction)(THIS_ UINT index); + STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ const char *name); + STDMETHOD_(D3DXHANDLE, GetAnnotation)(THIS_ D3DXHANDLE object, UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, const char *name) PURE; + STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT bytes) PURE; + STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, void *data, UINT bytes) PURE; + STDMETHOD(SetBool)(THIS_ D3DXHANDLE parameter, BOOL b) PURE; + STDMETHOD(GetBool)(THIS_ D3DXHANDLE parameter, BOOL* b) PURE; + STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, const BOOL *b, UINT count) PURE; + STDMETHOD(GetBoolArray)(THIS_ D3DXHANDLE parameter, BOOL* b, UINT count) PURE; + STDMETHOD(SetInt)(THIS_ D3DXHANDLE parameter, INT n) PURE; + STDMETHOD(GetInt)(THIS_ D3DXHANDLE parameter, INT* n) PURE; + STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, const INT *n, UINT count) PURE; + STDMETHOD(GetIntArray)(THIS_ D3DXHANDLE parameter, INT* n, UINT count) PURE; + STDMETHOD(SetFloat)(THIS_ D3DXHANDLE parameter, FLOAT f) PURE; + STDMETHOD(GetFloat)(THIS_ D3DXHANDLE parameter, FLOAT* f) PURE; + STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, const FLOAT *f, UINT count) PURE; + STDMETHOD(GetFloatArray)(THIS_ D3DXHANDLE parameter, FLOAT* f, UINT count) PURE; + STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector) PURE; + STDMETHOD(GetVector)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector) PURE; + STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count) PURE; + STDMETHOD(GetVectorArray)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count) PURE; + STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE; + STDMETHOD(GetMatrix)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE; + STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE; + STDMETHOD(GetMatrixArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE; + STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE; + STDMETHOD(GetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE; + STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE; + STDMETHOD(GetMatrixTranspose)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE; + STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE; + STDMETHOD(GetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE; + STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE; + STDMETHOD(GetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE; + STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, const char *string) PURE; + STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, const char **string) PURE; + STDMETHOD(SetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture) PURE; + STDMETHOD(GetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture) PURE; + STDMETHOD(GetPixelShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader) PURE; + STDMETHOD(GetVertexShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DVertexShader9 **shader) PURE; + STDMETHOD(SetArrayRange)(THIS_ D3DXHANDLE parameter, UINT start, UINT end) PURE; + /*** ID3DXEffectCompiler methods ***/ + STDMETHOD(SetLiteral)(THIS_ D3DXHANDLE parameter, BOOL literal) PURE; + STDMETHOD(GetLiteral)(THIS_ D3DXHANDLE parameter, BOOL* literal) PURE; + STDMETHOD(CompileEffect)(THIS_ DWORD flags, ID3DXBuffer **effect, ID3DXBuffer **error_msgs) PURE; + STDMETHOD(CompileShader)(THIS_ D3DXHANDLE function, const char *target, DWORD flags, + ID3DXBuffer **shader, ID3DXBuffer **error_msgs, ID3DXConstantTable **constant_table) PURE; +}; +#undef INTERFACE + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DXCreateEffectPool(ID3DXEffectPool **pool); +HRESULT WINAPI D3DXCreateEffect(struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatalen, + const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +HRESULT WINAPI D3DXCreateEffectEx(struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatalen, + const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skip_constants, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +HRESULT WINAPI D3DXCreateEffectCompiler(const char *srcdata, UINT srcdatalen, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **parse_errors); +HRESULT WINAPI D3DXCreateEffectFromFileExA(struct IDirect3DDevice9 *device, const char *srcfile, + const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skip_constants, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +HRESULT WINAPI D3DXCreateEffectFromFileExW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, + const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skip_constants, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +#define D3DXCreateEffectFromFileEx WINELIB_NAME_AW(D3DXCreateEffectFromFileEx) + +HRESULT WINAPI D3DXCreateEffectFromFileA(struct IDirect3DDevice9 *device, const char *srcfile, + const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +HRESULT WINAPI D3DXCreateEffectFromFileW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, + const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +#define D3DXCreateEffectFromFile WINELIB_NAME_AW(D3DXCreateEffectFromFile) + +HRESULT WINAPI D3DXCreateEffectFromResourceExA(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const char *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, + const char *skip_constants, DWORD flags, struct ID3DXEffectPool *pool, + struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +HRESULT WINAPI D3DXCreateEffectFromResourceExW(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const WCHAR *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, + const char *skip_constants, DWORD flags, struct ID3DXEffectPool *pool, + struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +#define D3DXCreateEffectFromResourceEx WINELIB_NAME_AW(D3DXCreateEffectFromResourceEx) + +HRESULT WINAPI D3DXCreateEffectFromResourceA(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const char *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +HRESULT WINAPI D3DXCreateEffectFromResourceW(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const WCHAR *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, + struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors); +#define D3DXCreateEffectFromResource WINELIB_NAME_AW(D3DXCreateEffectFromResource) + +HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(const char *srcfile, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors); +HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(const WCHAR *srcfile, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors); +#define D3DXCreateEffectCompilerFromFile WINELIB_NAME_AW(D3DXCreateEffectCompilerFromFile) + +HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, const char *srcresource, + const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, + ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors); +HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, const WCHAR *srcresource, + const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, + ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors); +#define D3DXCreateEffectCompilerFromResource WINELIB_NAME_AW(D3DXCreateEffectCompilerFromResource) + +HRESULT WINAPI D3DXDisassembleEffect(ID3DXEffect *effect, BOOL enable_color_code, ID3DXBuffer **disassembly); + +#ifdef __cplusplus +} +#endif + +#endif /* __D3DX9EFFECT_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9math.h b/WineFix/lib/d2d1/include/windows/d3dx9math.h new file mode 100644 index 0000000..32d894f --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9math.h @@ -0,0 +1,475 @@ +/* + * Copyright (C) 2007 David Adam + * Copyright (C) 2007 Tony Wasserka + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __D3DX9MATH_H__ +#define __D3DX9MATH_H__ + +#include + +#define D3DX_PI ((FLOAT)3.141592654) +#define D3DX_1BYPI ((FLOAT)0.318309886) + +#define D3DXSH_MINORDER 2 +#define D3DXSH_MAXORDER 6 + +#define D3DXToRadian(degree) ((degree) * (D3DX_PI / 180.0f)) +#define D3DXToDegree(radian) ((radian) * (180.0f / D3DX_PI)) + +typedef struct D3DXVECTOR2 +{ +#ifdef __cplusplus + D3DXVECTOR2(); + D3DXVECTOR2(const FLOAT *pf); + D3DXVECTOR2(FLOAT fx, FLOAT fy); + + operator FLOAT* (); + operator const FLOAT* () const; + + D3DXVECTOR2& operator += (const D3DXVECTOR2&); + D3DXVECTOR2& operator -= (const D3DXVECTOR2&); + D3DXVECTOR2& operator *= (FLOAT); + D3DXVECTOR2& operator /= (FLOAT); + + D3DXVECTOR2 operator + () const; + D3DXVECTOR2 operator - () const; + + D3DXVECTOR2 operator + (const D3DXVECTOR2&) const; + D3DXVECTOR2 operator - (const D3DXVECTOR2&) const; + D3DXVECTOR2 operator * (FLOAT) const; + D3DXVECTOR2 operator / (FLOAT) const; + + friend D3DXVECTOR2 operator * (FLOAT, const D3DXVECTOR2&); + + BOOL operator == (const D3DXVECTOR2&) const; + BOOL operator != (const D3DXVECTOR2&) const; +#endif /* __cplusplus */ + FLOAT x, y; +} D3DXVECTOR2, *LPD3DXVECTOR2; + +#ifdef __cplusplus +typedef struct D3DXVECTOR3 : public D3DVECTOR +{ + D3DXVECTOR3(); + D3DXVECTOR3(const FLOAT *pf); + D3DXVECTOR3(const D3DVECTOR& v); + D3DXVECTOR3(FLOAT fx, FLOAT fy, FLOAT fz); + + operator FLOAT* (); + operator const FLOAT* () const; + + D3DXVECTOR3& operator += (const D3DXVECTOR3&); + D3DXVECTOR3& operator -= (const D3DXVECTOR3&); + D3DXVECTOR3& operator *= (FLOAT); + D3DXVECTOR3& operator /= (FLOAT); + + D3DXVECTOR3 operator + () const; + D3DXVECTOR3 operator - () const; + + D3DXVECTOR3 operator + (const D3DXVECTOR3&) const; + D3DXVECTOR3 operator - (const D3DXVECTOR3&) const; + D3DXVECTOR3 operator * (FLOAT) const; + D3DXVECTOR3 operator / (FLOAT) const; + + friend D3DXVECTOR3 operator * (FLOAT, const struct D3DXVECTOR3&); + + BOOL operator == (const D3DXVECTOR3&) const; + BOOL operator != (const D3DXVECTOR3&) const; +} D3DXVECTOR3, *LPD3DXVECTOR3; +#else /* !__cplusplus */ +typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3; +#endif /* !__cplusplus */ + +typedef struct D3DXVECTOR4 +{ +#ifdef __cplusplus + D3DXVECTOR4(); + D3DXVECTOR4(const FLOAT *pf); + D3DXVECTOR4(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw); + + operator FLOAT* (); + operator const FLOAT* () const; + + D3DXVECTOR4& operator += (const D3DXVECTOR4&); + D3DXVECTOR4& operator -= (const D3DXVECTOR4&); + D3DXVECTOR4& operator *= (FLOAT); + D3DXVECTOR4& operator /= (FLOAT); + + D3DXVECTOR4 operator + () const; + D3DXVECTOR4 operator - () const; + + D3DXVECTOR4 operator + (const D3DXVECTOR4&) const; + D3DXVECTOR4 operator - (const D3DXVECTOR4&) const; + D3DXVECTOR4 operator * (FLOAT) const; + D3DXVECTOR4 operator / (FLOAT) const; + + friend D3DXVECTOR4 operator * (FLOAT, const D3DXVECTOR4&); + + BOOL operator == (const D3DXVECTOR4&) const; + BOOL operator != (const D3DXVECTOR4&) const; +#endif /* __cplusplus */ + FLOAT x, y, z, w; +} D3DXVECTOR4, *LPD3DXVECTOR4; + +#ifdef __cplusplus +typedef struct D3DXMATRIX : public D3DMATRIX +{ + D3DXMATRIX(); + D3DXMATRIX(const FLOAT *pf); + D3DXMATRIX(const D3DMATRIX& mat); + D3DXMATRIX(FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14, + FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24, + FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34, + FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44); + + FLOAT& operator () (UINT row, UINT col); + FLOAT operator () (UINT row, UINT col) const; + + operator FLOAT* (); + operator const FLOAT* () const; + + D3DXMATRIX& operator *= (const D3DXMATRIX&); + D3DXMATRIX& operator += (const D3DXMATRIX&); + D3DXMATRIX& operator -= (const D3DXMATRIX&); + D3DXMATRIX& operator *= (FLOAT); + D3DXMATRIX& operator /= (FLOAT); + + D3DXMATRIX operator + () const; + D3DXMATRIX operator - () const; + + D3DXMATRIX operator * (const D3DXMATRIX&) const; + D3DXMATRIX operator + (const D3DXMATRIX&) const; + D3DXMATRIX operator - (const D3DXMATRIX&) const; + D3DXMATRIX operator * (FLOAT) const; + D3DXMATRIX operator / (FLOAT) const; + + friend D3DXMATRIX operator * (FLOAT, const D3DXMATRIX&); + + BOOL operator == (const D3DXMATRIX&) const; + BOOL operator != (const D3DXMATRIX&) const; +} D3DXMATRIX, *LPD3DXMATRIX; +#else /* !__cplusplus */ +typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX; +#endif /* !__cplusplus */ + +typedef struct D3DXQUATERNION +{ +#ifdef __cplusplus + D3DXQUATERNION(); + D3DXQUATERNION(const FLOAT *pf); + D3DXQUATERNION(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw); + + operator FLOAT* (); + operator const FLOAT* () const; + + D3DXQUATERNION& operator += (const D3DXQUATERNION&); + D3DXQUATERNION& operator -= (const D3DXQUATERNION&); + D3DXQUATERNION& operator *= (const D3DXQUATERNION&); + D3DXQUATERNION& operator *= (FLOAT); + D3DXQUATERNION& operator /= (FLOAT); + + D3DXQUATERNION operator + () const; + D3DXQUATERNION operator - () const; + + D3DXQUATERNION operator + (const D3DXQUATERNION&) const; + D3DXQUATERNION operator - (const D3DXQUATERNION&) const; + D3DXQUATERNION operator * (const D3DXQUATERNION&) const; + D3DXQUATERNION operator * (FLOAT) const; + D3DXQUATERNION operator / (FLOAT) const; + + friend D3DXQUATERNION operator * (FLOAT, const D3DXQUATERNION&); + + BOOL operator == (const D3DXQUATERNION&) const; + BOOL operator != (const D3DXQUATERNION&) const; +#endif /* __cplusplus */ + FLOAT x, y, z, w; +} D3DXQUATERNION, *LPD3DXQUATERNION; + +typedef struct D3DXPLANE +{ +#ifdef __cplusplus + D3DXPLANE(); + D3DXPLANE(const FLOAT *pf); + D3DXPLANE(FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd); + + operator FLOAT* (); + operator const FLOAT* () const; + + D3DXPLANE operator + () const; + D3DXPLANE operator - () const; + + BOOL operator == (const D3DXPLANE&) const; + BOOL operator != (const D3DXPLANE&) const; +#endif /* __cplusplus */ + FLOAT a, b, c, d; +} D3DXPLANE, *LPD3DXPLANE; + +typedef struct D3DXCOLOR +{ +#ifdef __cplusplus + D3DXCOLOR(); + D3DXCOLOR(DWORD col); + D3DXCOLOR(const FLOAT *pf); + D3DXCOLOR(const D3DCOLORVALUE& col); + D3DXCOLOR(FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa); + + operator DWORD () const; + + operator FLOAT* (); + operator const FLOAT* () const; + + operator D3DCOLORVALUE* (); + operator const D3DCOLORVALUE* () const; + + operator D3DCOLORVALUE& (); + operator const D3DCOLORVALUE& () const; + + D3DXCOLOR& operator += (const D3DXCOLOR&); + D3DXCOLOR& operator -= (const D3DXCOLOR&); + D3DXCOLOR& operator *= (FLOAT); + D3DXCOLOR& operator /= (FLOAT); + + D3DXCOLOR operator + () const; + D3DXCOLOR operator - () const; + + D3DXCOLOR operator + (const D3DXCOLOR&) const; + D3DXCOLOR operator - (const D3DXCOLOR&) const; + D3DXCOLOR operator * (FLOAT) const; + D3DXCOLOR operator / (FLOAT) const; + + friend D3DXCOLOR operator * (FLOAT, const D3DXCOLOR&); + + BOOL operator == (const D3DXCOLOR&) const; + BOOL operator != (const D3DXCOLOR&) const; +#endif /* __cplusplus */ + FLOAT r, g, b, a; +} D3DXCOLOR, *LPD3DXCOLOR; + +typedef struct D3DXFLOAT16 +{ +#ifdef __cplusplus + D3DXFLOAT16(); + D3DXFLOAT16(FLOAT f); + D3DXFLOAT16(const D3DXFLOAT16 &f); + + operator FLOAT (); + + BOOL operator == (const D3DXFLOAT16 &) const; + BOOL operator != (const D3DXFLOAT16 &) const; +#endif /* __cplusplus */ + WORD value; +} D3DXFLOAT16, *LPD3DXFLOAT16; + +#ifdef __cplusplus +extern "C" { +#endif + +D3DXCOLOR* WINAPI D3DXColorAdjustContrast(D3DXCOLOR *pout, const D3DXCOLOR *pc, FLOAT s); +D3DXCOLOR* WINAPI D3DXColorAdjustSaturation(D3DXCOLOR *pout, const D3DXCOLOR *pc, FLOAT s); + +FLOAT WINAPI D3DXFresnelTerm(FLOAT costheta, FLOAT refractionindex); + +D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation(D3DXMATRIX *pout, FLOAT scaling, const D3DXVECTOR3 *rotationcenter, const D3DXQUATERNION *rotation, + const D3DXVECTOR3 *translation); +D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation2D(D3DXMATRIX *pout, FLOAT scaling, const D3DXVECTOR2 *protationcenter, FLOAT rotation, + const D3DXVECTOR2 *ptranslation); +HRESULT WINAPI D3DXMatrixDecompose(D3DXVECTOR3 *poutscale, D3DXQUATERNION *poutrotation, D3DXVECTOR3 *pouttranslation, const D3DXMATRIX *pm); +FLOAT WINAPI D3DXMatrixDeterminant(const D3DXMATRIX *pm); +D3DXMATRIX* WINAPI D3DXMatrixInverse(D3DXMATRIX *pout, FLOAT *pdeterminant, const D3DXMATRIX *pm); +D3DXMATRIX* WINAPI D3DXMatrixLookAtLH(D3DXMATRIX *pout, const D3DXVECTOR3 *peye, const D3DXVECTOR3 *pat, const D3DXVECTOR3 *pup); +D3DXMATRIX* WINAPI D3DXMatrixLookAtRH(D3DXMATRIX *pout, const D3DXVECTOR3 *peye, const D3DXVECTOR3 *pat, const D3DXVECTOR3 *pup); +D3DXMATRIX* WINAPI D3DXMatrixMultiply(D3DXMATRIX *pout, const D3DXMATRIX *pm1, const D3DXMATRIX *pm2); +D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose(D3DXMATRIX *pout, const D3DXMATRIX *pm1, const D3DXMATRIX *pm2); +D3DXMATRIX* WINAPI D3DXMatrixOrthoLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixOrthoRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); +D3DXMATRIX* WINAPI D3DXMatrixReflect(D3DXMATRIX *pout, const D3DXPLANE *pplane); +D3DXMATRIX* WINAPI D3DXMatrixRotationAxis(D3DXMATRIX *pout, const D3DXVECTOR3 *pv, FLOAT angle); +D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion(D3DXMATRIX *pout, const D3DXQUATERNION *pq); +D3DXMATRIX* WINAPI D3DXMatrixRotationX(D3DXMATRIX *pout, FLOAT angle); +D3DXMATRIX* WINAPI D3DXMatrixRotationY(D3DXMATRIX *pout, FLOAT angle); +D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll(D3DXMATRIX *pout, FLOAT yaw, FLOAT pitch, FLOAT roll); +D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle); +D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz); +D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, const D3DXVECTOR4 *plight, const D3DXPLANE *pPlane); +D3DXMATRIX* WINAPI D3DXMatrixTransformation(D3DXMATRIX *pout, const D3DXVECTOR3 *pscalingcenter, const D3DXQUATERNION *pscalingrotation, const D3DXVECTOR3 *pscaling, const D3DXVECTOR3 *protationcenter, + const D3DXQUATERNION *protation, const D3DXVECTOR3 *ptranslation); +D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(D3DXMATRIX *pout, const D3DXVECTOR2 *pscalingcenter, FLOAT scalingrotation, const D3DXVECTOR2 *pscaling, + const D3DXVECTOR2 *protationcenter, FLOAT rotation, const D3DXVECTOR2 *ptranslation); +D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z); +D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, const D3DXMATRIX *pm); + +D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, const D3DXVECTOR3 *pvpoint, const D3DXVECTOR3 *pvnormal); +D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pv3); +D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, const D3DXPLANE *pp, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2); +D3DXPLANE* WINAPI D3DXPlaneNormalize(D3DXPLANE *pout, const D3DXPLANE *pp); +D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, const D3DXPLANE *pplane, const D3DXMATRIX *pm); +D3DXPLANE* WINAPI D3DXPlaneTransformArray(D3DXPLANE *pout, UINT outstride, const D3DXPLANE *pplane, UINT pstride, const D3DXMATRIX *pm, UINT n); + +D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, const D3DXQUATERNION *pq3, FLOAT f, FLOAT g); +D3DXQUATERNION* WINAPI D3DXQuaternionExp(D3DXQUATERNION *pout, const D3DXQUATERNION *pq); +D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, const D3DXQUATERNION *pq); +D3DXQUATERNION* WINAPI D3DXQuaternionLn(D3DXQUATERNION *pout, const D3DXQUATERNION *pq); +D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2); +D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, const D3DXQUATERNION *pq); +D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *pout, const D3DXVECTOR3 *pv, FLOAT angle); +D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *pout, const D3DXMATRIX *pm); +D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pout, FLOAT yaw, FLOAT pitch, FLOAT roll); +D3DXQUATERNION* WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, FLOAT t); +D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, const D3DXQUATERNION *pq3, + const D3DXQUATERNION *pq4, FLOAT t); +void WINAPI D3DXQuaternionSquadSetup(D3DXQUATERNION *paout, D3DXQUATERNION *pbout, D3DXQUATERNION *pcout, const D3DXQUATERNION *pq0, + const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, const D3DXQUATERNION *pq3); +void WINAPI D3DXQuaternionToAxisAngle(const D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle); + +D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2, const D3DXVECTOR2 *pv3, FLOAT f, FLOAT g); +D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv0, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2, const D3DXVECTOR2 *pv3, FLOAT s); +D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pt1, const D3DXVECTOR2 *pv2, const D3DXVECTOR2 *pt2, FLOAT s); +D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv); +D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, const D3DXVECTOR2 *pv, const D3DXMATRIX *pm); +D3DXVECTOR4* WINAPI D3DXVec2TransformArray(D3DXVECTOR4 *pout, UINT outstride, const D3DXVECTOR2 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); +D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv, const D3DXMATRIX *pm); +D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(D3DXVECTOR2 *pout, UINT outstride, const D3DXVECTOR2 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); +D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv, const D3DXMATRIX *pm); +D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(D3DXVECTOR2 *pout, UINT outstride, const D3DXVECTOR2 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); + +D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pv3, FLOAT f, FLOAT g); +D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv0, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pv3, FLOAT s); +D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pt1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pt2, FLOAT s); +D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv); +D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3DVIEWPORT9 *pviewport, const D3DXMATRIX *pprojection, + const D3DXMATRIX *pview, const D3DXMATRIX *pworld); +D3DXVECTOR3* WINAPI D3DXVec3ProjectArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DVIEWPORT9 *pviewport, + const D3DXMATRIX *pprojection, const D3DXMATRIX *pview, const D3DXMATRIX *pworld, UINT n); +D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, const D3DXVECTOR3 *pv, const D3DXMATRIX *pm); +D3DXVECTOR4* WINAPI D3DXVec3TransformArray(D3DXVECTOR4 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); +D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3DXMATRIX *pm); +D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); +D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3DXMATRIX *pm); +D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); +D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3DVIEWPORT9 *pviewport, const D3DXMATRIX *pprojection, + const D3DXMATRIX *pview, const D3DXMATRIX *pworld); +D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DVIEWPORT9 *pviewport, + const D3DXMATRIX *pprojection, const D3DXMATRIX *pview, const D3DXMATRIX *pworld, UINT n); +D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pv3, FLOAT f, FLOAT g); +D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv0, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pv3, FLOAT s); +D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pv3); +D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pt1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pt2, FLOAT s); +D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv); +D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv, const D3DXMATRIX *pm); +D3DXVECTOR4* WINAPI D3DXVec4TransformArray(D3DXVECTOR4 *pout, UINT outstride, const D3DXVECTOR4 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n); + +D3DXFLOAT16 *WINAPI D3DXFloat32To16Array(D3DXFLOAT16 *pout, const FLOAT *pin, UINT n); +FLOAT *WINAPI D3DXFloat16To32Array(FLOAT *pout, const D3DXFLOAT16 *pin, UINT n); + +FLOAT* WINAPI D3DXSHAdd(FLOAT *out, UINT order, const FLOAT *a, const FLOAT *b); +FLOAT WINAPI D3DXSHDot(UINT order, const FLOAT *a, const FLOAT *b); +HRESULT WINAPI D3DXSHEvalConeLight(UINT order, const D3DXVECTOR3 *dir, FLOAT radius, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *rout, FLOAT *gout, FLOAT *bout); +FLOAT* WINAPI D3DXSHEvalDirection(FLOAT *out, UINT order, const D3DXVECTOR3 *dir); +HRESULT WINAPI D3DXSHEvalDirectionalLight(UINT order, const D3DXVECTOR3 *dir, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *rout, FLOAT *gout, FLOAT *bout); +HRESULT WINAPI D3DXSHEvalHemisphereLight(UINT order, const D3DXVECTOR3 *dir, D3DXCOLOR top, D3DXCOLOR bottom, FLOAT *rout, FLOAT *gout, FLOAT *bout); +HRESULT WINAPI D3DXSHEvalSphericalLight(UINT order, const D3DXVECTOR3 *dir, FLOAT radius, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *rout, FLOAT *gout, FLOAT *bout); +FLOAT* WINAPI D3DXSHMultiply2(FLOAT *out, const FLOAT *a, const FLOAT *b); +FLOAT* WINAPI D3DXSHMultiply3(FLOAT *out, const FLOAT *a, const FLOAT *b); +FLOAT* WINAPI D3DXSHMultiply4(FLOAT *out, const FLOAT *a, const FLOAT *b); +HRESULT WINAPI D3DXSHProjectCubeMap(UINT order, IDirect3DCubeTexture9 *texture, FLOAT *red, FLOAT *green, FLOAT *blue); +FLOAT* WINAPI D3DXSHRotate(FLOAT *out, UINT order, const D3DXMATRIX *matrix, const FLOAT *in); +FLOAT* WINAPI D3DXSHRotateZ(FLOAT *out, UINT order, FLOAT angle, const FLOAT *in); +FLOAT* WINAPI D3DXSHScale(FLOAT *out, UINT order, const FLOAT *a, const FLOAT scale); + +#ifdef __cplusplus +} +#endif + +typedef interface ID3DXMatrixStack *LPD3DXMATRIXSTACK; + +DEFINE_GUID(IID_ID3DXMatrixStack, +0xc7885ba7, 0xf990, 0x4fe7, 0x92, 0x2d, 0x85, 0x15, 0xe4, 0x77, 0xdd, 0x85); + +#undef INTERFACE +#define INTERFACE ID3DXMatrixStack + +DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + STDMETHOD(Pop)(THIS) PURE; + STDMETHOD(Push)(THIS) PURE; + STDMETHOD(LoadIdentity)(THIS) PURE; + STDMETHOD(LoadMatrix)(THIS_ const D3DXMATRIX* pM ) PURE; + STDMETHOD(MultMatrix)(THIS_ const D3DXMATRIX* pM ) PURE; + STDMETHOD(MultMatrixLocal)(THIS_ const D3DXMATRIX* pM ) PURE; + STDMETHOD(RotateAxis)(THIS_ const D3DXVECTOR3* pV, FLOAT Angle) PURE; + STDMETHOD(RotateAxisLocal)(THIS_ const D3DXVECTOR3* pV, FLOAT Angle) PURE; + STDMETHOD(RotateYawPitchRoll)(THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE; + STDMETHOD(RotateYawPitchRollLocal)(THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE; + STDMETHOD(Scale)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; + STDMETHOD(ScaleLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; + STDMETHOD(Translate)(THIS_ FLOAT x, FLOAT y, FLOAT z ) PURE; + STDMETHOD(TranslateLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; + STDMETHOD_(D3DXMATRIX*, GetTop)(THIS) PURE; +}; + +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) + +#define ID3DXMatrixStack_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXMatrixStack_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXMatrixStack_Release(p) (p)->lpVtbl->Release(p) +#define ID3DXMatrixStack_Pop(p) (p)->lpVtbl->Pop(p) +#define ID3DXMatrixStack_Push(p) (p)->lpVtbl->Push(p) +#define ID3DXMatrixStack_LoadIdentity(p) (p)->lpVtbl->LoadIdentity(p) +#define ID3DXMatrixStack_LoadMatrix(p,a) (p)->lpVtbl->LoadMatrix(p,a) +#define ID3DXMatrixStack_MultMatrix(p,a) (p)->lpVtbl->MultMatrix(p,a) +#define ID3DXMatrixStack_MultMatrixLocal(p,a) (p)->lpVtbl->MultMatrixLocal(p,a) +#define ID3DXMatrixStack_RotateAxis(p,a,b) (p)->lpVtbl->RotateAxis(p,a,b) +#define ID3DXMatrixStack_RotateAxisLocal(p,a,b) (p)->lpVtbl->RotateAxisLocal(p,a,b) +#define ID3DXMatrixStack_RotateYawPitchRoll(p,a,b,c) (p)->lpVtbl->RotateYawPitchRoll(p,a,b,c) +#define ID3DXMatrixStack_RotateYawPitchRollLocal(p,a,b,c) (p)->lpVtbl->RotateYawPitchRollLocal(p,a,b,c) +#define ID3DXMatrixStack_Scale(p,a,b,c) (p)->lpVtbl->Scale(p,a,b,c) +#define ID3DXMatrixStack_ScaleLocal(p,a,b,c) (p)->lpVtbl->ScaleLocal(p,a,b,c) +#define ID3DXMatrixStack_Translate(p,a,b,c) (p)->lpVtbl->Translate(p,a,b,c) +#define ID3DXMatrixStack_TranslateLocal(p,a,b,c) (p)->lpVtbl->TranslateLocal(p,a,b,c) +#define ID3DXMatrixStack_GetTop(p) (p)->lpVtbl->GetTop(p) + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DXCreateMatrixStack(DWORD flags, ID3DXMatrixStack **stack); + +#ifdef __cplusplus +} +#endif + +#include "d3dx9math.inl" + +#endif /* __D3DX9MATH_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9mesh.h b/WineFix/lib/d2d1/include/windows/d3dx9mesh.h new file mode 100644 index 0000000..d0cb896 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9mesh.h @@ -0,0 +1,1058 @@ +/* + * Copyright (C) 2009 David Adam + * Copyright (C) 2010 Tony Wasserka + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __WINE_D3DX9MESH_H +#define __WINE_D3DX9MESH_H + +DEFINE_GUID(IID_ID3DXBaseMesh, 0x7ed943dd, 0x52e8, 0x40b5, 0xa8, 0xd8, 0x76, 0x68, 0x5c, 0x40, 0x63, 0x30); +DEFINE_GUID(IID_ID3DXMesh, 0x4020e5c2, 0x1403, 0x4929, 0x88, 0x3f, 0xe2, 0xe8, 0x49, 0xfa, 0xc1, 0x95); +DEFINE_GUID(IID_ID3DXPMesh, 0x8875769a, 0xd579, 0x4088, 0xaa, 0xeb, 0x53, 0x4d, 0x1a, 0xd8, 0x4e, 0x96); +DEFINE_GUID(IID_ID3DXSPMesh, 0x667ea4c7, 0xf1cd, 0x4386, 0xb5, 0x23, 0x7c, 0x02, 0x90, 0xb8, 0x3c, 0xc5); +DEFINE_GUID(IID_ID3DXSkinInfo, 0x11eaa540, 0xf9a6, 0x4d49, 0xae, 0x6a, 0xe1, 0x92, 0x21, 0xf7, 0x0c, 0xc4); +DEFINE_GUID(IID_ID3DXPatchMesh,0x3ce6cc22, 0xdbf2, 0x44f4, 0x89, 0x4d, 0xf9, 0xc3, 0x4a, 0x33, 0x71, 0x39); +DEFINE_GUID(IID_ID3DXPRTBuffer, 0xf1827e47, 0x00a8, 0x49cd, 0x90, 0x8c, 0x9d, 0x11, 0x95, 0x5f, 0x87, 0x28); +DEFINE_GUID(IID_ID3DXPRTCompBuffer, 0xa758d465, 0xfe8d, 0x45ad, 0x9c, 0xf0, 0xd0, 0x1e, 0x56, 0x26, 0x6a, 0x07); +DEFINE_GUID(IID_ID3DXTextureGutterHelper, 0x838f01ec, 0x9729, 0x4527, 0xaa, 0xdb, 0xdf, 0x70, 0xad, 0xe7, 0xfe, 0xa9); +DEFINE_GUID(IID_ID3DXPRTEngine, 0x683a4278, 0xcd5f, 0x4d24, 0x90, 0xad, 0xc4, 0xe1, 0xb6, 0x85, 0x5d, 0x53); + +#define UNUSED16 (0xffff) +#define UNUSED32 (0xffffffff) + +enum _MAX_FVF_DECL_SIZE +{ + MAX_FVF_DECL_SIZE = MAXD3DDECLLENGTH + 1 +}; + +enum _D3DXMESH +{ + D3DXMESH_32BIT = 0x001, + D3DXMESH_DONOTCLIP = 0x002, + D3DXMESH_POINTS = 0x004, + D3DXMESH_RTPATCHES = 0x008, + D3DXMESH_NPATCHES = 0x4000, + D3DXMESH_VB_SYSTEMMEM = 0x010, + D3DXMESH_VB_MANAGED = 0x020, + D3DXMESH_VB_WRITEONLY = 0x040, + D3DXMESH_VB_DYNAMIC = 0x080, + D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000, + D3DXMESH_IB_SYSTEMMEM = 0x100, + D3DXMESH_IB_MANAGED = 0x200, + D3DXMESH_IB_WRITEONLY = 0x400, + D3DXMESH_IB_DYNAMIC = 0x800, + D3DXMESH_IB_SOFTWAREPROCESSING = 0x10000, + D3DXMESH_VB_SHARE = 0x1000, + D3DXMESH_USEHWONLY = 0x2000, + D3DXMESH_SYSTEMMEM = 0x110, + D3DXMESH_MANAGED = 0x220, + D3DXMESH_WRITEONLY = 0x440, + D3DXMESH_DYNAMIC = 0x880, + D3DXMESH_SOFTWAREPROCESSING = 0x18000 +}; + +enum _D3DXMESHOPT +{ + D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000, + D3DXMESHOPT_COMPACT = 0x01000000, + D3DXMESHOPT_ATTRSORT = 0x02000000, + D3DXMESHOPT_VERTEXCACHE = 0x04000000, + D3DXMESHOPT_STRIPREORDER = 0x08000000, + D3DXMESHOPT_IGNOREVERTS = 0x10000000, + D3DXMESHOPT_DONOTSPLIT = 0x20000000, +}; + +typedef enum _D3DXPATCHMESHTYPE +{ + D3DXPATCHMESH_RECT = 1, + D3DXPATCHMESH_TRI = 2, + D3DXPATCHMESH_NPATCH = 3, + D3DXPATCHMESH_FORCE_DWORD = 0x7fffffff, +} D3DXPATCHMESHTYPE; + +enum _D3DXPATCHMESH +{ + D3DXPATCHMESH_DEFAULT = 0, +}; + +enum _D3DXMESHSIMP +{ + D3DXMESHSIMP_VERTEX = 0x1, + D3DXMESHSIMP_FACE = 0x2, +}; + +typedef enum D3DXCLEANTYPE { + D3DXCLEAN_BACKFACING = 0x00000001, + D3DXCLEAN_BOWTIES = 0x00000002, + + D3DXCLEAN_SKINNING = D3DXCLEAN_BACKFACING, + D3DXCLEAN_OPTIMIZATION = D3DXCLEAN_BACKFACING, + D3DXCLEAN_SIMPLIFICATION = D3DXCLEAN_BACKFACING | D3DXCLEAN_BOWTIES, +} D3DXCLEANTYPE; + +typedef enum _D3DXTANGENT +{ + D3DXTANGENT_WRAP_U = 0x0001, + D3DXTANGENT_WRAP_V = 0x0002, + D3DXTANGENT_WRAP_UV = 0x0003, + D3DXTANGENT_DONT_NORMALIZE_PARTIALS = 0x0004, + D3DXTANGENT_DONT_ORTHOGONALIZE = 0x0008, + D3DXTANGENT_ORTHOGONALIZE_FROM_V = 0x0010, + D3DXTANGENT_ORTHOGONALIZE_FROM_U = 0x0020, + D3DXTANGENT_WEIGHT_BY_AREA = 0x0040, + D3DXTANGENT_WEIGHT_EQUAL = 0x0080, + D3DXTANGENT_WIND_CW = 0x0100, + D3DXTANGENT_CALCULATE_NORMALS = 0x0200, + D3DXTANGENT_GENERATE_IN_PLACE = 0x0400, +} D3DXTANGENT; + +typedef enum _D3DXIMT +{ + D3DXIMT_WRAP_U = 0x01, + D3DXIMT_WRAP_V = 0x02, + D3DXIMT_WRAP_UV = 0x03, +} D3DXIMT; + +typedef enum _D3DXUVATLAS +{ + D3DXUVATLAS_DEFAULT = 0x00, + D3DXUVATLAS_GEODESIC_FAST = 0x01, + D3DXUVATLAS_GEODESIC_QUALITY = 0x02, +} D3DXUVATLAS; + +typedef enum _D3DXEFFECTDEFAULTTYPE +{ + D3DXEDT_STRING = 1, + D3DXEDT_FLOATS = 2, + D3DXEDT_DWORD = 3, + D3DXEDT_FORCEDWORD = 0x7fffffff, +} D3DXEFFECTDEFAULTTYPE; + +enum _D3DXWELDEPSILONSFLAGS +{ + D3DXWELDEPSILONS_WELDALL = 0x1, + D3DXWELDEPSILONS_WELDPARTIALMATCHES = 0x2, + D3DXWELDEPSILONS_DONOTREMOVEVERTICES = 0x4, + D3DXWELDEPSILONS_DONOTSPLIT = 0x8, +}; + +typedef enum _D3DXSHCOMPRESSQUALITYTYPE +{ + D3DXSHCQUAL_FASTLOWQUALITY = 1, + D3DXSHCQUAL_SLOWHIGHQUALITY = 2, + D3DXSHCQUAL_FORCE_DWORD = 0x7fffffff, +} D3DXSHCOMPRESSQUALITYTYPE; + +typedef enum _D3DXSHGPUSIMOPT +{ + D3DXSHGPUSIMOPT_SHADOWRES256 = 1, + D3DXSHGPUSIMOPT_SHADOWRES512 = 0, + D3DXSHGPUSIMOPT_SHADOWRES1024 = 2, + D3DXSHGPUSIMOPT_SHADOWRES2048 = 3, + D3DXSHGPUSIMOPT_HIGHQUALITY = 4, + D3DXSHGPUSIMOPT_FORCE_DWORD = 0x7fffffff, +} D3DXSHGPUSIMOPT; + +typedef struct ID3DXBaseMesh* LPD3DXBASEMESH; +typedef struct ID3DXMesh* LPD3DXMESH; +typedef struct ID3DXPMesh *LPD3DXPMESH; +typedef struct ID3DXSPMesh *LPD3DXSPMESH; +typedef struct ID3DXSkinInfo *LPD3DXSKININFO; +typedef struct ID3DXPatchMesh *LPD3DXPATCHMESH; +typedef struct ID3DXPRTBuffer *LPD3DXPRTBUFFER; +typedef struct ID3DXPRTCompBuffer *LPD3DXPRTCOMPBUFFER; +typedef struct ID3DXPRTEngine *LPD3DXPRTENGINE; +typedef struct ID3DXTextureGutterHelper *LPD3DXTEXTUREGUTTERHELPER; + +typedef struct _D3DXATTRIBUTERANGE { + DWORD AttribId; + DWORD FaceStart; + DWORD FaceCount; + DWORD VertexStart; + DWORD VertexCount; +} D3DXATTRIBUTERANGE; + +typedef D3DXATTRIBUTERANGE* LPD3DXATTRIBUTERANGE; + +typedef struct _D3DXMATERIAL +{ + D3DMATERIAL9 MatD3D; + char *pTextureFilename; +} D3DXMATERIAL, *LPD3DXMATERIAL; + +typedef struct _D3DXEFFECTDEFAULT +{ + char *pParamName; + D3DXEFFECTDEFAULTTYPE Type; + DWORD NumBytes; + void *pValue; +} D3DXEFFECTDEFAULT, *LPD3DXEFFECTDEFAULT; + +typedef struct _D3DXEFFECTINSTANCE +{ + char *pEffectFilename; + DWORD NumDefaults; + LPD3DXEFFECTDEFAULT pDefaults; +} D3DXEFFECTINSTANCE, *LPD3DXEFFECTINSTANCE; + +typedef struct _D3DXATTRIBUTEWEIGHTS +{ + FLOAT Position; + FLOAT Boundary; + FLOAT Normal; + FLOAT Diffuse; + FLOAT Specular; + FLOAT Texcoords[8]; + FLOAT Tangent; + FLOAT Binormal; +} D3DXATTRIBUTEWEIGHTS, *LPD3DXATTRIBUTEWEIGHTS; + +typedef struct _D3DXWELDEPSILONS +{ + FLOAT Position; + FLOAT BlendWeights; + FLOAT Normals; + FLOAT PSize; + FLOAT Specular; + FLOAT Diffuse; + FLOAT Texcoords[8]; + FLOAT Tangent; + FLOAT Binormal; + FLOAT TessFactor; +} D3DXWELDEPSILONS, *LPD3DXWELDEPSILONS; + +typedef struct _D3DXBONECOMBINATION +{ + DWORD AttribId; + DWORD FaceStart; + DWORD FaceCount; + DWORD VertexStart; + DWORD VertexCout; + DWORD *BoneId; +} D3DXBONECOMBINATION, *LPD3DXBONECOMBINATION; + +typedef struct _D3DXPATCHINFO +{ + D3DXPATCHMESHTYPE PatchType; + D3DDEGREETYPE Degree; + D3DBASISTYPE Basis; +} D3DXPATCHINFO, *LPD3DXPATCHINFO; + +typedef struct _D3DXINTERSECTINFO +{ + DWORD FaceIndex; + FLOAT U; + FLOAT V; + FLOAT Dist; +} D3DXINTERSECTINFO, *LPD3DXINTERSECTINFO; + +typedef struct _D3DXSHMATERIAL +{ + D3DCOLORVALUE Diffuse; + BOOL bMirror; + BOOL bSubSurf; + FLOAT RelativeIndexOfRefraction; + D3DCOLORVALUE Absorption; + D3DCOLORVALUE ReducedScattering; +} D3DXSHMATERIAL; + +typedef struct _D3DXSHPRTSPLITMESHVERTDATA +{ + UINT uVertRemap; + UINT uSubCluster; + UCHAR ucVertStatus; +} D3DXSHPRTSPLITMESHVERTDATA; + +typedef struct _D3DXSHPRTSPLITMESHCLUSTERDATA +{ + UINT uVertStart; + UINT uVertLength; + UINT uFaceStart; + UINT uFaceLength; + UINT uClusterStart; + UINT uClusterLength; +} D3DXSHPRTSPLITMESHCLUSTERDATA; + +typedef struct _XFILECOMPRESSEDANIMATIONSET +{ + DWORD CompressedBlockSize; + FLOAT TicksPerSec; + DWORD PlaybackType; + DWORD BufferLength; +} XFILECOMPRESSEDANIMATIONSET; + +typedef HRESULT (WINAPI *LPD3DXUVATLASCB)(float complete, void *ctx); +typedef HRESULT (WINAPI *LPD3DXIMTSIGNALCALLBACK)(const D3DXVECTOR2 *, UINT, UINT, void *, FLOAT *); +typedef HRESULT (WINAPI *LPD3DXSHPRTSIMCB)(float complete, void *ctx); + +#undef INTERFACE +#define INTERFACE ID3DXBaseMesh + +DECLARE_INTERFACE_(ID3DXBaseMesh, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBaseMesh ***/ + STDMETHOD(DrawSubset)(THIS_ DWORD attrib_id) PURE; + STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE; + STDMETHOD_(DWORD, GetFVF)(THIS) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE; + STDMETHOD_(DWORD, GetOptions)(THIS) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(CloneMeshFVF)(THIS_ DWORD options, DWORD fvf, + struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(CloneMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE; + STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE; + STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockVertexBuffer)(THIS) PURE; + STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockIndexBuffer)(THIS) PURE; + STDMETHOD(GetAttributeTable)(THIS_ D3DXATTRIBUTERANGE* attrib_table, DWORD* attrib_table_size) PURE; + STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD *point_reps, DWORD *adjacency) PURE; + STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD *adjacency, DWORD *point_reps) PURE; + STDMETHOD(GenerateAdjacency)(THIS_ FLOAT epsilon, DWORD* adjacency) PURE; + STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXMesh +DECLARE_INTERFACE_(ID3DXMesh, ID3DXBaseMesh) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBaseMesh ***/ + STDMETHOD(DrawSubset)(THIS_ DWORD attrib_id) PURE; + STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE; + STDMETHOD_(DWORD, GetFVF)(THIS) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE; + STDMETHOD_(DWORD, GetOptions)(THIS) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(CloneMeshFVF)(THIS_ DWORD options, DWORD fvf, + struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(CloneMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE; + STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE; + STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockVertexBuffer)(THIS) PURE; + STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockIndexBuffer)(THIS) PURE; + STDMETHOD(GetAttributeTable)(THIS_ D3DXATTRIBUTERANGE* attrib_table, DWORD* attrib_table_size) PURE; + STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD *point_reps, DWORD *adjacency) PURE; + STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD *adjacency, DWORD *point_reps) PURE; + STDMETHOD(GenerateAdjacency)(THIS_ FLOAT epsilon, DWORD* adjacency) PURE; + STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + /*** ID3DXMesh ***/ + STDMETHOD(LockAttributeBuffer)(THIS_ DWORD flags, DWORD** data) PURE; + STDMETHOD(UnlockAttributeBuffer)(THIS) PURE; + STDMETHOD(Optimize)(THIS_ DWORD flags, const DWORD *adjacency_in, DWORD *adjacency_out, + DWORD *face_remap, ID3DXBuffer **vertex_remap, ID3DXMesh **opt_mesh) PURE; + STDMETHOD(OptimizeInplace)(THIS_ DWORD flags, const DWORD *adjacency_in, DWORD *adjacency_out, + DWORD *face_remap, ID3DXBuffer **vertex_remap) PURE; + STDMETHOD(SetAttributeTable)(THIS_ const D3DXATTRIBUTERANGE *attrib_table, + DWORD attrib_table_size) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXPMesh +DECLARE_INTERFACE_(ID3DXPMesh, ID3DXBaseMesh) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBaseMesh ***/ + STDMETHOD(DrawSubset)(THIS_ DWORD attrib_id) PURE; + STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE; + STDMETHOD_(DWORD, GetFVF)(THIS) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE; + STDMETHOD_(DWORD, GetOptions)(THIS) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(CloneMeshFVF)(THIS_ DWORD options, DWORD fvf, + struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(CloneMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE; + STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE; + STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockVertexBuffer)(THIS) PURE; + STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockIndexBuffer)(THIS) PURE; + STDMETHOD(GetAttributeTable)(THIS_ D3DXATTRIBUTERANGE* attrib_table, DWORD* attrib_table_size) PURE; + STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD *point_reps, DWORD *adjacency) PURE; + STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD *adjacency, DWORD *point_reps) PURE; + STDMETHOD(GenerateAdjacency)(THIS_ FLOAT epsilon, DWORD* adjacency) PURE; + STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + /*** ID3DXPMesh ***/ + STDMETHOD(ClonePMeshFVF)(THIS_ DWORD options, DWORD fvf, + struct IDirect3DDevice9 *device, struct ID3DXPMesh **clone_mesh) PURE; + STDMETHOD(ClonePMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, struct ID3DXPMesh **clone_mesh) PURE; + STDMETHOD(SetNumFaces)(THIS_ DWORD faces) PURE; + STDMETHOD(SetNumVertices)(THIS_ DWORD vertices) PURE; + STDMETHOD_(DWORD, GetMaxFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetMinFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetMaxVertices)(THIS) PURE; + STDMETHOD_(DWORD, GetMinVertices)(THIS) PURE; + STDMETHOD(Save)(THIS_ IStream *stream, const D3DXMATERIAL *material, + const D3DXEFFECTINSTANCE *effect_instance, DWORD num_materials) PURE; + STDMETHOD(Optimize)(THIS_ DWORD flags, DWORD *adjacency_out, DWORD *face_remap, + ID3DXBuffer **vertex_remap, ID3DXMesh **opt_mesh) PURE; + STDMETHOD(OptimizeBaseLOD)(THIS_ DWORD flags, DWORD* face_remap) PURE; + STDMETHOD(TrimByFaces)(THIS_ DWORD new_faces_min, DWORD new_faces_max, DWORD* face_remap, DWORD* vertex_remap) PURE; + STDMETHOD(TrimByVertices)(THIS_ DWORD new_vertices_min, DWORD new_vertices_max, DWORD* face_remap, DWORD* vertex_remap) PURE; + STDMETHOD(GetAdjacency)(THIS_ DWORD* adjacency) PURE; + STDMETHOD(GenerateVertexHistory)(THIS_ DWORD* vertex_history) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXSPMesh +DECLARE_INTERFACE_(ID3DXSPMesh, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXSPMesh ***/ + STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE; + STDMETHOD_(DWORD, GetNumFVF)(THIS) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + STDMETHOD_(DWORD, GetOptions)(THIS) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(CloneMeshFVF)(THIS_ DWORD options, DWORD fvf, + struct IDirect3DDevice9 *device, DWORD *adjacency_out, + DWORD *vertex_remap_out, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(CloneMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, DWORD *adjacency_out, + DWORD *vertex_remap_out, struct ID3DXMesh **clone_mesh) PURE; + STDMETHOD(ClonePMeshFVF)(THIS_ DWORD options, DWORD fvf, + struct IDirect3DDevice9 *device, DWORD *vertex_remap_out, + float *errors_by_face, struct ID3DXPMesh **clone_mesh) PURE; + STDMETHOD(ClonePMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, DWORD *vertex_remap_out, + float *errors_by_face, struct ID3DXPMesh **clone_mesh) PURE; + STDMETHOD(ReduceFaces)(THIS_ DWORD faces) PURE; + STDMETHOD(ReduceVertices)(THIS_ DWORD vertices) PURE; + STDMETHOD_(DWORD, GetMaxFaces)(THIS) PURE; + STDMETHOD_(DWORD, GetMaxVertices)(THIS) PURE; + STDMETHOD(GetVertexAttributeWeights)(THIS_ LPD3DXATTRIBUTEWEIGHTS vertex_attribute_weights) PURE; + STDMETHOD(GetVertexWeights)(THIS_ FLOAT* vertex_weights) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXPatchMesh +DECLARE_INTERFACE_(ID3DXPatchMesh, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXPatchMesh ***/ + STDMETHOD_(DWORD, GetNumPatches)(THIS) PURE; + STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + STDMETHOD_(DWORD, GetControlVerticesPerPatch)(THIS) PURE; + STDMETHOD_(DWORD, GetOptions)(THIS) PURE; + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD(GetPatchInfo)(THIS_ LPD3DXPATCHINFO patch_info) PURE; + STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE; + STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE; + STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockVertexBuffer)(THIS) PURE; + STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE; + STDMETHOD(UnlockIndexBuffer)(THIS) PURE; + STDMETHOD(LockAttributeBuffer)(THIS_ DWORD flags, DWORD** data) PURE; + STDMETHOD(UnlockAttributeBuffer)(THIS) PURE; + STDMETHOD(GetTessSize)(THIS_ FLOAT tess_level, DWORD adaptive, DWORD* num_triangles, DWORD* num_vertices) PURE; + STDMETHOD(GenerateAdjacency)(THIS_ FLOAT tolerance) PURE; + STDMETHOD(CloneMesh)(THIS_ DWORD options, const D3DVERTEXELEMENT9 *declaration, ID3DXPatchMesh **clone_mesh) PURE; + STDMETHOD(Optimize)(THIS_ DWORD flags) PURE; + STDMETHOD(SetDisplaceParam)(THIS_ struct IDirect3DBaseTexture9 *texture, D3DTEXTUREFILTERTYPE min_filter, + D3DTEXTUREFILTERTYPE mag_filter, D3DTEXTUREFILTERTYPE mip_filter, D3DTEXTUREADDRESS wrap, + DWORD lod_bias) PURE; + STDMETHOD(GetDisplaceParam)(THIS_ struct IDirect3DBaseTexture9 **texture, D3DTEXTUREFILTERTYPE *min_filter, + D3DTEXTUREFILTERTYPE *mag_filter, D3DTEXTUREFILTERTYPE *mip_filter, D3DTEXTUREADDRESS *wrap, + DWORD *lod_bias) PURE; + STDMETHOD(Tessellate)(THIS_ float tess_level, ID3DXMesh *mesh) PURE; + STDMETHOD(TessellateAdaptive)(THIS_ const D3DXVECTOR4 *trans, DWORD max_tess_level, + DWORD min_tess_level, ID3DXMesh *mesh) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXSkinInfo +DECLARE_INTERFACE_(ID3DXSkinInfo, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXSkinInfo ***/ + STDMETHOD(SetBoneInfluence)(THIS_ DWORD bone, DWORD num_influences, const DWORD *vertices, + const FLOAT *weights) PURE; + STDMETHOD(SetBoneVertexInfluence)(THIS_ DWORD bone_num, DWORD influence_num, float weight) PURE; + STDMETHOD_(DWORD, GetNumBoneInfluences)(THIS_ DWORD bone) PURE; + STDMETHOD(GetBoneInfluence)(THIS_ DWORD bone, DWORD* vertices, FLOAT* weights) PURE; + STDMETHOD(GetBoneVertexInfluence)(THIS_ DWORD bone_num, DWORD influence_num, float *weight, DWORD* vertex_num) PURE; + STDMETHOD(GetMaxVertexInfluences)(THIS_ DWORD* max_vertex_influences) PURE; + STDMETHOD_(DWORD, GetNumBones)(THIS) PURE; + STDMETHOD(FindBoneVertexInfluenceIndex)(THIS_ DWORD bone_num, DWORD vertex_num, DWORD* influence_index) PURE; + STDMETHOD(GetMaxFaceInfluences)(THIS_ struct IDirect3DIndexBuffer9 *index_buffer, + DWORD num_faces, DWORD *max_face_influences) PURE; + STDMETHOD(SetMinBoneInfluence)(THIS_ FLOAT min_influence) PURE; + STDMETHOD_(FLOAT, GetMinBoneInfluence)(THIS) PURE; + STDMETHOD(SetBoneName)(THIS_ DWORD bone_idx, const char *name) PURE; + STDMETHOD_(const char *, GetBoneName)(THIS_ DWORD bone_idx) PURE; + STDMETHOD(SetBoneOffsetMatrix)(THIS_ DWORD bone, const D3DXMATRIX *bone_transform) PURE; + STDMETHOD_(D3DXMATRIX *, GetBoneOffsetMatrix)(THIS_ DWORD bone) PURE; + STDMETHOD(Clone)(THIS_ ID3DXSkinInfo **skin_info) PURE; + STDMETHOD(Remap)(THIS_ DWORD num_vertices, DWORD* vertex_remap) PURE; + STDMETHOD(SetFVF)(THIS_ DWORD FVF) PURE; + STDMETHOD(SetDeclaration)(THIS_ const D3DVERTEXELEMENT9 *declaration) PURE; + STDMETHOD_(DWORD, GetFVF)(THIS) PURE; + STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE; + STDMETHOD(UpdateSkinnedMesh)(THIS_ const D3DXMATRIX *bone_transforms, + const D3DXMATRIX *bone_inv_transpose_transforms, const void *src_vertices, void *dst_vertices) PURE; + STDMETHOD(ConvertToBlendedMesh)(THIS_ ID3DXMesh *mesh_in, DWORD options, const DWORD *adjacency_in, + DWORD *adjacency_out, DWORD *face_remap, ID3DXBuffer **vertex_remap, DWORD *max_face_infl, + DWORD *num_bone_combinations, ID3DXBuffer **bone_combination_table, ID3DXMesh **mesh_out) PURE; + STDMETHOD(ConvertToIndexedBlendedMesh)(THIS_ ID3DXMesh *mesh_in, DWORD options, DWORD palette_size, + const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap, ID3DXBuffer **vertex_remap, + DWORD *max_face_infl, DWORD *num_bone_combinations, ID3DXBuffer **bone_combination_table, + ID3DXMesh **mesh_out) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXPRTBuffer +DECLARE_INTERFACE_(ID3DXPRTBuffer, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXPRTBuffer methods ***/ + STDMETHOD_(UINT, GetNumSamples)(THIS) PURE; + STDMETHOD_(UINT, GetNumCoeffs)(THIS) PURE; + STDMETHOD_(UINT, GetNumChannels)(THIS) PURE; + STDMETHOD_(BOOL, IsTexture)(THIS) PURE; + STDMETHOD_(BOOL, GetWidth)(THIS) PURE; + STDMETHOD_(BOOL, GetHeight)(THIS) PURE; + STDMETHOD(Resize)(THIS_ UINT new_size) PURE; + STDMETHOD(LockBuffer)(THIS_ UINT start, UINT num_samples, FLOAT **data) PURE; + STDMETHOD(UnlockBuffer)(THIS) PURE; + STDMETHOD(ScaleBuffer)(THIS_ FLOAT scale) PURE; + STDMETHOD(AddBuffer)(THIS_ ID3DXPRTBuffer *buffer) PURE; + STDMETHOD(AttachGH)(THIS_ struct ID3DXTextureGutterHelper *gh) PURE; + STDMETHOD(ReleaseGH)(THIS) PURE; + STDMETHOD(EvalGH)(THIS) PURE; + STDMETHOD(ExtractTexture)(THIS_ UINT channel, UINT start_coefficient, + UINT num_coefficients, struct IDirect3DTexture9 *texture) PURE; + STDMETHOD(ExtractToMesh)(THIS_ UINT num_coefficients, D3DDECLUSAGE usage, + UINT usage_index_start, ID3DXMesh *scene) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXPRTCompBuffer +DECLARE_INTERFACE_(ID3DXPRTCompBuffer, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXPRTCompBuffer methods ***/ + STDMETHOD_(UINT, GetNumSamples)(THIS) PURE; + STDMETHOD_(UINT, GetNumCoeffs)(THIS) PURE; + STDMETHOD_(UINT, GetNumChannels)(THIS) PURE; + STDMETHOD_(BOOL, IsTexture)(THIS) PURE; + STDMETHOD_(UINT, GetWidth)(THIS) PURE; + STDMETHOD_(UINT, GetHeight)(THIS) PURE; + STDMETHOD_(UINT, GetNumClusters)(THIS) PURE; + STDMETHOD_(UINT, GetNumPCA)(THIS) PURE; + STDMETHOD(NormalizeData)(THIS) PURE; + STDMETHOD(ExtractBasis)(THIS_ UINT cluster, FLOAT *cluster_basis) PURE; + STDMETHOD(ExtractClusterIDs)(THIS_ UINT *cluster_ids) PURE; + STDMETHOD(ExtractPCA)(THIS_ UINT start_pca, UINT num_extract, FLOAT *pca_coefficients) PURE; + STDMETHOD(ExtractTexture)(THIS_ UINT start_pca, UINT num_pca, struct IDirect3DTexture9 *texture) PURE; + STDMETHOD(ExtractToMesh)(THIS_ UINT num_pca, D3DDECLUSAGE usage, UINT usage_index_start, ID3DXMesh *scene) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXTextureGutterHelper +DECLARE_INTERFACE_(ID3DXTextureGutterHelper, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXTextureGutterHelper methods ***/ + STDMETHOD_(UINT, GetWidth)(THIS) PURE; + STDMETHOD_(UINT, GetHeight)(THIS) PURE; + + STDMETHOD(ApplyGuttersFloat)(THIS_ FLOAT *data_in, UINT num_coeffs, UINT width, UINT height) PURE; + STDMETHOD(ApplyGuttersTex)(THIS_ struct IDirect3DTexture9 *texture) PURE; + STDMETHOD(ApplyGuttersPRT)(THIS_ ID3DXPRTBuffer *buffer) PURE; + STDMETHOD(ResampleTex)(THIS_ struct IDirect3DTexture9 *texture_in, struct ID3DXMesh *mesh_in, + D3DDECLUSAGE usage, UINT usage_index, struct IDirect3DTexture9 *texture_out) PURE; + STDMETHOD(GetFaceMap)(THIS_ UINT *face_data) PURE; + STDMETHOD(GetBaryMap)(THIS_ D3DXVECTOR2 *bary_data) PURE; + STDMETHOD(GetTexelMap)(THIS_ D3DXVECTOR2 *texel_data) PURE; + STDMETHOD(GetGutterMap)(THIS_ BYTE *gutter_data) PURE; + STDMETHOD(SetFaceMap)(THIS_ UINT *face_data) PURE; + STDMETHOD(SetBaryMap)(THIS_ D3DXVECTOR2 *bary_data) PURE; + STDMETHOD(SetTexelMap)(THIS_ D3DXVECTOR2 *texel_data) PURE; + STDMETHOD(SetGutterMap)(THIS_ BYTE *gutter_data) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXPRTEngine +DECLARE_INTERFACE_(ID3DXPRTEngine, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXPRTEngine methods ***/ + STDMETHOD(SetMeshMaterials)(THIS_ const D3DXSHMATERIAL **materials, UINT num_meshes, + UINT num_channels, BOOL set_albedo, FLOAT length_scale) PURE; + STDMETHOD(SetPerVertexAlbedo)(THIS_ const void *data_in, UINT num_channels, UINT stride) PURE; + STDMETHOD(SetPerTexelAlbedo)(THIS_ struct IDirect3DTexture9 *albedo_texture, + UINT num_channels, struct ID3DXTextureGutterHelper *gh) PURE; + STDMETHOD(GetVertexAlbedo)(THIS_ D3DXCOLOR *vert_colors, UINT num_verts) PURE; + STDMETHOD(SetPerTexelNormals)(THIS_ struct IDirect3DTexture9 *normal_texture) PURE; + STDMETHOD(ExtractPerVertexAlbedo)(THIS_ ID3DXMesh *mesh, D3DDECLUSAGE usage, UINT num_channels) PURE; + STDMETHOD(ResampleBuffer)(THIS_ ID3DXPRTBuffer *buffer_in, ID3DXPRTBuffer *buffer_out) PURE; + STDMETHOD(GetAdaptedMesh)(THIS_ struct IDirect3DDevice9 *device, UINT *face_remap, + UINT *vert_remap, float *vert_weights, struct ID3DXMesh **mesh) PURE; + STDMETHOD_(UINT, GetNumVerts)(THIS) PURE; + STDMETHOD_(UINT, GetNumFaces)(THIS) PURE; + STDMETHOD(SetMinMaxIntersection)(THIS_ FLOAT min, FLOAT max) PURE; + STDMETHOD(RobustMeshRefine)(THIS_ FLOAT min_edge_length, UINT max_subdiv) PURE; + STDMETHOD(SetSamplingInfo)(THIS_ UINT num_rays, BOOL use_sphere, + BOOL use_cosine, BOOL adaptive, FLOAT adpative_thresh) PURE; + STDMETHOD(ComputeDirectLightingSH)(THIS_ UINT sh_order, ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ComputeDirectLightingSHAdaptive)(THIS_ UINT sh_order, float adaptive_thresh, + float min_edge_length, UINT max_subdiv, ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ComputeDirectLightingSHGPU)(THIS_ struct IDirect3DDevice9 *device, UINT flags, + UINT sh_order, float zbias, float zangle_bias, struct ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ComputeSS)(THIS_ ID3DXPRTBuffer *data_in, ID3DXPRTBuffer *data_out, + ID3DXPRTBuffer *data_total) PURE; + STDMETHOD(ComputeSSAdaptive)(THIS_ ID3DXPRTBuffer *data_in, float adaptive_thres, + float min_edge_length, UINT max_subdiv, ID3DXPRTBuffer *data_out, ID3DXPRTBuffer *data_total) PURE; + STDMETHOD(ComputeBounce)(THIS_ ID3DXPRTBuffer *data_in, ID3DXPRTBuffer *data_out, + ID3DXPRTBuffer *data_total) PURE; + STDMETHOD(ComputeBounceAdaptive)(THIS_ ID3DXPRTBuffer *data_in, float adaptive_thres, + float min_edge_length, UINT max_subdiv, ID3DXPRTBuffer *data_out, ID3DXPRTBuffer *data_total) PURE; + STDMETHOD(ComputeVolumeSamplesDirectSH)(THIS_ UINT sh_order_in, UINT sh_order_out, + UINT num_vol_samples, const D3DXVECTOR3 *sample_locs, ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ComputeVolumeSamples)(THIS_ ID3DXPRTBuffer *surf_data_in, UINT sh_order, + UINT num_vol_samples, const D3DXVECTOR3 *sample_locs, ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ComputeSurfSamplesDirectSH)(THIS_ UINT sh_order, UINT num_samples, + const D3DXVECTOR3 *sample_locs, const D3DXVECTOR3 *sample_norms, ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ComputeSurfSamplesBounce)(THIS_ ID3DXPRTBuffer *surf_data_in, UINT num_samples, + const D3DXVECTOR3 *sample_locs, const D3DXVECTOR3 *sample_norms, ID3DXPRTBuffer *data_out, + ID3DXPRTBuffer *data_total) PURE; + STDMETHOD(FreeSSData)(THIS) PURE; + STDMETHOD(FreeBounceData)(THIS) PURE; + STDMETHOD(ComputeLDPRTCoeffs)(THIS_ ID3DXPRTBuffer *data_in, UINT sh_order, D3DXVECTOR3 *norm_out, + ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(ScaleMeshChunk)(THIS_ UINT mesh_chunk, float scale, ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(MultiplyAlbedo)(THIS_ ID3DXPRTBuffer *data_out) PURE; + STDMETHOD(SetCallback)(THIS_ LPD3DXSHPRTSIMCB cb, float frequency, void *user_context) PURE; + STDMETHOD_(BOOL, ShadowRayIntersects)(THIS_ const D3DXVECTOR3 *ray_pos, + const D3DXVECTOR3 *ray_dir) PURE; + STDMETHOD_(BOOL, ClosestRayIntersects)(THIS_ const D3DXVECTOR3 *ray_pos, + const D3DXVECTOR3 *ray_dir, DWORD *face_index, FLOAT *u, FLOAT *v, FLOAT *dist) PURE; +}; +#undef INTERFACE + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DXCreateMesh(DWORD face_count, DWORD vertex_count, DWORD flags, + const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXCreateMeshFVF(DWORD face_count, DWORD vertex_count, DWORD flags, + DWORD fvf, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXCreateBuffer(DWORD size, ID3DXBuffer **buffer); +HRESULT WINAPI D3DXCreateSPMesh(ID3DXMesh *mesh, const DWORD *adjacency, + const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights, ID3DXSPMesh **spmesh); +HRESULT WINAPI D3DXCreatePMeshFromStream(struct IStream *stream, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXPMesh **mesh); +HRESULT WINAPI D3DXCreateSkinInfo(DWORD vertex_count, const D3DVERTEXELEMENT9 *declaration, + DWORD bone_count, ID3DXSkinInfo **skin_info); +HRESULT WINAPI D3DXCreateSkinInfoFVF(DWORD vertex_count, DWORD fvf, DWORD bone_count, ID3DXSkinInfo **skin_info); +HRESULT WINAPI D3DXCreateSkinInfoFromBlendedMesh(ID3DXBaseMesh *mesh, DWORD bone_count, + const D3DXBONECOMBINATION *bone_combination_table, ID3DXSkinInfo **skin_info); +HRESULT WINAPI D3DXCreatePatchMesh(const D3DXPATCHINFO *patch_info, DWORD patch_count, + DWORD vertex_count, DWORD flags, const D3DVERTEXELEMENT9 *declaration, + struct IDirect3DDevice9 *device, struct ID3DXPatchMesh **mesh); +HRESULT WINAPI D3DXCreatePRTBuffer(UINT sample_count, UINT coeff_count, UINT channel_count, ID3DXPRTBuffer **buffer); +HRESULT WINAPI D3DXCreatePRTBufferTex(UINT width, UINT height, UINT coeff_count, + UINT channel_count, ID3DXPRTBuffer **buffer); +HRESULT WINAPI D3DXCreatePRTCompBuffer(D3DXSHCOMPRESSQUALITYTYPE quality, UINT cluster_count, UINT pca_count, + LPD3DXSHPRTSIMCB cb, void *ctx, ID3DXPRTBuffer *input, ID3DXPRTCompBuffer **buffer); +HRESULT WINAPI D3DXCreateTextureGutterHelper(UINT width, UINT height, ID3DXMesh *mesh, + float gutter_size, ID3DXTextureGutterHelper **gh); +HRESULT WINAPI D3DXCreatePRTEngine(ID3DXMesh *mesh, DWORD *adjacency, BOOL extract_uv, + ID3DXMesh *blocker_mesh, ID3DXPRTEngine **engine); +HRESULT WINAPI D3DXLoadMeshFromXA(const char *filename, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXLoadMeshFromXW(const WCHAR *filename, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXMesh **mesh); +#define D3DXLoadMeshFromX WINELIB_NAME_AW(D3DXLoadMeshFromX) +HRESULT WINAPI D3DXLoadMeshFromXInMemory(const void *data, DWORD data_size, DWORD flags, + struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, + struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXLoadMeshFromXResource(HMODULE module, const char *resource, const char *resource_type, + DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, + struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXLoadMeshFromXof(struct ID3DXFileData *file_data, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXLoadPatchMeshFromXof(struct ID3DXFileData *file_data, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXPatchMesh **mesh); +HRESULT WINAPI D3DXLoadSkinMeshFromXof(struct ID3DXFileData *file_data, DWORD flags, struct IDirect3DDevice9 *device, + struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, + DWORD *material_count, struct ID3DXSkinInfo **skin_info, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXLoadPRTBufferFromFileA(const char *filename, ID3DXPRTBuffer **buffer); +HRESULT WINAPI D3DXLoadPRTBufferFromFileW(const WCHAR *filename, ID3DXPRTBuffer **buffer); +#define D3DXLoadPRTBufferFromFile WINELIB_NAME_AW(D3DXLoadPRTBufferFromFile) +HRESULT WINAPI D3DXLoadPRTCompBufferFromFileA(const char *filename, ID3DXPRTCompBuffer **buffer); +HRESULT WINAPI D3DXLoadPRTCompBufferFromFileW(const WCHAR *filename, ID3DXPRTCompBuffer **buffer); +#define D3DXLoadPRTCompBufferFromFile WINELIB_NAME_AW(D3DXLoadPRTCompBufferFromFile) +HRESULT WINAPI D3DXSaveMeshToXA(const char *filename, ID3DXMesh *mesh, const DWORD *adjacency, + const D3DXMATERIAL *materials, const D3DXEFFECTINSTANCE *effect_instances, DWORD material_count, DWORD format); +HRESULT WINAPI D3DXSaveMeshToXW(const WCHAR *filename, ID3DXMesh *mesh, const DWORD *adjacency, + const D3DXMATERIAL *materials, const D3DXEFFECTINSTANCE *effect_instances, DWORD material_count, DWORD format); +#define D3DXSaveMeshToX WINELIB_NAME_AW(D3DXSaveMeshToX) +HRESULT WINAPI D3DXSavePRTBufferToFileA(const char *filename, ID3DXPRTBuffer *buffer); +HRESULT WINAPI D3DXSavePRTBufferToFileW(const WCHAR *filename, ID3DXPRTBuffer *buffer); +#define D3DXSavePRTBufferToFile WINELIB_NAME_AW(D3DXSavePRTBufferToFile) +HRESULT WINAPI D3DXSavePRTCompBufferToFileA(const char *filename, ID3DXPRTCompBuffer *buffer); +HRESULT WINAPI D3DXSavePRTCompBufferToFileW(const WCHAR *filename, ID3DXPRTCompBuffer *buffer); +#define D3DXSavePRTCompBufferToFile WINELIB_NAME_AW(D3DXSavePRTCompBufferToFile) +UINT WINAPI D3DXGetDeclLength(const D3DVERTEXELEMENT9 *decl); +UINT WINAPI D3DXGetDeclVertexSize(const D3DVERTEXELEMENT9 *decl, DWORD stream_idx); +UINT WINAPI D3DXGetFVFVertexSize(DWORD); +BOOL WINAPI D3DXBoxBoundProbe(const D3DXVECTOR3 *vmin, const D3DXVECTOR3 *vmax, + const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir); +BOOL WINAPI D3DXSphereBoundProbe(const D3DXVECTOR3 *center, FLOAT radius, + const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir); +HRESULT WINAPI D3DXCleanMesh(D3DXCLEANTYPE clean_type, ID3DXMesh *mesh_in, const DWORD *adjacency_in, + ID3DXMesh **mesh_out, DWORD *adjacency_out, ID3DXBuffer **errors); +HRESULT WINAPI D3DXConcatenateMeshes(struct ID3DXMesh **meshes, UINT mesh_count, DWORD flags, + const D3DXMATRIX *geometry_matrices, const D3DXMATRIX *texture_matrices, + const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh); +HRESULT WINAPI D3DXComputeBoundingBox(const D3DXVECTOR3 *first_pos, DWORD num_vertices, + DWORD stride, D3DXVECTOR3 *vmin, D3DXVECTOR3 *vmax); +HRESULT WINAPI D3DXComputeBoundingSphere(const D3DXVECTOR3 *first_pos, DWORD num_vertices, + DWORD stride, D3DXVECTOR3 *center, FLOAT *radius); +HRESULT WINAPI D3DXComputeIMTFromPerTexelSignal(ID3DXMesh *mesh, DWORD texture_idx, float *texel_signal, + UINT width, UINT height, UINT signal_dimension, UINT component_count, DWORD flags, + LPD3DXUVATLASCB cb, void *ctx, ID3DXBuffer **buffer); +HRESULT WINAPI D3DXComputeIMTFromPerVertexSignal(ID3DXMesh *mesh, const float *vertex_signal, + UINT signal_dimension, UINT signal_stride, DWORD flags, + LPD3DXUVATLASCB cb, void *ctx, ID3DXBuffer **buffer); +HRESULT WINAPI D3DXComputeIMTFromSignal(ID3DXMesh *mesh, DWORD texture_idx, UINT signal_dimension, + float max_uv_distance, DWORD flags, LPD3DXIMTSIGNALCALLBACK signal_cb, void *signal_ctx, + LPD3DXUVATLASCB status_cb, void *status_ctx, ID3DXBuffer **buffer); +HRESULT WINAPI D3DXComputeIMTFromTexture(struct ID3DXMesh *mesh, struct IDirect3DTexture9 *texture, + DWORD texture_idx, DWORD options, LPD3DXUVATLASCB cb, void *ctx, struct ID3DXBuffer **out); +HRESULT WINAPI D3DXComputeNormals(ID3DXBaseMesh *mesh, const DWORD *adjacency); +HRESULT WINAPI D3DXComputeTangentFrameEx(ID3DXMesh *mesh_in, DWORD texture_in_semantic, DWORD texture_in_idx, + DWORD u_partial_out_semantic, DWORD u_partial_out_idx, DWORD v_partial_out_semantic, + DWORD v_partial_out_idx, DWORD normal_out_semantic, DWORD normal_out_idx, DWORD flags, + const DWORD *adjacency, float partial_edge_threshold, float singular_point_threshold, + float normal_edge_threshold, ID3DXMesh **mesh_out, ID3DXBuffer **buffer); +HRESULT WINAPI D3DXComputeTangent(ID3DXMesh *mesh, DWORD stage, DWORD tangent_idx, + DWORD binorm_idx, DWORD wrap, const DWORD *adjacency); +HRESULT WINAPI D3DXConvertMeshSubsetToSingleStrip(struct ID3DXBaseMesh *mesh_in, DWORD attribute_id, + DWORD ib_flags, struct IDirect3DIndexBuffer9 **index_buffer, DWORD *index_count); +HRESULT WINAPI D3DXConvertMeshSubsetToStrips(struct ID3DXBaseMesh *mesh_in, DWORD attribute_id, + DWORD ib_flags, struct IDirect3DIndexBuffer9 **index_buffer, DWORD *index_count, + struct ID3DXBuffer **strip_lengths, DWORD *strip_count); +HRESULT WINAPI D3DXDeclaratorFromFVF(DWORD, D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE]); +HRESULT WINAPI D3DXFVFFromDeclarator(const D3DVERTEXELEMENT9 *decl, DWORD *fvf); +HRESULT WINAPI D3DXGenerateOutputDecl(D3DVERTEXELEMENT9 *decl_out, const D3DVERTEXELEMENT9 *decl_in); +HRESULT WINAPI D3DXGeneratePMesh(ID3DXMesh *mesh, const DWORD *adjacency, + const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights, + DWORD min_value, DWORD flags, ID3DXPMesh **pmesh); +HRESULT WINAPI D3DXIntersect(ID3DXBaseMesh *mesh, const D3DXVECTOR3 *ray_position, const D3DXVECTOR3 *ray_direction, + BOOL *hit, DWORD *face_idx, float *u, float *v, float *distance, ID3DXBuffer **hits, DWORD *hit_count); +HRESULT WINAPI D3DXIntersectSubset(ID3DXBaseMesh *mesh, DWORD attribute_id, const D3DXVECTOR3 *ray_position, + const D3DXVECTOR3 *ray_direction, BOOL *hit, DWORD *face_idx, float *u, float *v, float *distance, + ID3DXBuffer **hits, DWORD *hit_count); +BOOL WINAPI D3DXIntersectTri(const D3DXVECTOR3 *vtx0, const D3DXVECTOR3 *vtx1, + const D3DXVECTOR3 *vtx2, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir, FLOAT *u, + FLOAT *v, FLOAT *dist); +HRESULT WINAPI D3DXOptimizeFaces(const void *indices, UINT face_count, + UINT vertex_count, BOOL idx_32bit, DWORD *face_remap); +HRESULT WINAPI D3DXOptimizeVertices(const void *indices, UINT face_count, + UINT vertex_count, BOOL idx_32bit, DWORD *vertex_remap); +HRESULT WINAPI D3DXRectPatchSize(const FLOAT *segment_count, DWORD *num_triangles, + DWORD *num_vertices); +HRESULT WINAPI D3DXSHPRTCompSuperCluster(UINT *cluster_ids, ID3DXMesh *scene, UINT max_cluster_count, + UINT cluster_count, UINT *scluster_ids, UINT *scluster_count); +HRESULT WINAPI D3DXSHPRTCompSplitMeshSC(UINT *cluster_idx, UINT vertex_count, UINT cluster_count, UINT *scluster_ids, + UINT scluster_count, void *index_buffer_in, BOOL ib_in_32bit, UINT face_count, ID3DXBuffer **index_buffer_out, + UINT *index_buffer_size, BOOL ib_out_32bit, ID3DXBuffer **face_remap, ID3DXBuffer **vertex_data, + UINT *vertex_data_length, UINT *sc_cluster_list, D3DXSHPRTSPLITMESHCLUSTERDATA *sc_data); +HRESULT WINAPI D3DXSimplifyMesh(ID3DXMesh *mesh_in, const DWORD *adjacency, + const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights, DWORD min_value, + DWORD flags, ID3DXMesh **mesh_out); +HRESULT WINAPI D3DXSplitMesh(ID3DXMesh *mesh_in, const DWORD *adjacency_in, const DWORD max_size, + const DWORD flags, DWORD *mesh_out_count, ID3DXBuffer **mesh_out, ID3DXBuffer **adjacency_out, + ID3DXBuffer **face_remap_out, ID3DXBuffer **vertex_remap_out); +HRESULT WINAPI D3DXTessellateNPatches(ID3DXMesh *mesh_in, const DWORD *adjacency_in, float segment_count, + BOOL quad_interp, ID3DXMesh **mesh_out, ID3DXBuffer **adjacency_out); +HRESULT WINAPI D3DXTessellateRectPatch(struct IDirect3DVertexBuffer9 *buffer, const float *segment_count, + const D3DVERTEXELEMENT9 *declaration, const D3DRECTPATCH_INFO *patch_info, struct ID3DXMesh *mesh); +HRESULT WINAPI D3DXTessellateTriPatch(struct IDirect3DVertexBuffer9 *buffer, const float *segment_count, + const D3DVERTEXELEMENT9 *declaration, const D3DTRIPATCH_INFO *patch_info, struct ID3DXMesh *mesh); +HRESULT WINAPI D3DXTriPatchSize(const FLOAT *segment_count, DWORD *num_triangles, + DWORD *num_vertices); +HRESULT WINAPI D3DXUVAtlasCreate(ID3DXMesh *mesh_in, UINT max_chart_count, float max_stretch_in, + UINT width, UINT height, float gutter, DWORD texture_idx, const DWORD *adjacency, const DWORD *false_edges, + const float *imt_array, LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, ID3DXMesh **mesh_out, + ID3DXBuffer **face_partitioning_out, ID3DXBuffer **vertex_remap_out, float *max_stretch_out, UINT *chart_count); +HRESULT WINAPI D3DXUVAtlasPack(ID3DXMesh *mesh, UINT width, UINT height, float gutter, DWORD texture_idx, + const DWORD *partition_result_adjacency, LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, + ID3DXBuffer *face_partitioning); +HRESULT WINAPI D3DXUVAtlasPartition(ID3DXMesh *mesh_in, UINT max_chart_count, float max_stretch_in, + DWORD texture_idx, const DWORD *adjacency, const DWORD *false_edges, const float *imt_array, + LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, ID3DXMesh **mesh_out, + ID3DXBuffer **face_partitioning_out, ID3DXBuffer **vertex_remap_out, ID3DXBuffer **adjacency_out, + float *max_stretch_out, UINT *chart_count); +HRESULT WINAPI D3DXValidMesh(ID3DXMesh *mesh, const DWORD *adjacency, ID3DXBuffer **errors); +HRESULT WINAPI D3DXValidPatchMesh(ID3DXPatchMesh *mesh, DWORD *degenerate_vertex_count, + DWORD *degenerate_patch_count, ID3DXBuffer **errors); +HRESULT WINAPI D3DXWeldVertices(ID3DXMesh *mesh, DWORD flags, const D3DXWELDEPSILONS *epsilons, + const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap_out, ID3DXBuffer **vertex_remap_out); + +#ifdef __cplusplus +} +#endif + +DEFINE_GUID(DXFILEOBJ_XSkinMeshHeader, 0x3cf169ce, 0xff7c, 0x44ab, 0x93, 0xc0, 0xf7, 0x8f, 0x62, 0xd1, 0x72, 0xe2); +DEFINE_GUID(DXFILEOBJ_VertexDuplicationIndices, 0xb8d65549, 0xd7c9, 0x4995, 0x89, 0xcf, 0x53, 0xa9, 0xa8, 0xb0, 0x31, 0xe3); +DEFINE_GUID(DXFILEOBJ_FaceAdjacency, 0xa64c844a, 0xe282, 0x4756, 0x8b, 0x80, 0x25, 0x0c, 0xde, 0x04, 0x39, 0x8c); +DEFINE_GUID(DXFILEOBJ_SkinWeights, 0x6f0d123b, 0xbad2, 0x4167, 0xa0, 0xd0, 0x80, 0x22, 0x4f, 0x25, 0xfa, 0xbb); +DEFINE_GUID(DXFILEOBJ_Patch, 0xa3eb5d44, 0xfc22, 0x429d, 0x9a, 0xfb, 0x32, 0x21, 0xcb, 0x97, 0x19, 0xa6); +DEFINE_GUID(DXFILEOBJ_PatchMesh, 0xd02c95cc, 0xedba, 0x4305, 0x9b, 0x5d, 0x18, 0x20, 0xd7, 0x70, 0x4b, 0xbf); +DEFINE_GUID(DXFILEOBJ_PatchMesh9, 0xb9ec94e1, 0xb9a6, 0x4251, 0xba, 0x18, 0x94, 0x89, 0x3f, 0x02, 0xc0, 0xea); +DEFINE_GUID(DXFILEOBJ_PMInfo, 0xb6c3e656, 0xec8b, 0x4b92, 0x9b, 0x62, 0x68, 0x16, 0x59, 0x52, 0x29, 0x47); +DEFINE_GUID(DXFILEOBJ_PMAttributeRange, 0x917e0427, 0xc61e, 0x4a14, 0x9c, 0x64, 0xaf, 0xe6, 0x5f, 0x9e, 0x98, 0x44); +DEFINE_GUID(DXFILEOBJ_PMVSplitRecord, 0x574ccc14, 0xf0b3, 0x4333, 0x82, 0x2d, 0x93, 0xe8, 0xa8, 0xa0, 0x8e, 0x4c); +DEFINE_GUID(DXFILEOBJ_FVFData, 0xb6e70a0e, 0x8ef9, 0x4e83, 0x94, 0xad, 0xec, 0xc8, 0xb0, 0xc0, 0x48, 0x97); +DEFINE_GUID(DXFILEOBJ_VertexElement, 0xf752461c, 0x1e23, 0x48f6, 0xb9, 0xf8, 0x83, 0x50, 0x85, 0x0f, 0x33, 0x6f); +DEFINE_GUID(DXFILEOBJ_DeclData, 0xbf22e553, 0x292c, 0x4781, 0x9f, 0xea, 0x62, 0xbd, 0x55, 0x4b, 0xdd, 0x93); +DEFINE_GUID(DXFILEOBJ_EffectFloats, 0xf1cfe2b3, 0x0de3, 0x4e28, 0xaf, 0xa1, 0x15, 0x5a, 0x75, 0x0a, 0x28, 0x2d); +DEFINE_GUID(DXFILEOBJ_EffectString, 0xd55b097e, 0xbdb6, 0x4c52, 0xb0, 0x3d, 0x60, 0x51, 0xc8, 0x9d, 0x0e, 0x42); +DEFINE_GUID(DXFILEOBJ_EffectDWord, 0x622c0ed0, 0x956e, 0x4da9, 0x90, 0x8a, 0x2a, 0xf9, 0x4f, 0x3c, 0xe7, 0x16); +DEFINE_GUID(DXFILEOBJ_EffectParamFloats, 0x3014b9a0, 0x62f5, 0x478c, 0x9b, 0x86, 0xe4, 0xac, 0x9f, 0x4e, 0x41, 0x8b); +DEFINE_GUID(DXFILEOBJ_EffectParamString, 0x1dbc4c88, 0x94c1, 0x46ee, 0x90, 0x76, 0x2c, 0x28, 0x81, 0x8c, 0x94, 0x81); +DEFINE_GUID(DXFILEOBJ_EffectParamDWord, 0xe13963bc, 0xae51, 0x4c5d, 0xb0, 0x0f, 0xcf, 0xa3, 0xa9, 0xd9, 0x7c, 0xe5); +DEFINE_GUID(DXFILEOBJ_EffectInstance, 0xe331f7e4, 0x0559, 0x4cc2, 0x8e, 0x99, 0x1c, 0xec, 0x16, 0x57, 0x92, 0x8f); +DEFINE_GUID(DXFILEOBJ_AnimTicksPerSecond, 0x9e415a43, 0x7ba6, 0x4a73, 0x87, 0x43, 0xb7, 0x3d, 0x47, 0xe8, 0x84, 0x76); +DEFINE_GUID(DXFILEOBJ_CompressedAnimationSet, 0x7f9b00b3, 0xf125, 0x4890, 0x87, 0x6e, 0x1c, 0x42, 0xbf, 0x69, 0x7c, 0x4d); + +#define XSKINEXP_TEMPLATES \ + "xof 0303txt 0032\ + template XSkinMeshHeader \ + { \ + <3CF169CE-FF7C-44ab-93C0-F78F62D172E2> \ + WORD nMaxSkinWeightsPerVertex; \ + WORD nMaxSkinWeightsPerFace; \ + WORD nBones; \ + } \ + template VertexDuplicationIndices \ + { \ + \ + DWORD nIndices; \ + DWORD nOriginalVertices; \ + array DWORD indices[nIndices]; \ + } \ + template FaceAdjacency \ + { \ + \ + DWORD nIndices; \ + array DWORD indices[nIndices]; \ + } \ + template SkinWeights \ + { \ + <6F0D123B-BAD2-4167-A0D0-80224F25FABB> \ + STRING transformNodeName; \ + DWORD nWeights; \ + array DWORD vertexIndices[nWeights]; \ + array float weights[nWeights]; \ + Matrix4x4 matrixOffset; \ + } \ + template Patch \ + { \ + \ + DWORD nControlIndices; \ + array DWORD controlIndices[nControlIndices]; \ + } \ + template PatchMesh \ + { \ + \ + DWORD nVertices; \ + array Vector vertices[nVertices]; \ + DWORD nPatches; \ + array Patch patches[nPatches]; \ + [ ... ] \ + } \ + template PatchMesh9 \ + { \ + \ + DWORD Type; \ + DWORD Degree; \ + DWORD Basis; \ + DWORD nVertices; \ + array Vector vertices[nVertices]; \ + DWORD nPatches; \ + array Patch patches[nPatches]; \ + [ ... ] \ + } template EffectFloats \ + { \ + \ + DWORD nFloats; \ + array float Floats[nFloats]; \ + } \ + template EffectString \ + { \ + \ + STRING Value; \ + } \ + template EffectDWord \ + { \ + <622C0ED0-956E-4da9-908A-2AF94F3CE716> \ + DWORD Value; \ + } template EffectParamFloats \ + { \ + <3014B9A0-62F5-478c-9B86-E4AC9F4E418B> \ + STRING ParamName; \ + DWORD nFloats; \ + array float Floats[nFloats]; \ + } template EffectParamString \ + { \ + <1DBC4C88-94C1-46ee-9076-2C28818C9481> \ + STRING ParamName; \ + STRING Value; \ + } \ + template EffectParamDWord \ + { \ + \ + STRING ParamName; \ + DWORD Value; \ + } \ + template EffectInstance \ + { \ + \ + STRING EffectFilename; \ + [ ... ] \ + } template AnimTicksPerSecond \ + { \ + <9E415A43-7BA6-4a73-8743-B73D47E88476> \ + DWORD AnimTicksPerSecond; \ + } \ + template CompressedAnimationSet \ + { \ + <7F9B00B3-F125-4890-876E-1C42BF697C4D> \ + DWORD CompressedBlockSize; \ + FLOAT TicksPerSec; \ + DWORD PlaybackType; \ + DWORD BufferLength; \ + array DWORD CompressedData[BufferLength]; \ + } " + +#define XEXTENSIONS_TEMPLATES \ + "xof 0303txt 0032\ + template FVFData \ + { \ + \ + DWORD dwFVF; \ + DWORD nDWords; \ + array DWORD data[nDWords]; \ + } \ + template VertexElement \ + { \ + \ + DWORD Type; \ + DWORD Method; \ + DWORD Usage; \ + DWORD UsageIndex; \ + } \ + template DeclData \ + { \ + \ + DWORD nElements; \ + array VertexElement Elements[nElements]; \ + DWORD nDWords; \ + array DWORD data[nDWords]; \ + } \ + template PMAttributeRange \ + { \ + <917E0427-C61E-4a14-9C64-AFE65F9E9844> \ + DWORD iFaceOffset; \ + DWORD nFacesMin; \ + DWORD nFacesMax; \ + DWORD iVertexOffset; \ + DWORD nVerticesMin; \ + DWORD nVerticesMax; \ + } \ + template PMVSplitRecord \ + { \ + <574CCC14-F0B3-4333-822D-93E8A8A08E4C> \ + DWORD iFaceCLW; \ + DWORD iVlrOffset; \ + DWORD iCode; \ + } \ + template PMInfo \ + { \ + \ + DWORD nAttributes; \ + array PMAttributeRange attributeRanges[nAttributes]; \ + DWORD nMaxValence; \ + DWORD nMinLogicalVertices; \ + DWORD nMaxLogicalVertices; \ + DWORD nVSplits; \ + array PMVSplitRecord splitRecords[nVSplits]; \ + DWORD nAttributeMispredicts; \ + array DWORD attributeMispredicts[nAttributeMispredicts]; \ + } " + +#endif /* __WINE_D3DX9MESH_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9shader.h b/WineFix/lib/d2d1/include/windows/d3dx9shader.h new file mode 100644 index 0000000..3d41e4b --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9shader.h @@ -0,0 +1,463 @@ +/* + * Copyright 2008 Luis Busquets + * Copyright 2014 Kai Tietz + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __D3DX9SHADER_H__ +#define __D3DX9SHADER_H__ + +#define D3DXSHADER_DEBUG 0x1 +#define D3DXSHADER_SKIPVALIDATION 0x2 +#define D3DXSHADER_SKIPOPTIMIZATION 0x4 +#define D3DXSHADER_PACKMATRIX_ROWMAJOR 0x8 +#define D3DXSHADER_PACKMATRIX_COLUMNMAJOR 0x10 +#define D3DXSHADER_PARTIALPRECISION 0x20 +#define D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT 0x40 +#define D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT 0x80 +#define D3DXSHADER_NO_PRESHADER 0x100 +#define D3DXSHADER_AVOID_FLOW_CONTROL 0x200 +#define D3DXSHADER_PREFER_FLOW_CONTROL 0x400 +#define D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY 0x1000 +#define D3DXSHADER_IEEE_STRICTNESS 0x2000 + +#define D3DXSHADER_OPTIMIZATION_LEVEL0 0x4000 +#define D3DXSHADER_OPTIMIZATION_LEVEL1 0x0 +#define D3DXSHADER_OPTIMIZATION_LEVEL2 0xC000 +#define D3DXSHADER_OPTIMIZATION_LEVEL3 0x8000 + +#define D3DXSHADER_USE_LEGACY_D3DX9_31_DLL 0x10000 + +#define D3DXCONSTTABLE_LARGEADDRESSAWARE 0x20000 + +typedef const char *D3DXHANDLE; +typedef D3DXHANDLE *LPD3DXHANDLE; + +typedef enum _D3DXREGISTER_SET +{ + D3DXRS_BOOL, + D3DXRS_INT4, + D3DXRS_FLOAT4, + D3DXRS_SAMPLER, + D3DXRS_FORCE_DWORD = 0x7fffffff +} D3DXREGISTER_SET, *LPD3DXREGISTER_SET; + +typedef enum D3DXPARAMETER_CLASS +{ + D3DXPC_SCALAR, + D3DXPC_VECTOR, + D3DXPC_MATRIX_ROWS, + D3DXPC_MATRIX_COLUMNS, + D3DXPC_OBJECT, + D3DXPC_STRUCT, + D3DXPC_FORCE_DWORD = 0x7fffffff, +} D3DXPARAMETER_CLASS, *LPD3DXPARAMETER_CLASS; + +typedef enum D3DXPARAMETER_TYPE +{ + D3DXPT_VOID, + D3DXPT_BOOL, + D3DXPT_INT, + D3DXPT_FLOAT, + D3DXPT_STRING, + D3DXPT_TEXTURE, + D3DXPT_TEXTURE1D, + D3DXPT_TEXTURE2D, + D3DXPT_TEXTURE3D, + D3DXPT_TEXTURECUBE, + D3DXPT_SAMPLER, + D3DXPT_SAMPLER1D, + D3DXPT_SAMPLER2D, + D3DXPT_SAMPLER3D, + D3DXPT_SAMPLERCUBE, + D3DXPT_PIXELSHADER, + D3DXPT_VERTEXSHADER, + D3DXPT_PIXELFRAGMENT, + D3DXPT_VERTEXFRAGMENT, + D3DXPT_UNSUPPORTED, + D3DXPT_FORCE_DWORD = 0x7fffffff, +} D3DXPARAMETER_TYPE, *LPD3DXPARAMETER_TYPE; + +typedef struct _D3DXCONSTANTTABLE_DESC +{ + const char *Creator; + DWORD Version; + UINT Constants; +} D3DXCONSTANTTABLE_DESC, *LPD3DXCONSTANTTABLE_DESC; + +typedef struct _D3DXCONSTANT_DESC +{ + const char *Name; + D3DXREGISTER_SET RegisterSet; + UINT RegisterIndex; + UINT RegisterCount; + D3DXPARAMETER_CLASS Class; + D3DXPARAMETER_TYPE Type; + UINT Rows; + UINT Columns; + UINT Elements; + UINT StructMembers; + UINT Bytes; + const void *DefaultValue; +} D3DXCONSTANT_DESC, *LPD3DXCONSTANT_DESC; + +#if D3DX_SDK_VERSION < 43 +DEFINE_GUID(IID_ID3DXConstantTable, 0x9dca3190, 0x38b9, 0x4fc3, 0x92, 0xe3, 0x39, 0xc6, 0xdd, 0xfb, 0x35, 0x8b); +#else +DEFINE_GUID(IID_ID3DXConstantTable, 0xab3c758f, 0x093e, 0x4356, 0xb7, 0x62, 0x4d, 0xb1, 0x8f, 0x1b, 0x3a, 0x01); +#endif + +#undef INTERFACE +#define INTERFACE ID3DXConstantTable + +DECLARE_INTERFACE_(ID3DXConstantTable, ID3DXBuffer) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + /*** ID3DXBuffer methods ***/ + STDMETHOD_(void *, GetBufferPointer)(THIS) PURE; + STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE; + /*** ID3DXConstantTable methods ***/ + STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE; + STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE; + STDMETHOD_(UINT, GetSamplerIndex)(THIS_ D3DXHANDLE hConstant) PURE; + STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE; + STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE constant, const char *name) PURE; + STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE; + STDMETHOD(SetDefaults)(THIS_ struct IDirect3DDevice9 *device) PURE; + STDMETHOD(SetValue)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const void *data, UINT data_size) PURE; + STDMETHOD(SetBool)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, BOOL value) PURE; + STDMETHOD(SetBoolArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const BOOL *values, UINT value_count) PURE; + STDMETHOD(SetInt)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, INT value) PURE; + STDMETHOD(SetIntArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const INT *values, UINT value_count) PURE; + STDMETHOD(SetFloat)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, float value) PURE; + STDMETHOD(SetFloatArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const float *values, UINT value_count) PURE; + STDMETHOD(SetVector)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXVECTOR4 *value) PURE; + STDMETHOD(SetVectorArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const D3DXVECTOR4 *values, UINT value_count) PURE; + STDMETHOD(SetMatrix)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *value) PURE; + STDMETHOD(SetMatrixArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const D3DXMATRIX *values, UINT value_count) PURE; + STDMETHOD(SetMatrixPointerArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const D3DXMATRIX **values, UINT value_count) PURE; + STDMETHOD(SetMatrixTranspose)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const D3DXMATRIX *value) PURE; + STDMETHOD(SetMatrixTransposeArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const D3DXMATRIX *values, UINT value_count) PURE; + STDMETHOD(SetMatrixTransposePointerArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, + const D3DXMATRIX **values, UINT value_count) PURE; +}; +#undef INTERFACE + +#if !defined(__cplusplus) || defined(CINTERFACE) +/*** IUnknown methods ***/ +#define ID3DXConstantTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ID3DXConstantTable_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ID3DXConstantTable_Release(p) (p)->lpVtbl->Release(p) +/*** ID3DXBuffer methods ***/ +#define ID3DXConstantTable_GetBufferPointer(p) (p)->lpVtbl->GetBufferPointer(p) +#define ID3DXConstantTable_GetBufferSize(p) (p)->lpVtbl->GetBufferSize(p) +/*** ID3DXConstantTable methods ***/ +#define ID3DXConstantTable_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define ID3DXConstantTable_GetConstantDesc(p,a,b,c) (p)->lpVtbl->GetConstantDesc(p,a,b,c) +#define ID3DXConstantTable_GetSamplerIndex(p,a) (p)->lpVtbl->GetSamplerIndex(p,a) +#define ID3DXConstantTable_GetConstant(p,a,b) (p)->lpVtbl->GetConstant(p,a,b) +#define ID3DXConstantTable_GetConstantByName(p,a,b) (p)->lpVtbl->GetConstantByName(p,a,b) +#define ID3DXConstantTable_GetConstantElement(p,a,b) (p)->lpVtbl->GetConstantElement(p,a,b) +#define ID3DXConstantTable_SetDefaults(p,a) (p)->lpVtbl->SetDefaults(p,a) +#define ID3DXConstantTable_SetValue(p,a,b,c,d) (p)->lpVtbl->SetValue(p,a,b,c,d) +#define ID3DXConstantTable_SetBool(p,a,b,c) (p)->lpVtbl->SetBool(p,a,b,c) +#define ID3DXConstantTable_SetBoolArray(p,a,b,c,d) (p)->lpVtbl->SetBoolArray(p,a,b,c,d) +#define ID3DXConstantTable_SetInt(p,a,b,c) (p)->lpVtbl->SetInt(p,a,b,c) +#define ID3DXConstantTable_SetIntArray(p,a,b,c,d) (p)->lpVtbl->SetIntArray(p,a,b,c,d) +#define ID3DXConstantTable_SetFloat(p,a,b,c) (p)->lpVtbl->SetFloat(p,a,b,c) +#define ID3DXConstantTable_SetFloatArray(p,a,b,c,d) (p)->lpVtbl->SetFloatArray(p,a,b,c,d) +#define ID3DXConstantTable_SetVector(p,a,b,c) (p)->lpVtbl->SetVector(p,a,b,c) +#define ID3DXConstantTable_SetVectorArray(p,a,b,c,d) (p)->lpVtbl->SetVectorArray(p,a,b,c,d) +#define ID3DXConstantTable_SetMatrix(p,a,b,c) (p)->lpVtbl->SetMatrix(p,a,b,c) +#define ID3DXConstantTable_SetMatrixArray(p,a,b,c,d) (p)->lpVtbl->SetMatrixArray(p,a,b,c,d) +#define ID3DXConstantTable_SetMatrixPointerArray(p,a,b,c,d) (p)->lpVtbl->SetMatrixPointerArray(p,a,b,c,d) +#define ID3DXConstantTable_SetMatrixTranspose(p,a,b,c) (p)->lpVtbl->SetMatrixTranspose(p,a,b,c) +#define ID3DXConstantTable_SetMatrixTransposeArray(p,a,b,c,d) (p)->lpVtbl->SetMatrixTransposeArray(p,a,b,c,d) +#define ID3DXConstantTable_SetMatrixTransposePointerArray(p,a,b,c,d) (p)->lpVtbl->SetMatrixTransposePointerArray(p,a,b,c,d) +#else +/*** IUnknown methods ***/ +#define ID3DXConstantTable_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define ID3DXConstantTable_AddRef(p) (p)->AddRef() +#define ID3DXConstantTable_Release(p) (p)->Release() +/*** ID3DXBuffer methods ***/ +#define ID3DXConstantTable_GetBufferPointer(p) (p)->GetBufferPointer() +#define ID3DXConstantTable_GetBufferSize(p) (p)->GetBufferSize() +/*** ID3DXConstantTable methods ***/ +#define ID3DXConstantTable_GetDesc(p,a) (p)->GetDesc(a) +#define ID3DXConstantTable_GetConstantDesc(p,a,b,c) (p)->GetConstantDesc(a,b,c) +#define ID3DXConstantTable_GetSamplerIndex(p,a) (p)->GetSamplerIndex(a) +#define ID3DXConstantTable_GetConstant(p,a,b) (p)->GetConstant(a,b) +#define ID3DXConstantTable_GetConstantByName(p,a,b) (p)->GetConstantByName(a,b) +#define ID3DXConstantTable_GetConstantElement(p,a,b) (p)->GetConstantElement(a,b) +#define ID3DXConstantTable_SetDefaults(p,a) (p)->SetDefaults(a) +#define ID3DXConstantTable_SetValue(p,a,b,c,d) (p)->SetValue(a,b,c,d) +#define ID3DXConstantTable_SetBool(p,a,b,c) (p)->SetBool(a,b,c) +#define ID3DXConstantTable_SetBoolArray(p,a,b,c,d) (p)->SetBoolArray(a,b,c,d) +#define ID3DXConstantTable_SetInt(p,a,b,c) (p)->SetInt(a,b,c) +#define ID3DXConstantTable_SetIntArray(p,a,b,c,d) (p)->SetIntArray(a,b,c,d) +#define ID3DXConstantTable_SetFloat(p,a,b,c) (p)->SetFloat(a,b,c) +#define ID3DXConstantTable_SetFloatArray(p,a,b,c,d) (p)->SetFloatArray(a,b,c,d) +#define ID3DXConstantTable_SetVector(p,a,b,c) (p)->SetVector(a,b,c) +#define ID3DXConstantTable_SetVectorArray(p,a,b,c,d) (p)->SetVectorArray(a,b,c,d) +#define ID3DXConstantTable_SetMatrix(p,a,b,c) (p)->SetMatrix(a,b,c) +#define ID3DXConstantTable_SetMatrixArray(p,a,b,c,d) (p)->SetMatrixArray(a,b,c,d) +#define ID3DXConstantTable_SetMatrixPointerArray(p,a,b,c,d) (p)->SetMatrixPointerArray(a,b,c,d) +#define ID3DXConstantTable_SetMatrixTranspose(p,a,b,c) (p)->SetMatrixTranspose(a,b,c) +#define ID3DXConstantTable_SetMatrixTransposeArray(p,a,b,c,d) (p)->SetMatrixTransposeArray(a,b,c,d) +#define ID3DXConstantTable_SetMatrixTransposePointerArray(p,a,b,c,d) (p)->SetMatrixTransposePointerArray(a,b,c,d) +#endif + +typedef struct ID3DXConstantTable *LPD3DXCONSTANTTABLE; + +typedef interface ID3DXTextureShader *LPD3DXTEXTURESHADER; + +DEFINE_GUID(IID_ID3DXTextureShader, 0x3e3d67f8, 0xaa7a, 0x405d, 0xa8, 0x57, 0xba, 0x1, 0xd4, 0x75, 0x84, 0x26); + +#define INTERFACE ID3DXTextureShader +DECLARE_INTERFACE_(ID3DXTextureShader, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + STDMETHOD(GetFunction)(THIS_ struct ID3DXBuffer **ppFunction) PURE; + STDMETHOD(GetConstantBuffer)(THIS_ struct ID3DXBuffer **ppConstantBuffer) PURE; + STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE; + STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE; + STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE; + STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, const char *pName) PURE; + STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE; + STDMETHOD(SetDefaults)(THIS) PURE; + STDMETHOD(SetValue)(THIS_ D3DXHANDLE hConstant, const void *pData, UINT Bytes) PURE; + STDMETHOD(SetBool)(THIS_ D3DXHANDLE hConstant, BOOL b) PURE; + STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE hConstant, const BOOL *pb, UINT Count) PURE; + STDMETHOD(SetInt)(THIS_ D3DXHANDLE hConstant, INT n) PURE; + STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE hConstant, const INT *pn, UINT Count) PURE; + STDMETHOD(SetFloat)(THIS_ D3DXHANDLE hConstant, FLOAT f) PURE; + STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE hConstant, const FLOAT *pf, UINT Count) PURE; + STDMETHOD(SetVector)(THIS_ D3DXHANDLE hConstant, const D3DXVECTOR4 *pVector) PURE; + STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE hConstant, const D3DXVECTOR4 *pVector, UINT Count) PURE; + STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix) PURE; + STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix, UINT Count) PURE; + STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX **ppMatrix, UINT Count) PURE; + STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix) PURE; + STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix, UINT Count) PURE; + STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX **ppMatrix, UINT Count) PURE; +}; +#undef INTERFACE + +typedef struct _D3DXMACRO +{ + const char *Name; + const char *Definition; +} D3DXMACRO, *LPD3DXMACRO; + +typedef struct _D3DXSEMANTIC { + UINT Usage; + UINT UsageIndex; +} D3DXSEMANTIC, *LPD3DXSEMANTIC; + +typedef enum _D3DXINCLUDE_TYPE +{ + D3DXINC_LOCAL, + D3DXINC_SYSTEM, + D3DXINC_FORCE_DWORD = 0x7fffffff, +} D3DXINCLUDE_TYPE, *LPD3DXINCLUDE_TYPE; + +#define INTERFACE ID3DXInclude + +DECLARE_INTERFACE(ID3DXInclude) +{ + STDMETHOD(Open)(THIS_ D3DXINCLUDE_TYPE include_type, const char *filename, + const void *parent_data, const void **data, UINT *bytes) PURE; + STDMETHOD(Close)(THIS_ const void *data) PURE; +}; +#undef INTERFACE + +#define ID3DXInclude_Open(p,a,b,c,d,e) (p)->lpVtbl->Open(p,a,b,c,d,e) +#define ID3DXInclude_Close(p,a) (p)->lpVtbl->Close(p,a) + +typedef struct ID3DXInclude *LPD3DXINCLUDE; + +typedef struct _D3DXFRAGMENT_DESC +{ + const char *Name; + DWORD Target; + +} D3DXFRAGMENT_DESC, *LPD3DXFRAGMENT_DESC; + + +DEFINE_GUID(IID_ID3DXFragmentLinker, 0x1a2c0cc2, 0xe5b6, 0x4ebc, 0x9e, 0x8d, 0x39, 0xe, 0x5, 0x78, 0x11, 0xb6); + +#define INTERFACE ID3DXFragmentLinker +DECLARE_INTERFACE_(ID3DXFragmentLinker, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **ppv) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE; + STDMETHOD_(UINT, GetNumberOfFragments)(THIS) PURE; + + STDMETHOD_(D3DXHANDLE, GetFragmentHandleByIndex)(THIS_ UINT index) PURE; + STDMETHOD_(D3DXHANDLE, GetFragmentHandleByName)(THIS_ const char *name) PURE; + STDMETHOD(GetFragmentDesc)(THIS_ D3DXHANDLE name, D3DXFRAGMENT_DESC *frag_desc) PURE; + + STDMETHOD(AddFragments)(THIS_ const DWORD *fragments) PURE; + + STDMETHOD(GetAllFragments)(THIS_ ID3DXBuffer **buffer) PURE; + STDMETHOD(GetFragment)(THIS_ D3DXHANDLE name, ID3DXBuffer **buffer) PURE; + + STDMETHOD(LinkShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragmenthandles, UINT fragments, ID3DXBuffer **buffer, ID3DXBuffer **errors) PURE; + STDMETHOD(LinkVertexShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragment_handles, UINT fragments, IDirect3DVertexShader9 **shader, ID3DXBuffer **errors) PURE; + STDMETHOD(LinkPixelShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragment_handles, UINT fragments, IDirect3DPixelShader9 **shader, ID3DXBuffer **errors) PURE; + + STDMETHOD(ClearCache)(THIS) PURE; +}; +#undef INTERFACE + +#ifdef __cplusplus +extern "C" { +#endif + +const char * WINAPI D3DXGetPixelShaderProfile(struct IDirect3DDevice9 *device); +UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code); +DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code); +const char * WINAPI D3DXGetVertexShaderProfile(struct IDirect3DDevice9 *device); +HRESULT WINAPI D3DXFindShaderComment(const DWORD *byte_code, DWORD fourcc, const void **data, UINT *size); +HRESULT WINAPI D3DXGetShaderSamplers(const DWORD *byte_code, const char **samplers, UINT *count); + +HRESULT WINAPI D3DXAssembleShaderFromFileA(const char *filename, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +HRESULT WINAPI D3DXAssembleShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +#define D3DXAssembleShaderFromFile WINELIB_NAME_AW(D3DXAssembleShaderFromFile) + +HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +#define D3DXAssembleShaderFromResource WINELIB_NAME_AW(D3DXAssembleShaderFromResource) + +HRESULT WINAPI D3DXAssembleShader(const char *data, UINT data_len, const D3DXMACRO *defines, + ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages); + +HRESULT WINAPI D3DXCompileShader(const char *src_data, UINT data_len, const D3DXMACRO *defines, + ID3DXInclude *include, const char *function_name, const char *profile, DWORD flags, + ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table); + +HRESULT WINAPI D3DXDisassembleShader(const DWORD *pShader, BOOL EnableColorCode, const char *pComments, struct ID3DXBuffer **ppDisassembly); + +HRESULT WINAPI D3DXCompileShaderFromFileA(const char *filename, const D3DXMACRO *defines, + ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, + ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table); +HRESULT WINAPI D3DXCompileShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines, + ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, + ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table); +#define D3DXCompileShaderFromFile WINELIB_NAME_AW(D3DXCompileShaderFromFile) + +HRESULT WINAPI D3DXCompileShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines, + ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, + ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table); +HRESULT WINAPI D3DXCompileShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines, + ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, + ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table); +#define D3DXCompileShaderFromResource WINELIB_NAME_AW(D3DXCompileShaderFromResource) + +HRESULT WINAPI D3DXPreprocessShader(const char *data, UINT data_len, const D3DXMACRO *defines, + ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages); + +HRESULT WINAPI D3DXPreprocessShaderFromFileA(const char *filename, const D3DXMACRO *defines, + ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +HRESULT WINAPI D3DXPreprocessShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines, + ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +#define D3DXPreprocessShaderFromFile WINELIB_NAME_AW(D3DXPreprocessShaderFromFile) + +HRESULT WINAPI D3DXPreprocessShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines, + ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +HRESULT WINAPI D3DXPreprocessShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines, + ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages); +#define D3DXPreprocessShaderFromResource WINELIB_NAME_AW(D3DXPreprocessShaderFromResource) + +HRESULT WINAPI D3DXGetShaderConstantTableEx(const DWORD *byte_code, DWORD flags, ID3DXConstantTable **constant_table); + +HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table); + +HRESULT WINAPI D3DXGetShaderInputSemantics(const DWORD *pFunction, D3DXSEMANTIC *pSemantics, UINT *pCount); +HRESULT WINAPI D3DXGetShaderOutputSemantics(const DWORD *pFunction, D3DXSEMANTIC *pSemantics, UINT *pCount); + +HRESULT WINAPI D3DXCreateTextureShader(const DWORD *pFunction, ID3DXTextureShader **ppTextureShader); + +HRESULT WINAPI D3DXCreateFragmentLinker(IDirect3DDevice9 *device, UINT size, ID3DXFragmentLinker **linker); +HRESULT WINAPI D3DXCreateFragmentLinkerEx(IDirect3DDevice9 *device, UINT size, DWORD flags, ID3DXFragmentLinker **linker); + +#ifdef __cplusplus +} +#endif + +typedef struct _D3DXSHADER_CONSTANTTABLE +{ + DWORD Size; + DWORD Creator; + DWORD Version; + DWORD Constants; + DWORD ConstantInfo; + DWORD Flags; + DWORD Target; +} D3DXSHADER_CONSTANTTABLE, *LPD3DXSHADER_CONSTANTTABLE; + +typedef struct _D3DXSHADER_CONSTANTINFO +{ + DWORD Name; + WORD RegisterSet; + WORD RegisterIndex; + WORD RegisterCount; + WORD Reserved; + DWORD TypeInfo; + DWORD DefaultValue; +} D3DXSHADER_CONSTANTINFO, *LPD3DXSHADER_CONSTANTINFO; + +typedef struct _D3DXSHADER_TYPEINFO +{ + WORD Class; + WORD Type; + WORD Rows; + WORD Columns; + WORD Elements; + WORD StructMembers; + DWORD StructMemberInfo; +} D3DXSHADER_TYPEINFO, *LPD3DXSHADER_TYPEINFO; + +typedef struct _D3DXSHADER_STRUCTMEMBERINFO +{ + DWORD Name; + DWORD TypeInfo; +} D3DXSHADER_STRUCTMEMBERINFO, *LPD3DXSHADER_STRUCTMEMBERINFO; + +#endif /* __D3DX9SHADER_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9shape.h b/WineFix/lib/d2d1/include/windows/d3dx9shape.h new file mode 100644 index 0000000..af49bb4 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9shape.h @@ -0,0 +1,50 @@ +/* + * Copyright 2010 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __D3DX9SHAPE_H__ +#define __D3DX9SHAPE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DXCreateBox(struct IDirect3DDevice9 *device, float width, float height, + float depth, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency); +HRESULT WINAPI D3DXCreateCylinder(struct IDirect3DDevice9 *device, float radius1, float radius2, + float length, UINT slices, UINT stacks, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency); +HRESULT WINAPI D3DXCreatePolygon(struct IDirect3DDevice9 *device, float length, UINT sides, struct ID3DXMesh **mesh, + ID3DXBuffer **adjacency); +HRESULT WINAPI D3DXCreateSphere(struct IDirect3DDevice9 *device, float radius, UINT slices, + UINT stacks, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency); +HRESULT WINAPI D3DXCreateTeapot(struct IDirect3DDevice9 *device, + struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency); +HRESULT WINAPI D3DXCreateTextA(struct IDirect3DDevice9 *device, HDC hdc, const char *text, float deviation, + float extrusion, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency, GLYPHMETRICSFLOAT *glyphmetrics); +HRESULT WINAPI D3DXCreateTextW(struct IDirect3DDevice9 *device, HDC hdc, const WCHAR *text, float deviation, + FLOAT extrusion, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency, GLYPHMETRICSFLOAT *glyphmetrics); +HRESULT WINAPI D3DXCreateTorus(struct IDirect3DDevice9 *device, + float innerradius, float outerradius, UINT sides, UINT rings, struct ID3DXMesh **mesh, ID3DXBuffer **adjacency); +#define D3DXCreateText WINELIB_NAME_AW(D3DXCreateText) + +#ifdef __cplusplus +} +#endif + +#endif /* __D3DX9SHAPE_H__ */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9tex.h b/WineFix/lib/d2d1/include/windows/d3dx9tex.h new file mode 100644 index 0000000..ae3fd8c --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9tex.h @@ -0,0 +1,354 @@ +/* + * Copyright (C) 2008 Tony Wasserka + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx9.h" + +#ifndef __WINE_D3DX9TEX_H +#define __WINE_D3DX9TEX_H + +/********************************************** + ***************** Definitions **************** + **********************************************/ +#define D3DX_FILTER_NONE 0x00000001 +#define D3DX_FILTER_POINT 0x00000002 +#define D3DX_FILTER_LINEAR 0x00000003 +#define D3DX_FILTER_TRIANGLE 0x00000004 +#define D3DX_FILTER_BOX 0x00000005 +#define D3DX_FILTER_MIRROR_U 0x00010000 +#define D3DX_FILTER_MIRROR_V 0x00020000 +#define D3DX_FILTER_MIRROR_W 0x00040000 +#define D3DX_FILTER_MIRROR 0x00070000 +#define D3DX_FILTER_DITHER 0x00080000 +#define D3DX_FILTER_DITHER_DIFFUSION 0x00100000 +#define D3DX_FILTER_SRGB_IN 0x00200000 +#define D3DX_FILTER_SRGB_OUT 0x00400000 +#define D3DX_FILTER_SRGB 0x00600000 + +#define D3DX_SKIP_DDS_MIP_LEVELS_MASK 0x1f +#define D3DX_SKIP_DDS_MIP_LEVELS_SHIFT 26 +#define D3DX_SKIP_DDS_MIP_LEVELS(l, f) ((((l) & D3DX_SKIP_DDS_MIP_LEVELS_MASK) \ + << D3DX_SKIP_DDS_MIP_LEVELS_SHIFT) | ((f) == D3DX_DEFAULT ? D3DX_FILTER_BOX : (f))) + +#define D3DX_NORMALMAP_MIRROR_U 0x00010000 +#define D3DX_NORMALMAP_MIRROR_V 0x00020000 +#define D3DX_NORMALMAP_MIRROR 0x00030000 +#define D3DX_NORMALMAP_INVERTSIGN 0x00080000 +#define D3DX_NORMALMAP_COMPUTE_OCCLUSION 0x00100000 + +#define D3DX_CHANNEL_RED 0x00000001 +#define D3DX_CHANNEL_BLUE 0x00000002 +#define D3DX_CHANNEL_GREEN 0x00000004 +#define D3DX_CHANNEL_ALPHA 0x00000008 +#define D3DX_CHANNEL_LUMINANCE 0x00000010 + +/********************************************** + ****************** Typedefs ****************** + **********************************************/ +typedef enum _D3DXIMAGE_FILEFORMAT +{ + D3DXIFF_BMP, + D3DXIFF_JPG, + D3DXIFF_TGA, + D3DXIFF_PNG, + D3DXIFF_DDS, + D3DXIFF_PPM, + D3DXIFF_DIB, + D3DXIFF_HDR, + D3DXIFF_PFM, + D3DXIFF_FORCE_DWORD = 0x7fffffff +} D3DXIMAGE_FILEFORMAT; + +typedef struct _D3DXIMAGE_INFO +{ + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + D3DFORMAT Format; + D3DRESOURCETYPE ResourceType; + D3DXIMAGE_FILEFORMAT ImageFileFormat; +} D3DXIMAGE_INFO; + +/********************************************** + ****************** Functions ***************** + **********************************************/ +/* Typedefs for callback functions */ +typedef void (WINAPI *LPD3DXFILL2D)(D3DXVECTOR4 *out, const D3DXVECTOR2 *texcoord, + const D3DXVECTOR2 *texelsize, void *data); +typedef void (WINAPI *LPD3DXFILL3D)(D3DXVECTOR4 *out, const D3DXVECTOR3 *texcoord, + const D3DXVECTOR3 *texelsize, void *data); + +#ifdef __cplusplus +extern "C" { +#endif + + +/* Image Information */ +HRESULT WINAPI D3DXGetImageInfoFromFileA(const char *file, D3DXIMAGE_INFO *info); +HRESULT WINAPI D3DXGetImageInfoFromFileW(const WCHAR *file, D3DXIMAGE_INFO *info); +#define D3DXGetImageInfoFromFile WINELIB_NAME_AW(D3DXGetImageInfoFromFile) + +HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, const char *resource, D3DXIMAGE_INFO *info); +HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, const WCHAR *resource, D3DXIMAGE_INFO *info); +#define D3DXGetImageInfoFromResource WINELIB_NAME_AW(D3DXGetImageInfoFromResource) + +HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT data_size, D3DXIMAGE_INFO *info); + + +/* Surface Loading/Saving */ +HRESULT WINAPI D3DXLoadSurfaceFromFileA(struct IDirect3DSurface9 *destsurface, + const PALETTEENTRY *destpalette, const RECT *destrect, const char *srcfile, + const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +HRESULT WINAPI D3DXLoadSurfaceFromFileW(struct IDirect3DSurface9 *destsurface, + const PALETTEENTRY *destpalette, const RECT *destrect, const WCHAR *srcfile, + const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +#define D3DXLoadSurfaceFromFile WINELIB_NAME_AW(D3DXLoadSurfaceFromFile) + +HRESULT WINAPI D3DXLoadSurfaceFromResourceA(struct IDirect3DSurface9 *destsurface, + const PALETTEENTRY *destpalette, const RECT *destrect, HMODULE srcmodule, const char *resource, + const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +HRESULT WINAPI D3DXLoadSurfaceFromResourceW(struct IDirect3DSurface9 *destsurface, + const PALETTEENTRY *destpalette, const RECT *destrect, HMODULE srcmodule, const WCHAR *resource, + const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +#define D3DXLoadSurfaceFromResource WINELIB_NAME_AW(D3DXLoadSurfaceFromResource) + +HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(struct IDirect3DSurface9 *destsurface, + const PALETTEENTRY *destpalette, const RECT *destrect, const void *srcdata, UINT srcdatasize, + const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); + +HRESULT WINAPI D3DXLoadSurfaceFromSurface(struct IDirect3DSurface9 *destsurface, + const PALETTEENTRY *destpalette, const RECT *destrect, struct IDirect3DSurface9 *srcsurface, + const PALETTEENTRY *srcpalette, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey); + +HRESULT WINAPI D3DXLoadSurfaceFromMemory(IDirect3DSurface9 *dst_surface, + const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_memory, + D3DFORMAT src_format, UINT src_pitch, const PALETTEENTRY *src_palette, const RECT *src_rect, + DWORD filter, D3DCOLOR color_key); + +HRESULT WINAPI D3DXSaveSurfaceToFileInMemory(struct ID3DXBuffer **destbuffer, + D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DSurface9 *srcsurface, + const PALETTEENTRY *srcpalette, const RECT *srcrect); + +HRESULT WINAPI D3DXSaveSurfaceToFileA(const char *destfile, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DSurface9 *srcsurface, const PALETTEENTRY *srcpalette, const RECT *srcrect); +HRESULT WINAPI D3DXSaveSurfaceToFileW(const WCHAR *destfile, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DSurface9 *srcsurface, const PALETTEENTRY *srcpalette, const RECT *srcrect); +#define D3DXSaveSurfaceToFile WINELIB_NAME_AW(D3DXSaveSurfaceToFile) + + +/* Volume Loading/Saving */ +HRESULT WINAPI D3DXLoadVolumeFromFileA(struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, const char *srcfile, + const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +HRESULT WINAPI D3DXLoadVolumeFromFileW( struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, const WCHAR *srcfile, + const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +#define D3DXLoadVolumeFromFile WINELIB_NAME_AW(D3DXLoadVolumeFromFile) + +HRESULT WINAPI D3DXLoadVolumeFromResourceA(struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, HMODULE srcmodule, const char *resource, + const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +HRESULT WINAPI D3DXLoadVolumeFromResourceW(struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, HMODULE srcmodule, const WCHAR *resource, + const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); +#define D3DXLoadVolumeFromResource WINELIB_NAME_AW(D3DXLoadVolumeFromResource) + +HRESULT WINAPI D3DXLoadVolumeFromFileInMemory(struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, const void *srcdata, UINT srcdatasize, + const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo); + +HRESULT WINAPI D3DXLoadVolumeFromVolume(struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, struct IDirect3DVolume9 *srcvolume, + const PALETTEENTRY *srcpalette, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey); + +HRESULT WINAPI D3DXLoadVolumeFromMemory(struct IDirect3DVolume9 *destvolume, + const PALETTEENTRY *destpalette, const D3DBOX *destbox, const void *srcmemory, + D3DFORMAT srcformat, UINT srcrowpitch, UINT srcslicepitch, const PALETTEENTRY *srcpalette, + const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey); + +HRESULT WINAPI D3DXSaveVolumeToFileInMemory(struct ID3DXBuffer **dst_buffer, D3DXIMAGE_FILEFORMAT dst_format, + struct IDirect3DVolume9 *src_volume, const PALETTEENTRY *src_palette, const D3DBOX *src_box); + +HRESULT WINAPI D3DXSaveVolumeToFileA(const char *destfile, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DVolume9 *srcvolume, const PALETTEENTRY *srcpalette, const D3DBOX *srcbox); +HRESULT WINAPI D3DXSaveVolumeToFileW(const WCHAR *destfile, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DVolume9 *srcvolume, const PALETTEENTRY *srcpalette, const D3DBOX *srcbox); +#define D3DXSaveVolumeToFile WINELIB_NAME_AW(D3DXSaveVolumeToFile) + + +/* Texture, cube texture and volume texture creation */ +HRESULT WINAPI D3DXCheckTextureRequirements(struct IDirect3DDevice9 *device, UINT *width, UINT *height, + UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool); +HRESULT WINAPI D3DXCheckCubeTextureRequirements(struct IDirect3DDevice9 *device, UINT *size, + UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool); +HRESULT WINAPI D3DXCheckVolumeTextureRequirements(struct IDirect3DDevice9 *device, UINT *width, UINT *height, + UINT *depth, UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool); + +HRESULT WINAPI D3DXCreateTexture(struct IDirect3DDevice9 *device, UINT width, UINT height, + UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateCubeTexture(struct IDirect3DDevice9 *device, UINT size, + UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateVolumeTexture(struct IDirect3DDevice9 *device, UINT width, UINT height, UINT depth, + UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DVolumeTexture9 **volume); + +HRESULT WINAPI D3DXCreateTextureFromFileA(struct IDirect3DDevice9 *device, + const char *srcfile, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateTextureFromFileW(struct IDirect3DDevice9 *device, + const WCHAR *srcfile, struct IDirect3DTexture9 **texture); +#define D3DXCreateTextureFromFile WINELIB_NAME_AW(D3DXCreateTextureFromFile) + +HRESULT WINAPI D3DXCreateCubeTextureFromFileA(struct IDirect3DDevice9 *device, + const char *srcfile, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateCubeTextureFromFileW(struct IDirect3DDevice9 *device, + const WCHAR *srcfile, struct IDirect3DCubeTexture9 **cube); +#define D3DXCreateCubeTextureFromFile WINELIB_NAME_AW(D3DXCreateCubeTextureFromFile) + +HRESULT WINAPI D3DXCreateVolumeTextureFromFileA(struct IDirect3DDevice9 *device, + const char *srcfile, struct IDirect3DVolumeTexture9 **volume); +HRESULT WINAPI D3DXCreateVolumeTextureFromFileW(struct IDirect3DDevice9 *device, + const WCHAR *srcfile, struct IDirect3DVolumeTexture9 **volume); +#define D3DXCreateVolumeTextureFromFile WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFile) + +HRESULT WINAPI D3DXCreateTextureFromResourceA(struct IDirect3DDevice9 *device, + HMODULE srcmodule, const char *resource, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateTextureFromResourceW(struct IDirect3DDevice9 *device, + HMODULE srcmodule, const WCHAR *resource, struct IDirect3DTexture9 **texture); +#define D3DXCreateTextureFromResource WINELIB_NAME_AW(D3DXCreateTextureFromResource) + +HRESULT WINAPI D3DXCreateCubeTextureFromResourceA(struct IDirect3DDevice9 *device, + HMODULE srcmodule, const char *resource, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateCubeTextureFromResourceW(struct IDirect3DDevice9 *device, + HMODULE srcmodule, const WCHAR *resource, struct IDirect3DCubeTexture9 **cube); +#define D3DXCreateCubeTextureFromResource WINELIB_NAME_AW(D3DXCreateCubeTextureFromResource) + +HRESULT WINAPI D3DXCreateVolumeTextureFromResourceA(struct IDirect3DDevice9 *device, + HMODULE srcmodule, const char *resource, struct IDirect3DVolumeTexture9 **volume); +HRESULT WINAPI D3DXCreateVolumeTextureFromResourceW(struct IDirect3DDevice9 *device, + HMODULE srcmodule, const WCHAR *resource, struct IDirect3DVolumeTexture9 **volume); +#define D3DXCreateVolumeTextureFromResource WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResource) + +HRESULT WINAPI D3DXCreateTextureFromFileExA(struct IDirect3DDevice9 *device, const char *srcfile, + UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateTextureFromFileExW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, + UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DTexture9 **texture); +#define D3DXCreateTextureFromFileEx WINELIB_NAME_AW(D3DXCreateTextureFromFileEx) + +HRESULT WINAPI D3DXCreateCubeTextureFromFileExA(struct IDirect3DDevice9 *device, const char *srcfile, + UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateCubeTextureFromFileExW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, + UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube); +#define D3DXCreateCubeTextureFromFileEx WINELIB_NAME_AW(D3DXCreateCubeTextureFromFileEx) + +HRESULT WINAPI D3DXCreateVolumeTextureFromFileExA(struct IDirect3DDevice9 *device, const char *srcfile, + UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume); +HRESULT WINAPI D3DXCreateVolumeTextureFromFileExW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, + UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume); +#define D3DXCreateVolumeTextureFromFileEx WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFileEx) + +HRESULT WINAPI D3DXCreateTextureFromResourceExA(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const char *resource, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateTextureFromResourceExW(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const WCHAR *resource, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DTexture9 **texture); +#define D3DXCreateTextureFromResourceEx WINELIB_NAME_AW(D3DXCreateTextureFromResourceEx) + +HRESULT WINAPI D3DXCreateCubeTextureFromResourceExA(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const char *resource, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateCubeTextureFromResourceExW(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const WCHAR *resource, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube); +#define D3DXCreateCubeTextureFromResourceEx WINELIB_NAME_AW(D3DXCreateCubeTextureFromResourceEx) + +HRESULT WINAPI D3DXCreateVolumeTextureFromResourceExA(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const char *resource, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume); +HRESULT WINAPI D3DXCreateVolumeTextureFromResourceExW(struct IDirect3DDevice9 *device, HMODULE srcmodule, + const WCHAR *resource, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume); +#define D3DXCreateVolumeTextureFromResourceEx WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResourceEx) + +HRESULT WINAPI D3DXCreateTextureFromFileInMemory(struct IDirect3DDevice9 *device, + const void *srcdata, UINT srcdatasize, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemory(struct IDirect3DDevice9 *device, + const void *srcdata, UINT srcdatasize, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemory(struct IDirect3DDevice9 *device, + const void *srcdata, UINT srcdatasize, struct IDirect3DVolumeTexture9 **volume); + +HRESULT WINAPI D3DXCreateTextureFromFileInMemoryEx(struct IDirect3DDevice9 *device, const void *srcdata, + UINT srcdatasize, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DTexture9 **texture); +HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemoryEx(struct IDirect3DDevice9 *device, const void *srcdata, + UINT srcdatasize, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube); +HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemoryEx(struct IDirect3DDevice9 *device, const void *srcdata, + UINT srcdatasize, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, + PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume); + +HRESULT WINAPI D3DXSaveTextureToFileInMemory(struct ID3DXBuffer **destbuffer, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DBaseTexture9 *srctexture, const PALETTEENTRY *srcpalette); +HRESULT WINAPI D3DXSaveTextureToFileA(const char *destfile, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DBaseTexture9 *srctexture, const PALETTEENTRY *srcpalette); +HRESULT WINAPI D3DXSaveTextureToFileW(const WCHAR *destfile, D3DXIMAGE_FILEFORMAT destformat, + struct IDirect3DBaseTexture9 *srctexture, const PALETTEENTRY *srcpalette); +#define D3DXSaveTextureToFile WINELIB_NAME_AW(D3DXSaveTextureToFile) + +/* Other functions */ +HRESULT WINAPI D3DXFilterTexture(struct IDirect3DBaseTexture9 *texture, + const PALETTEENTRY *palette, UINT srclevel, DWORD filter); +#define D3DXFilterCubeTexture D3DXFilterTexture +#define D3DXFilterVolumeTexture D3DXFilterTexture + +HRESULT WINAPI D3DXFillTexture(struct IDirect3DTexture9 *texture, LPD3DXFILL2D function, void *data); +HRESULT WINAPI D3DXFillCubeTexture(struct IDirect3DCubeTexture9 *cube, LPD3DXFILL3D function, void *data); +HRESULT WINAPI D3DXFillVolumeTexture(struct IDirect3DVolumeTexture9 *volume, LPD3DXFILL3D function, void *data); + +HRESULT WINAPI D3DXFillTextureTX(struct IDirect3DTexture9 *texture, ID3DXTextureShader *texture_shader); +HRESULT WINAPI D3DXFillCubeTextureTX(struct IDirect3DCubeTexture9 *cube, ID3DXTextureShader *texture_shader); +HRESULT WINAPI D3DXFillVolumeTextureTX(struct IDirect3DVolumeTexture9 *volume, ID3DXTextureShader *texture_shader); + +HRESULT WINAPI D3DXComputeNormalMap(IDirect3DTexture9 *texture, IDirect3DTexture9 *srctexture, + const PALETTEENTRY *srcpalette, DWORD flags, DWORD channel, float amplitude); + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_D3DX9TEX_H */ diff --git a/WineFix/lib/d2d1/include/windows/d3dx9xof.h b/WineFix/lib/d2d1/include/windows/d3dx9xof.h new file mode 100644 index 0000000..227f3a5 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/d3dx9xof.h @@ -0,0 +1,186 @@ +/* + * Copyright 2011 Dylan Smith + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DX9XOF_H +#define __WINE_D3DX9XOF_H + +#include "d3dx9.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef DWORD D3DXF_FILEFORMAT; +#define D3DXF_FILEFORMAT_BINARY 0 +#define D3DXF_FILEFORMAT_TEXT 1 +#define D3DXF_FILEFORMAT_COMPRESSED 2 + +typedef DWORD D3DXF_FILESAVEOPTIONS; +#define D3DXF_FILESAVE_TOFILE 0x00 +#define D3DXF_FILESAVE_TOWFILE 0x01 + +typedef DWORD D3DXF_FILELOADOPTIONS; +#define D3DXF_FILELOAD_FROMFILE 0x00 +#define D3DXF_FILELOAD_FROMWFILE 0x01 +#define D3DXF_FILELOAD_FROMRESOURCE 0x02 +#define D3DXF_FILELOAD_FROMMEMORY 0x03 + +typedef struct _D3DXF_FILELOADRESOURCE +{ + HMODULE hModule; + const char *lpName; + const char *lpType; +} D3DXF_FILELOADRESOURCE; + +typedef struct _D3DXF_FILELOADMEMORY +{ + const void *lpMemory; + SIZE_T dSize; +} D3DXF_FILELOADMEMORY; + + +#ifndef _NO_COM +DEFINE_GUID(IID_ID3DXFile, 0xcef08cf9, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01); +DEFINE_GUID(IID_ID3DXFileSaveObject, 0xcef08cfa, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01); +DEFINE_GUID(IID_ID3DXFileSaveData, 0xcef08cfb, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01); +DEFINE_GUID(IID_ID3DXFileEnumObject, 0xcef08cfc, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01); +DEFINE_GUID(IID_ID3DXFileData, 0xcef08cfd, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01); +#endif /* _NO_COM */ + +typedef interface ID3DXFile *LPD3DXFILE, **LPLPD3DXFILE; +typedef interface ID3DXFileSaveObject *LPD3DXFILESAVEOBJECT, **LPLPD3DXFILESAVEOBJECT; +typedef interface ID3DXFileSaveData *LPD3DXFILESAVEDATA, **LPLPD3DXFILESAVEDATA; +typedef interface ID3DXFileEnumObject *LPD3DXFILEENUMOBJECT, **LPLPD3DXFILEENUMOBJECT; +typedef interface ID3DXFileData *LPD3DXFILEDATA, **LPLPD3DXFILEDATA; + +STDAPI D3DXFileCreate(struct ID3DXFile **file); + +#define INTERFACE ID3DXFile +DECLARE_INTERFACE_IID_(ID3DXFile,IUnknown,"cef08cf9-7b4f-4429-9624-2a690a933201") +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** ID3DXFile methods ***/ + STDMETHOD(CreateEnumObject)(THIS_ const void *src, D3DXF_FILELOADOPTIONS type, + struct ID3DXFileEnumObject **enum_obj) PURE; + STDMETHOD(CreateSaveObject)(THIS_ const void *data, D3DXF_FILESAVEOPTIONS flags, + D3DXF_FILEFORMAT format, struct ID3DXFileSaveObject **save_obj) PURE; + STDMETHOD(RegisterTemplates)(THIS_ const void *data, SIZE_T data_size) PURE; + STDMETHOD(RegisterEnumTemplates)(THIS_ struct ID3DXFileEnumObject *enum_obj) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXFileSaveObject +DECLARE_INTERFACE_IID_(ID3DXFileSaveObject,IUnknown,"cef08cfa-7b4f-4429-9624-2a690a933201") +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** ID3DXFileSaveObject methods ***/ + STDMETHOD(GetFile)(THIS_ ID3DXFile **file) PURE; + STDMETHOD(AddDataObject)(THIS_ REFGUID template_guid, const char *name, const GUID *guid, + SIZE_T data_size, const void *data, struct ID3DXFileSaveData **obj) PURE; + STDMETHOD(Save)(THIS) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXFileSaveData +DECLARE_INTERFACE_IID_(ID3DXFileSaveData,IUnknown,"cef08cfb-7b4f-4429-9624-2a690a933201") +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** ID3DXFileSaveObject methods ***/ + STDMETHOD(GetSave)(THIS_ ID3DXFileSaveObject **save_obj) PURE; + STDMETHOD(GetName)(THIS_ char *name, SIZE_T *size) PURE; + STDMETHOD(GetId)(THIS_ LPGUID) PURE; + STDMETHOD(GetType)(THIS_ GUID*) PURE; + STDMETHOD(AddDataObject)(THIS_ REFGUID template_guid, const char *name, const GUID *guid, + SIZE_T data_size, const void *data, ID3DXFileSaveData **obj) PURE; + STDMETHOD(AddDataReference)(THIS_ const char *name, const GUID *id) PURE; +}; +#undef INTERFACE + + +#define INTERFACE ID3DXFileEnumObject +DECLARE_INTERFACE_IID_(ID3DXFileEnumObject,IUnknown,"cef08cfc-7b4f-4429-9624-2a690a933201") +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** ID3DXFileEnumObject methods ***/ + STDMETHOD(GetFile)(THIS_ ID3DXFile **file) PURE; + STDMETHOD(GetChildren)(THIS_ SIZE_T*) PURE; + STDMETHOD(GetChild)(THIS_ SIZE_T id, struct ID3DXFileData **child) PURE; + STDMETHOD(GetDataObjectById)(THIS_ REFGUID guid, struct ID3DXFileData **obj) PURE; + STDMETHOD(GetDataObjectByName)(THIS_ const char *name, struct ID3DXFileData **obj) PURE; +}; +#undef INTERFACE + +#define INTERFACE ID3DXFileData +DECLARE_INTERFACE_IID_(ID3DXFileData,IUnknown,"cef08cfd-7b4f-4429-9624-2a690a933201") +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + /*** ID3DXFileData methods ***/ + STDMETHOD(GetEnum)(THIS_ ID3DXFileEnumObject **enum_obj) PURE; + STDMETHOD(GetName)(THIS_ char *name, SIZE_T *size) PURE; + STDMETHOD(GetId)(THIS_ LPGUID) PURE; + STDMETHOD(Lock)(THIS_ SIZE_T *data_size, const void **data) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(GetType)(THIS_ GUID*) PURE; + STDMETHOD_(BOOL,IsReference)(THIS) PURE; + STDMETHOD(GetChildren)(THIS_ SIZE_T*) PURE; + STDMETHOD(GetChild)(THIS_ SIZE_T id, ID3DXFileData **child) PURE; +}; +#undef INTERFACE + +/* D3DX File errors */ +#define _FACD3DXF 0x876 + +#define D3DXFERR_BADOBJECT MAKE_HRESULT(1,_FACD3DXF,900) +#define D3DXFERR_BADVALUE MAKE_HRESULT(1,_FACD3DXF,901) +#define D3DXFERR_BADTYPE MAKE_HRESULT(1,_FACD3DXF,902) +#define D3DXFERR_NOTFOUND MAKE_HRESULT(1,_FACD3DXF,903) +#define D3DXFERR_NOTDONEYET MAKE_HRESULT(1,_FACD3DXF,904) +#define D3DXFERR_FILENOTFOUND MAKE_HRESULT(1,_FACD3DXF,905) +#define D3DXFERR_RESOURCENOTFOUND MAKE_HRESULT(1,_FACD3DXF,906) +#define D3DXFERR_BADRESOURCE MAKE_HRESULT(1,_FACD3DXF,907) +#define D3DXFERR_BADFILETYPE MAKE_HRESULT(1,_FACD3DXF,908) +#define D3DXFERR_BADFILEVERSION MAKE_HRESULT(1,_FACD3DXF,909) +#define D3DXFERR_BADFILEFLOATSIZE MAKE_HRESULT(1,_FACD3DXF,910) +#define D3DXFERR_BADFILE MAKE_HRESULT(1,_FACD3DXF,911) +#define D3DXFERR_PARSEERROR MAKE_HRESULT(1,_FACD3DXF,912) +#define D3DXFERR_BADARRAYSIZE MAKE_HRESULT(1,_FACD3DXF,913) +#define D3DXFERR_BADDATAREFERENCE MAKE_HRESULT(1,_FACD3DXF,914) +#define D3DXFERR_NOMOREOBJECTS MAKE_HRESULT(1,_FACD3DXF,915) +#define D3DXFERR_NOMOREDATA MAKE_HRESULT(1,_FACD3DXF,916) +#define D3DXFERR_BADCACHEFILE MAKE_HRESULT(1,_FACD3DXF,917) + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_D3DX9XOF_H */ diff --git a/WineFix/lib/d2d1/include/windows/dcommon.idl b/WineFix/lib/d2d1/include/windows/dcommon.idl new file mode 100644 index 0000000..d5a18bd --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dcommon.idl @@ -0,0 +1,215 @@ +/* + * Copyright 2012 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgiformat.idl"; + +cpp_quote("#if 0") +typedef struct +{ + long x, y; +} POINT; + +typedef struct +{ + long left, top, right, bottom; +} RECT; + +typedef unsigned int UINT32; +cpp_quote("#endif") + +typedef enum DWRITE_MEASURING_MODE +{ + DWRITE_MEASURING_MODE_NATURAL, + DWRITE_MEASURING_MODE_GDI_CLASSIC, + DWRITE_MEASURING_MODE_GDI_NATURAL +} DWRITE_MEASURING_MODE; + +typedef enum DWRITE_GLYPH_IMAGE_FORMATS +{ + DWRITE_GLYPH_IMAGE_FORMATS_NONE = 0, + DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE = 1 << 0, + DWRITE_GLYPH_IMAGE_FORMATS_CFF = 1 << 1, + DWRITE_GLYPH_IMAGE_FORMATS_COLR = 1 << 2, + DWRITE_GLYPH_IMAGE_FORMATS_SVG = 1 << 3, + DWRITE_GLYPH_IMAGE_FORMATS_PNG = 1 << 4, + DWRITE_GLYPH_IMAGE_FORMATS_JPEG = 1 << 5, + DWRITE_GLYPH_IMAGE_FORMATS_TIFF = 1 << 6, + DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8 = 1 << 7 +} DWRITE_GLYPH_IMAGE_FORMATS; + +typedef enum D2D1_ALPHA_MODE +{ + D2D1_ALPHA_MODE_UNKNOWN = 0, + D2D1_ALPHA_MODE_PREMULTIPLIED = 1, + D2D1_ALPHA_MODE_STRAIGHT = 2, + D2D1_ALPHA_MODE_IGNORE = 3, + D2D1_ALPHA_MODE_FORCE_DWORD = 0xffffffff +} D2D1_ALPHA_MODE; + +typedef struct D2D1_PIXEL_FORMAT +{ + DXGI_FORMAT format; + D2D1_ALPHA_MODE alphaMode; +} D2D1_PIXEL_FORMAT; + +typedef struct D2D_POINT_2F +{ + float x; + float y; +} D2D_POINT_2F, D2D1_POINT_2F; + +typedef POINT D2D_POINT_2L, D2D1_POINT_2L; + +typedef struct D2D_VECTOR_2F +{ + float x; + float y; +} D2D_VECTOR_2F; + +typedef struct D2D_VECTOR_3F +{ + float x; + float y; + float z; +} D2D_VECTOR_3F; + +typedef struct D2D_VECTOR_4F +{ + float x; + float y; + float z; + float w; +} D2D_VECTOR_4F; + +typedef RECT D2D_RECT_L, D2D1_RECT_L; + +typedef struct D2D_SIZE_U +{ + UINT32 width; + UINT32 height; +} D2D_SIZE_U, D2D1_SIZE_U; + +typedef struct D2D_SIZE_F +{ + float width; + float height; +} D2D_SIZE_F, D2D1_SIZE_F; + +typedef struct D2D_RECT_F +{ + float left; + float top; + float right; + float bottom; +} D2D_RECT_F, D2D1_RECT_F; + +typedef struct D2D_RECT_U +{ + UINT32 left; + UINT32 top; + UINT32 right; + UINT32 bottom; +} D2D_RECT_U, D2D1_RECT_U; + +typedef struct D2D_POINT_2U +{ + UINT32 x; + UINT32 y; +} D2D_POINT_2U, D2D1_POINT_2U; + +typedef struct D2D_COLOR_F +{ + float r; + float g; + float b; + float a; +} D2D_COLOR_F, D2D1_COLOR_F; + +typedef struct D2D_MATRIX_3X2_F +{ + union + { + struct + { + float m11; + float m12; + float m21; + float m22; + float dx; + float dy; + }; + + struct + { + float _11, _12; + float _21, _22; + float _31, _32; + }; + + float m[3][2]; + }; +} D2D_MATRIX_3X2_F; + +typedef struct D2D_MATRIX_4X3_F +{ + union + { + struct + { + float _11, _12, _13; + float _21, _22, _23; + float _31, _32, _33; + float _41, _42, _43; + }; + + float m[4][3]; + }; +} D2D_MATRIX_4X3_F; + +typedef struct D2D_MATRIX_4X4_F +{ + union + { + struct + { + float _11, _12, _13, _14; + float _21, _22, _23, _24; + float _31, _32, _33, _34; + float _41, _42, _43, _44; + }; + + float m[4][4]; + }; +} D2D_MATRIX_4X4_F; + +typedef struct D2D_MATRIX_5X4_F +{ + union + { + struct + { + float _11, _12, _13, _14; + float _21, _22, _23, _24; + float _31, _32, _33, _34; + float _41, _42, _43, _44; + float _51, _52, _53, _54; + }; + + float m[5][4]; + }; +} D2D_MATRIX_5X4_F; diff --git a/WineFix/lib/d2d1/include/windows/dwrite.idl b/WineFix/lib/d2d1/include/windows/dwrite.idl new file mode 100644 index 0000000..c35d0a7 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dwrite.idl @@ -0,0 +1,1674 @@ +/* + * Copyright 2012 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "unknwn.idl"; +import "dcommon.idl"; + +interface IDWriteFactory; +interface IDWriteFontCollection; +interface IDWriteFontFamily; +interface IDWriteFontFace; +interface IDWriteInlineObject; + +interface ID2D1SimplifiedGeometrySink; +typedef ID2D1SimplifiedGeometrySink IDWriteGeometrySink; + +cpp_quote("#ifndef _WINDEF_") +/* already defined in windef.h but needed for WIDL */ +typedef void *HMONITOR; +cpp_quote("#endif /* _WINDEF_ */") + +cpp_quote("#ifdef WINE_NO_UNICODE_MACROS") +cpp_quote("#undef GetGlyphIndices") +cpp_quote("#endif") + +typedef enum DWRITE_FACTORY_TYPE +{ + DWRITE_FACTORY_TYPE_SHARED, + DWRITE_FACTORY_TYPE_ISOLATED +} DWRITE_FACTORY_TYPE; + +typedef enum DWRITE_FONT_FILE_TYPE +{ + DWRITE_FONT_FILE_TYPE_UNKNOWN, + DWRITE_FONT_FILE_TYPE_CFF, + DWRITE_FONT_FILE_TYPE_TRUETYPE, + DWRITE_FONT_FILE_TYPE_OPENTYPE_COLLECTION, + DWRITE_FONT_FILE_TYPE_TYPE1_PFM, + DWRITE_FONT_FILE_TYPE_TYPE1_PFB, + DWRITE_FONT_FILE_TYPE_VECTOR, + DWRITE_FONT_FILE_TYPE_BITMAP, + DWRITE_FONT_FILE_TYPE_TRUETYPE_COLLECTION = DWRITE_FONT_FILE_TYPE_OPENTYPE_COLLECTION +} DWRITE_FONT_FILE_TYPE; + +typedef enum DWRITE_FONT_FACE_TYPE +{ + DWRITE_FONT_FACE_TYPE_CFF, + DWRITE_FONT_FACE_TYPE_TRUETYPE, + DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION, + DWRITE_FONT_FACE_TYPE_TYPE1, + DWRITE_FONT_FACE_TYPE_VECTOR, + DWRITE_FONT_FACE_TYPE_BITMAP, + DWRITE_FONT_FACE_TYPE_UNKNOWN, + DWRITE_FONT_FACE_TYPE_RAW_CFF, + DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION = DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION +} DWRITE_FONT_FACE_TYPE; + +typedef enum DWRITE_FONT_WEIGHT +{ + DWRITE_FONT_WEIGHT_THIN = 100, + DWRITE_FONT_WEIGHT_EXTRA_LIGHT = 200, + DWRITE_FONT_WEIGHT_ULTRA_LIGHT = 200, + DWRITE_FONT_WEIGHT_LIGHT = 300, + DWRITE_FONT_WEIGHT_SEMI_LIGHT = 350, + DWRITE_FONT_WEIGHT_NORMAL = 400, + DWRITE_FONT_WEIGHT_REGULAR = 400, + DWRITE_FONT_WEIGHT_MEDIUM = 500, + DWRITE_FONT_WEIGHT_DEMI_BOLD = 600, + DWRITE_FONT_WEIGHT_SEMI_BOLD = 600, + DWRITE_FONT_WEIGHT_BOLD = 700, + DWRITE_FONT_WEIGHT_EXTRA_BOLD = 800, + DWRITE_FONT_WEIGHT_ULTRA_BOLD = 800, + DWRITE_FONT_WEIGHT_BLACK = 900, + DWRITE_FONT_WEIGHT_HEAVY = 900, + DWRITE_FONT_WEIGHT_EXTRA_BLACK = 950, + DWRITE_FONT_WEIGHT_ULTRA_BLACK = 950 +} DWRITE_FONT_WEIGHT; + +typedef enum DWRITE_FONT_STRETCH +{ + DWRITE_FONT_STRETCH_UNDEFINED = 0, + DWRITE_FONT_STRETCH_ULTRA_CONDENSED = 1, + DWRITE_FONT_STRETCH_EXTRA_CONDENSED = 2, + DWRITE_FONT_STRETCH_CONDENSED = 3, + DWRITE_FONT_STRETCH_SEMI_CONDENSED = 4, + DWRITE_FONT_STRETCH_NORMAL = 5, + DWRITE_FONT_STRETCH_MEDIUM = 5, + DWRITE_FONT_STRETCH_SEMI_EXPANDED = 6, + DWRITE_FONT_STRETCH_EXPANDED = 7, + DWRITE_FONT_STRETCH_EXTRA_EXPANDED = 8, + DWRITE_FONT_STRETCH_ULTRA_EXPANDED = 9 +} DWRITE_FONT_STRETCH; + +typedef enum DWRITE_FONT_STYLE +{ + DWRITE_FONT_STYLE_NORMAL, + DWRITE_FONT_STYLE_OBLIQUE, + DWRITE_FONT_STYLE_ITALIC +} DWRITE_FONT_STYLE; + +typedef enum DWRITE_INFORMATIONAL_STRING_ID +{ + DWRITE_INFORMATIONAL_STRING_NONE, + DWRITE_INFORMATIONAL_STRING_COPYRIGHT_NOTICE, + DWRITE_INFORMATIONAL_STRING_VERSION_STRINGS, + DWRITE_INFORMATIONAL_STRING_TRADEMARK, + DWRITE_INFORMATIONAL_STRING_MANUFACTURER, + DWRITE_INFORMATIONAL_STRING_DESIGNER, + DWRITE_INFORMATIONAL_STRING_DESIGNER_URL, + DWRITE_INFORMATIONAL_STRING_DESCRIPTION, + DWRITE_INFORMATIONAL_STRING_FONT_VENDOR_URL, + DWRITE_INFORMATIONAL_STRING_LICENSE_DESCRIPTION, + DWRITE_INFORMATIONAL_STRING_LICENSE_INFO_URL, + DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, + DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES, + DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_FAMILY_NAMES, + DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_SUBFAMILY_NAMES, + DWRITE_INFORMATIONAL_STRING_SAMPLE_TEXT, + DWRITE_INFORMATIONAL_STRING_FULL_NAME, + DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME, + DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME, + DWRITE_INFORMATIONAL_STRING_WEIGHT_STRETCH_STYLE_FAMILY_NAME, + DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG, + DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG, + DWRITE_INFORMATIONAL_STRING_PREFERRED_FAMILY_NAMES = DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_FAMILY_NAMES, + DWRITE_INFORMATIONAL_STRING_PREFERRED_SUBFAMILY_NAMES = DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_SUBFAMILY_NAMES, + DWRITE_INFORMATIONAL_STRING_WWS_FAMILY_NAME = DWRITE_INFORMATIONAL_STRING_WEIGHT_STRETCH_STYLE_FAMILY_NAME, +} DWRITE_INFORMATIONAL_STRING_ID; + +typedef enum DWRITE_FONT_SIMULATIONS +{ + DWRITE_FONT_SIMULATIONS_NONE, + DWRITE_FONT_SIMULATIONS_BOLD, + DWRITE_FONT_SIMULATIONS_OBLIQUE +} DWRITE_FONT_SIMULATIONS; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(DWRITE_FONT_SIMULATIONS);") + +typedef enum DWRITE_PIXEL_GEOMETRY +{ + DWRITE_PIXEL_GEOMETRY_FLAT, + DWRITE_PIXEL_GEOMETRY_RGB, + DWRITE_PIXEL_GEOMETRY_BGR +} DWRITE_PIXEL_GEOMETRY; + +typedef enum DWRITE_RENDERING_MODE +{ + DWRITE_RENDERING_MODE_DEFAULT, + DWRITE_RENDERING_MODE_ALIASED, + DWRITE_RENDERING_MODE_GDI_CLASSIC, + DWRITE_RENDERING_MODE_GDI_NATURAL, + DWRITE_RENDERING_MODE_NATURAL, + DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC, + DWRITE_RENDERING_MODE_OUTLINE, + DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC = DWRITE_RENDERING_MODE_GDI_CLASSIC, + DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL = DWRITE_RENDERING_MODE_GDI_NATURAL, + DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL = DWRITE_RENDERING_MODE_NATURAL, + DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC = DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC +} DWRITE_RENDERING_MODE; + +typedef enum DWRITE_TEXT_ALIGNMENT +{ + DWRITE_TEXT_ALIGNMENT_LEADING, + DWRITE_TEXT_ALIGNMENT_TRAILING, + DWRITE_TEXT_ALIGNMENT_CENTER, + DWRITE_TEXT_ALIGNMENT_JUSTIFIED +} DWRITE_TEXT_ALIGNMENT; + +typedef enum DWRITE_PARAGRAPH_ALIGNMENT +{ + DWRITE_PARAGRAPH_ALIGNMENT_NEAR, + DWRITE_PARAGRAPH_ALIGNMENT_FAR, + DWRITE_PARAGRAPH_ALIGNMENT_CENTER +} DWRITE_PARAGRAPH_ALIGNMENT; + +typedef enum DWRITE_WORD_WRAPPING +{ + DWRITE_WORD_WRAPPING_WRAP, + DWRITE_WORD_WRAPPING_NO_WRAP, + DWRITE_WORD_WRAPPING_EMERGENCY_BREAK, + DWRITE_WORD_WRAPPING_WHOLE_WORD, + DWRITE_WORD_WRAPPING_CHARACTER +} DWRITE_WORD_WRAPPING; + +typedef enum DWRITE_READING_DIRECTION +{ + DWRITE_READING_DIRECTION_LEFT_TO_RIGHT, + DWRITE_READING_DIRECTION_RIGHT_TO_LEFT, + DWRITE_READING_DIRECTION_TOP_TO_BOTTOM, + DWRITE_READING_DIRECTION_BOTTOM_TO_TOP +} DWRITE_READING_DIRECTION; + +typedef enum DWRITE_FLOW_DIRECTION +{ + DWRITE_FLOW_DIRECTION_TOP_TO_BOTTOM, + DWRITE_FLOW_DIRECTION_BOTTOM_TO_TOP, + DWRITE_FLOW_DIRECTION_LEFT_TO_RIGHT, + DWRITE_FLOW_DIRECTION_RIGHT_TO_LEFT +} DWRITE_FLOW_DIRECTION; + +typedef enum DWRITE_TRIMMING_GRANULARITY +{ + DWRITE_TRIMMING_GRANULARITY_NONE, + DWRITE_TRIMMING_GRANULARITY_CHARACTER, + DWRITE_TRIMMING_GRANULARITY_WORD +} DWRITE_TRIMMING_GRANULARITY; + +typedef enum DWRITE_BREAK_CONDITION +{ + DWRITE_BREAK_CONDITION_NEUTRAL, + DWRITE_BREAK_CONDITION_CAN_BREAK, + DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, + DWRITE_BREAK_CONDITION_MUST_BREAK +} DWRITE_BREAK_CONDITION; + +typedef enum DWRITE_LINE_SPACING_METHOD +{ + DWRITE_LINE_SPACING_METHOD_DEFAULT, + DWRITE_LINE_SPACING_METHOD_UNIFORM, + DWRITE_LINE_SPACING_METHOD_PROPORTIONAL +} DWRITE_LINE_SPACING_METHOD; + +cpp_quote("#define DWRITE_MAKE_OPENTYPE_TAG(a,b,c,d) ( \\") +cpp_quote(" ((UINT32)(UINT8)(d) << 24) | \\") +cpp_quote(" ((UINT32)(UINT8)(c) << 16) | \\") +cpp_quote(" ((UINT32)(UINT8)(b) << 8) | \\") +cpp_quote(" (UINT32)(UINT8)(a))") + +typedef enum DWRITE_FONT_FEATURE_TAG +{ + DWRITE_FONT_FEATURE_TAG_ALTERNATIVE_FRACTIONS = 0x63726661, /* 'afrc' */ + DWRITE_FONT_FEATURE_TAG_PETITE_CAPITALS_FROM_CAPITALS = 0x63703263, /* 'c2pc' */ + DWRITE_FONT_FEATURE_TAG_SMALL_CAPITALS_FROM_CAPITALS = 0x63733263, /* 'c2sc' */ + DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_ALTERNATES = 0x746c6163, /* 'calt' */ + DWRITE_FONT_FEATURE_TAG_CASE_SENSITIVE_FORMS = 0x65736163, /* 'case' */ + DWRITE_FONT_FEATURE_TAG_GLYPH_COMPOSITION_DECOMPOSITION = 0x706d6363, /* 'ccmp' */ + DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_LIGATURES = 0x67696c63, /* 'clig' */ + DWRITE_FONT_FEATURE_TAG_CAPITAL_SPACING = 0x70737063, /* 'cpsp' */ + DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_SWASH = 0x68777363, /* 'cswh' */ + DWRITE_FONT_FEATURE_TAG_CURSIVE_POSITIONING = 0x73727563, /* 'curs' */ + DWRITE_FONT_FEATURE_TAG_DEFAULT = 0x746c6664, /* 'dflt' */ + DWRITE_FONT_FEATURE_TAG_DISCRETIONARY_LIGATURES = 0x67696c64, /* 'dlig' */ + DWRITE_FONT_FEATURE_TAG_EXPERT_FORMS = 0x74707865, /* 'expt' */ + DWRITE_FONT_FEATURE_TAG_FRACTIONS = 0x63617266, /* 'frac' */ + DWRITE_FONT_FEATURE_TAG_FULL_WIDTH = 0x64697766, /* 'fwid' */ + DWRITE_FONT_FEATURE_TAG_HALF_FORMS = 0x666c6168, /* 'half' */ + DWRITE_FONT_FEATURE_TAG_HALANT_FORMS = 0x6e6c6168, /* 'haln' */ + DWRITE_FONT_FEATURE_TAG_ALTERNATE_HALF_WIDTH = 0x746c6168, /* 'halt' */ + DWRITE_FONT_FEATURE_TAG_HISTORICAL_FORMS = 0x74736968, /* 'hist' */ + DWRITE_FONT_FEATURE_TAG_HORIZONTAL_KANA_ALTERNATES = 0x616e6b68, /* 'hkna' */ + DWRITE_FONT_FEATURE_TAG_HISTORICAL_LIGATURES = 0x67696c68, /* 'hlig' */ + DWRITE_FONT_FEATURE_TAG_HALF_WIDTH = 0x64697768, /* 'hwid' */ + DWRITE_FONT_FEATURE_TAG_HOJO_KANJI_FORMS = 0x6f6a6f68, /* 'hojo' */ + DWRITE_FONT_FEATURE_TAG_JIS04_FORMS = 0x3430706a, /* 'jp04' */ + DWRITE_FONT_FEATURE_TAG_JIS78_FORMS = 0x3837706a, /* 'jp78' */ + DWRITE_FONT_FEATURE_TAG_JIS83_FORMS = 0x3338706a, /* 'jp83' */ + DWRITE_FONT_FEATURE_TAG_JIS90_FORMS = 0x3039706a, /* 'jp90' */ + DWRITE_FONT_FEATURE_TAG_KERNING = 0x6e72656b, /* 'kern' */ + DWRITE_FONT_FEATURE_TAG_STANDARD_LIGATURES = 0x6167696c, /* 'liga' */ + DWRITE_FONT_FEATURE_TAG_LINING_FIGURES = 0x6d756e6c, /* 'lnum' */ + DWRITE_FONT_FEATURE_TAG_LOCALIZED_FORMS = 0x6c636f6c, /* 'locl' */ + DWRITE_FONT_FEATURE_TAG_MARK_POSITIONING = 0x6b72616d, /* 'mark' */ + DWRITE_FONT_FEATURE_TAG_MATHEMATICAL_GREEK = 0x6b72676d, /* 'mgrk' */ + DWRITE_FONT_FEATURE_TAG_MARK_TO_MARK_POSITIONING = 0x6b6d6b6d, /* 'mkmk' */ + DWRITE_FONT_FEATURE_TAG_ALTERNATE_ANNOTATION_FORMS = 0x746c616e, /* 'nalt' */ + DWRITE_FONT_FEATURE_TAG_NLC_KANJI_FORMS = 0x6b636c6e, /* 'nlck' */ + DWRITE_FONT_FEATURE_TAG_OLD_STYLE_FIGURES = 0x6d756e6f, /* 'onum' */ + DWRITE_FONT_FEATURE_TAG_ORDINALS = 0x6e64726f, /* 'ordn' */ + DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_ALTERNATE_WIDTH = 0x746c6170, /* 'palt' */ + DWRITE_FONT_FEATURE_TAG_PETITE_CAPITALS = 0x70616370, /* 'pcap' */ + DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_FIGURES = 0x6d756e70, /* 'pnum' */ + DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_WIDTHS = 0x64697770, /* 'pwid' */ + DWRITE_FONT_FEATURE_TAG_QUARTER_WIDTHS = 0x64697771, /* 'qwid' */ + DWRITE_FONT_FEATURE_TAG_REQUIRED_LIGATURES = 0x67696c72, /* 'rlig' */ + DWRITE_FONT_FEATURE_TAG_RUBY_NOTATION_FORMS = 0x79627572, /* 'ruby' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_ALTERNATES = 0x746c6173, /* 'salt' */ + DWRITE_FONT_FEATURE_TAG_SCIENTIFIC_INFERIORS = 0x666e6973, /* 'sinf' */ + DWRITE_FONT_FEATURE_TAG_SMALL_CAPITALS = 0x70636d73, /* 'smcp' */ + DWRITE_FONT_FEATURE_TAG_SIMPLIFIED_FORMS = 0x6c706d73, /* 'smpl' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1 = 0x31307373, /* 'ss01' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_2 = 0x32307373, /* 'ss02' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_3 = 0x33307373, /* 'ss03' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_4 = 0x34307373, /* 'ss04' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_5 = 0x35307373, /* 'ss05' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_6 = 0x36307373, /* 'ss06' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_7 = 0x37307373, /* 'ss07' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_8 = 0x38307373, /* 'ss08' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_9 = 0x39307373, /* 'ss09' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_10 = 0x30317373, /* 'ss10' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_11 = 0x31317373, /* 'ss11' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_12 = 0x32317373, /* 'ss12' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_13 = 0x33317373, /* 'ss13' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_14 = 0x34317373, /* 'ss14' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_15 = 0x35317373, /* 'ss15' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_16 = 0x36317373, /* 'ss16' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_17 = 0x37317373, /* 'ss17' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_18 = 0x38317373, /* 'ss18' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_19 = 0x39317373, /* 'ss19' */ + DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_20 = 0x30327373, /* 'ss20' */ + DWRITE_FONT_FEATURE_TAG_SUBSCRIPT = 0x73627573, /* 'subs' */ + DWRITE_FONT_FEATURE_TAG_SUPERSCRIPT = 0x73707573, /* 'sups' */ + DWRITE_FONT_FEATURE_TAG_SWASH = 0x68737773, /* 'swsh' */ + DWRITE_FONT_FEATURE_TAG_TITLING = 0x6c746974, /* 'titl' */ + DWRITE_FONT_FEATURE_TAG_TRADITIONAL_NAME_FORMS = 0x6d616e74, /* 'tnam' */ + DWRITE_FONT_FEATURE_TAG_TABULAR_FIGURES = 0x6d756e74, /* 'tnum' */ + DWRITE_FONT_FEATURE_TAG_TRADITIONAL_FORMS = 0x64617274, /* 'trad' */ + DWRITE_FONT_FEATURE_TAG_THIRD_WIDTHS = 0x64697774, /* 'twid' */ + DWRITE_FONT_FEATURE_TAG_UNICASE = 0x63696e75, /* 'unic' */ + DWRITE_FONT_FEATURE_TAG_VERTICAL_WRITING = 0x74726576, /* 'vert' */ + DWRITE_FONT_FEATURE_TAG_VERTICAL_ALTERNATES_AND_ROTATION= 0x32747276, /* 'vrt2' */ + DWRITE_FONT_FEATURE_TAG_SLASHED_ZERO = 0x6f72657a, /* 'zero' */ +} DWRITE_FONT_FEATURE_TAG; + +typedef enum DWRITE_SCRIPT_SHAPES +{ + DWRITE_SCRIPT_SHAPES_DEFAULT = 0, + DWRITE_SCRIPT_SHAPES_NO_VISUAL = 1 +} DWRITE_SCRIPT_SHAPES; +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(DWRITE_SCRIPT_SHAPES);") + +typedef enum DWRITE_NUMBER_SUBSTITUTION_METHOD +{ + DWRITE_NUMBER_SUBSTITUTION_METHOD_FROM_CULTURE, + DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL, + DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, + DWRITE_NUMBER_SUBSTITUTION_METHOD_NATIONAL, + DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL +} DWRITE_NUMBER_SUBSTITUTION_METHOD; + +cpp_quote("#define DWRITE_ALPHA_MAX 255") + +typedef enum DWRITE_TEXTURE_TYPE +{ + DWRITE_TEXTURE_ALIASED_1x1, + DWRITE_TEXTURE_CLEARTYPE_3x1 +} DWRITE_TEXTURE_TYPE; + +typedef struct DWRITE_FONT_METRICS +{ + UINT16 designUnitsPerEm; + UINT16 ascent; + UINT16 descent; + INT16 lineGap; + UINT16 capHeight; + UINT16 xHeight; + INT16 underlinePosition; + UINT16 underlineThickness; + INT16 strikethroughPosition; + UINT16 strikethroughThickness; +} DWRITE_FONT_METRICS; + +typedef struct DWRITE_GLYPH_METRICS +{ + INT32 leftSideBearing; + UINT32 advanceWidth; + INT32 rightSideBearing; + INT32 topSideBearing; + UINT32 advanceHeight; + INT32 bottomSideBearing; + INT32 verticalOriginY; +} DWRITE_GLYPH_METRICS; + +typedef struct DWRITE_GLYPH_OFFSET +{ + FLOAT advanceOffset; + FLOAT ascenderOffset; +} DWRITE_GLYPH_OFFSET; + +typedef struct DWRITE_MATRIX +{ + FLOAT m11; + FLOAT m12; + FLOAT m21; + FLOAT m22; + FLOAT dx; + FLOAT dy; +} DWRITE_MATRIX; + +typedef struct DWRITE_TRIMMING +{ + DWRITE_TRIMMING_GRANULARITY granularity; + UINT32 delimiter; + UINT32 delimiterCount; +} DWRITE_TRIMMING; + +cpp_quote("#ifndef __d2d1_h__") +typedef struct DWRITE_GLYPH_RUN DWRITE_GLYPH_RUN; +cpp_quote("#endif /* __d2d1_h__ */") + +struct DWRITE_GLYPH_RUN +{ + IDWriteFontFace* fontFace; + FLOAT fontEmSize; + UINT32 glyphCount; + UINT16 const* glyphIndices; + FLOAT const* glyphAdvances; + DWRITE_GLYPH_OFFSET const* glyphOffsets; + BOOL isSideways; + UINT32 bidiLevel; +}; + +cpp_quote("#ifndef __d2d1_1_h__") +typedef struct DWRITE_GLYPH_RUN_DESCRIPTION DWRITE_GLYPH_RUN_DESCRIPTION; +cpp_quote("#endif /* __d2d1_1_h__ */") + +struct DWRITE_GLYPH_RUN_DESCRIPTION +{ + WCHAR const* localeName; + WCHAR const* string; + UINT32 stringLength; + UINT16 const* clusterMap; + UINT32 textPosition; +}; + +typedef struct DWRITE_UNDERLINE +{ + FLOAT width; + FLOAT thickness; + FLOAT offset; + FLOAT runHeight; + DWRITE_READING_DIRECTION readingDirection; + DWRITE_FLOW_DIRECTION flowDirection; + WCHAR const* localeName; + DWRITE_MEASURING_MODE measuringMode; +} DWRITE_UNDERLINE; + +typedef struct DWRITE_STRIKETHROUGH +{ + FLOAT width; + FLOAT thickness; + FLOAT offset; + DWRITE_READING_DIRECTION readingDirection; + DWRITE_FLOW_DIRECTION flowDirection; + WCHAR const* localeName; + DWRITE_MEASURING_MODE measuringMode; +} DWRITE_STRIKETHROUGH; + +typedef struct DWRITE_INLINE_OBJECT_METRICS +{ + FLOAT width; + FLOAT height; + FLOAT baseline; + BOOL supportsSideways; +} DWRITE_INLINE_OBJECT_METRICS; + +typedef struct DWRITE_OVERHANG_METRICS +{ + FLOAT left; + FLOAT top; + FLOAT right; + FLOAT bottom; +} DWRITE_OVERHANG_METRICS; + +typedef struct DWRITE_FONT_FEATURE +{ + DWRITE_FONT_FEATURE_TAG nameTag; + UINT32 parameter; +} DWRITE_FONT_FEATURE; + +typedef struct DWRITE_TEXT_RANGE +{ + UINT32 startPosition; + UINT32 length; +} DWRITE_TEXT_RANGE; + +typedef struct DWRITE_LINE_METRICS +{ + UINT32 length; + UINT32 trailingWhitespaceLength; + UINT32 newlineLength; + FLOAT height; + FLOAT baseline; + BOOL isTrimmed; +} DWRITE_LINE_METRICS; + +typedef struct DWRITE_TEXT_METRICS +{ + FLOAT left; + FLOAT top; + FLOAT width; + FLOAT widthIncludingTrailingWhitespace; + FLOAT height; + FLOAT layoutWidth; + FLOAT layoutHeight; + UINT32 maxBidiReorderingDepth; + UINT32 lineCount; +} DWRITE_TEXT_METRICS; + +typedef struct DWRITE_CLUSTER_METRICS +{ + FLOAT width; + UINT16 length; + UINT16 canWrapLineAfter : 1; + UINT16 isWhitespace : 1; + UINT16 isNewline : 1; + UINT16 isSoftHyphen : 1; + UINT16 isRightToLeft : 1; + UINT16 padding : 11; +} DWRITE_CLUSTER_METRICS; + +typedef struct DWRITE_HIT_TEST_METRICS +{ + UINT32 textPosition; + UINT32 length; + FLOAT left; + FLOAT top; + FLOAT width; + FLOAT height; + UINT32 bidiLevel; + BOOL isText; + BOOL isTrimmed; +} DWRITE_HIT_TEST_METRICS; + +typedef struct DWRITE_SCRIPT_ANALYSIS +{ + UINT16 script; + DWRITE_SCRIPT_SHAPES shapes; +} DWRITE_SCRIPT_ANALYSIS; + +typedef struct DWRITE_LINE_BREAKPOINT +{ + UINT8 breakConditionBefore : 2; + UINT8 breakConditionAfter : 2; + UINT8 isWhitespace : 1; + UINT8 isSoftHyphen : 1; + UINT8 padding : 2; +} DWRITE_LINE_BREAKPOINT; + +typedef struct DWRITE_TYPOGRAPHIC_FEATURES +{ + DWRITE_FONT_FEATURE* features; + UINT32 featureCount; +} DWRITE_TYPOGRAPHIC_FEATURES; + +typedef struct DWRITE_SHAPING_TEXT_PROPERTIES +{ + UINT16 isShapedAlone : 1; + UINT16 reserved1 : 1; + UINT16 canBreakShapingAfter : 1; + UINT16 reserved : 13; +} DWRITE_SHAPING_TEXT_PROPERTIES; + +typedef struct DWRITE_SHAPING_GLYPH_PROPERTIES +{ + UINT16 justification : 4; + UINT16 isClusterStart : 1; + UINT16 isDiacritic : 1; + UINT16 isZeroWidthSpace : 1; + UINT16 reserved : 9; +} DWRITE_SHAPING_GLYPH_PROPERTIES; + +[ +local, +object, +uuid(6d4865fe-0ab8-4d91-8f62-5dd6be34a3e0) +] +interface IDWriteFontFileStream : IUnknown +{ + HRESULT ReadFileFragment( + [out] void const **fragment_start, + [in] UINT64 offset, + [in] UINT64 fragment_size, + [out] void **fragment_context + ); + void ReleaseFileFragment( + [in] void *fragment_context + ); + HRESULT GetFileSize( + [out] UINT64 *size + ); + HRESULT GetLastWriteTime( + [out] UINT64 *last_writetime + ); +} + +[ +local, +object, +uuid(727cad4e-d6af-4c9e-8a08-d695b11caa49) +] +interface IDWriteFontFileLoader : IUnknown +{ + HRESULT CreateStreamFromKey( + [in] void const *key, + [in] UINT32 key_size, + [out] IDWriteFontFileStream **stream + ); +} + +[ +local, +object, +uuid(b2d9f3ec-c9fe-4a11-a2ec-d86208f7c0a2) +] +interface IDWriteLocalFontFileLoader : IDWriteFontFileLoader +{ + HRESULT GetFilePathLengthFromKey( + [in] void const *key, + [in] UINT32 key_size, + [out] UINT32 *length + ); + HRESULT GetFilePathFromKey( + [in] void const *key, + [in] UINT32 key_size, + [out] WCHAR *path, + [in] UINT32 length + ); + HRESULT GetLastWriteTimeFromKey( + [in] void const *key, + [in] UINT32 key_size, + [out] FILETIME *writetime + ); +} + +[ +local, +object, +uuid(739d886a-cef5-47dc-8769-1a8b41bebbb0) +] +interface IDWriteFontFile : IUnknown +{ + HRESULT GetReferenceKey( + [out] void const **key, + [out] UINT32 *key_size + ); + HRESULT GetLoader( + [out] IDWriteFontFileLoader **loader + ); + HRESULT Analyze( + [out] BOOL *is_supported_fonttype, + [out] DWRITE_FONT_FILE_TYPE *file_type, + [out] DWRITE_FONT_FACE_TYPE *face_type, + [out] UINT32 *faces_num + ); +} + +[ +local, +object, +uuid(72755049-5ff7-435d-8348-4be97cfa6c7c) +] +interface IDWriteFontFileEnumerator : IUnknown +{ + HRESULT MoveNext( + [out] BOOL *has_current_file + ); + HRESULT GetCurrentFontFile( + [out] IDWriteFontFile **font_file + ); +} + +[ +local, +object, +uuid(cca920e4-52f0-492b-bfa8-29c72ee0a468) +] +interface IDWriteFontCollectionLoader : IUnknown +{ + HRESULT CreateEnumeratorFromKey( + [in] IDWriteFactory *factory, + [in] void const *key, + [in] UINT32 key_size, + [out] IDWriteFontFileEnumerator **enumerator + ); +} + +[ +local, +object, +uuid(08256209-099a-4b34-b86d-c22b110e7771) +] +interface IDWriteLocalizedStrings : IUnknown +{ + UINT32 GetCount(); + + HRESULT FindLocaleName( + [in] WCHAR const *locale_name, + [out] UINT32 *index, + [out] BOOL *exists + ); + HRESULT GetLocaleNameLength( + [in] UINT32 index, + [out] UINT32 *length + ); + HRESULT GetLocaleName( + [in] UINT32 index, + [out] WCHAR *locale_name, + [in] UINT32 size + ); + HRESULT GetStringLength( + [in] UINT32 index, + [out] UINT32 *length + ); + HRESULT GetString( + [in] UINT32 index, + [out] WCHAR *buffer, + [in] UINT32 size + ); +} + +[ +local, +object, +uuid(2f0da53a-2add-47cd-82ee-d9ec34688e75) +] +interface IDWriteRenderingParams : IUnknown +{ + FLOAT GetGamma(); + FLOAT GetEnhancedContrast(); + FLOAT GetClearTypeLevel(); + DWRITE_PIXEL_GEOMETRY GetPixelGeometry(); + DWRITE_RENDERING_MODE GetRenderingMode(); +} + +[ +local, +object, +uuid(5f49804d-7024-4d43-bfa9-d25984f53849) +] +interface IDWriteFontFace : IUnknown +{ + DWRITE_FONT_FACE_TYPE GetType(); + HRESULT GetFiles( + [out] UINT32 *number_of_files, + [out] IDWriteFontFile **fontfiles + ); + UINT32 GetIndex(); + DWRITE_FONT_SIMULATIONS GetSimulations(); + BOOL IsSymbolFont(); + void GetMetrics( + [out] DWRITE_FONT_METRICS *metrics + ); + UINT16 GetGlyphCount(); + + HRESULT GetDesignGlyphMetrics( + [in] UINT16 const *glyph_indices, + [in] UINT32 glyph_count, + [out] DWRITE_GLYPH_METRICS *metrics, + [in, defaultvalue(FALSE)] BOOL is_sideways + ); + HRESULT GetGlyphIndices( + [in] UINT32 const *codepoints, + [in] UINT32 count, + [out] UINT16 *glyph_indices + ); + HRESULT TryGetFontTable( + [in] UINT32 table_tag, + [out] const void **table_data, + [out] UINT32 *table_size, + [out] void **context, + [out] BOOL *exists + ); + void ReleaseFontTable( + [in] void *table_context + ); + HRESULT GetGlyphRunOutline( + [in] FLOAT emSize, + [in] UINT16 const *glyph_indices, + [in] FLOAT const* glyph_advances, + [in] DWRITE_GLYPH_OFFSET const *glyph_offsets, + [in] UINT32 glyph_count, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] IDWriteGeometrySink *geometrysink + ); + HRESULT GetRecommendedRenderingMode( + [in] FLOAT emSize, + [in] FLOAT pixels_per_dip, + [in] DWRITE_MEASURING_MODE mode, + [in] IDWriteRenderingParams *params, + [out] DWRITE_RENDERING_MODE *rendering_mode + ); + HRESULT GetGdiCompatibleMetrics( + [in] FLOAT emSize, + [in] FLOAT pixels_per_dip, + [in] DWRITE_MATRIX const *transform, + [out] DWRITE_FONT_METRICS *metrics + ); + HRESULT GetGdiCompatibleGlyphMetrics( + [in] FLOAT emSize, + [in] FLOAT pixels_per_dip, + [in] DWRITE_MATRIX const *transform, + [in] BOOL use_gdi_natural, + [in] UINT16 const *glyph_indices, + [in] UINT32 glyph_count, + [out] DWRITE_GLYPH_METRICS *metrics, + [in, defaultvalue(FALSE)] BOOL is_sideways + ); +} + +[ +local, +object, +uuid(acd16696-8c14-4f5d-877e-fe3fc1d32737) +] +interface IDWriteFont : IUnknown +{ + HRESULT GetFontFamily( + [out] IDWriteFontFamily **family + ); + DWRITE_FONT_WEIGHT GetWeight(); + DWRITE_FONT_STRETCH GetStretch(); + DWRITE_FONT_STYLE GetStyle(); + BOOL IsSymbolFont(); + + HRESULT GetFaceNames( + [out] IDWriteLocalizedStrings **names + ); + HRESULT GetInformationalStrings( + [in] DWRITE_INFORMATIONAL_STRING_ID stringid, + [out] IDWriteLocalizedStrings **strings, + [out] BOOL *exists + ); + DWRITE_FONT_SIMULATIONS GetSimulations(); + void GetMetrics( + [out] DWRITE_FONT_METRICS *metrics + ); + HRESULT HasCharacter( + [in] UINT32 value, + [out] BOOL *exists + ); + HRESULT CreateFontFace( + [out] IDWriteFontFace **face + ); +} + +[ +local, +object, +uuid(1a0d8438-1d97-4ec1-aef9-a2fb86ed6acb) +] +interface IDWriteFontList : IUnknown +{ + HRESULT GetFontCollection( + [out] IDWriteFontCollection **collection + ); + UINT32 GetFontCount(); + HRESULT GetFont( + [in] UINT32 index, + [out] IDWriteFont **font + ); +} + +[ +local, +object, +uuid(da20d8ef-812a-4c43-9802-62ec4abd7add) +] +interface IDWriteFontFamily : IDWriteFontList +{ + HRESULT GetFamilyNames( + [out] IDWriteLocalizedStrings **names + ); + HRESULT GetFirstMatchingFont( + [in] DWRITE_FONT_WEIGHT weight, + [in] DWRITE_FONT_STRETCH stretch, + [in] DWRITE_FONT_STYLE style, + [out] IDWriteFont **font + ); + HRESULT GetMatchingFonts( + [in] DWRITE_FONT_WEIGHT weight, + [in] DWRITE_FONT_STRETCH stretch, + [in] DWRITE_FONT_STYLE style, + [out] IDWriteFontList **fonts + ); +} + +[ +local, +object, +uuid(a84cee02-3eea-4eee-a827-87c1a02a0fcc) +] +interface IDWriteFontCollection : IUnknown +{ + UINT32 GetFontFamilyCount(); + HRESULT GetFontFamily( + [in] UINT32 index, + [out] IDWriteFontFamily **family + ); + HRESULT FindFamilyName( + [in] WCHAR const *name, + [out] UINT32 *index, + [out] BOOL *exists + ); + HRESULT GetFontFromFontFace( + [in] IDWriteFontFace *face, + [out] IDWriteFont **font + ); +} + +[ +local, +object, +uuid(eaf3a2da-ecf4-4d24-b644-b34f6842024b) +] +interface IDWritePixelSnapping : IUnknown +{ + HRESULT IsPixelSnappingDisabled( + [in] void *client_drawingcontext, + [out] BOOL *disabled + ); + HRESULT GetCurrentTransform( + [in] void *client_drawingcontext, + [out] DWRITE_MATRIX *transform + ); + HRESULT GetPixelsPerDip( + [in] void *client_drawingcontext, + [out] FLOAT *pixels_per_dip + ); +} + +[ +local, +object, +uuid(ef8a8135-5cc6-45fe-8825-c5a0724eb819) +] +interface IDWriteTextRenderer : IDWritePixelSnapping +{ + HRESULT DrawGlyphRun( + [in] void *client_drawingcontext, + [in] FLOAT baselineOriginX, + [in] FLOAT baselineOriginY, + [in] DWRITE_MEASURING_MODE mode, + [in] DWRITE_GLYPH_RUN const *glyph_run, + [in] DWRITE_GLYPH_RUN_DESCRIPTION const *run_descr, + [in] IUnknown *drawing_effect + ); + HRESULT DrawUnderline( + [in] void *client_drawingcontext, + [in] FLOAT baselineOriginX, + [in] FLOAT baselineOriginY, + [in] DWRITE_UNDERLINE const *underline, + [in] IUnknown *drawing_effect + ); + HRESULT DrawStrikethrough( + [in] void *client_drawingcontext, + [in] FLOAT baselineOriginX, + [in] FLOAT baselineOriginY, + [in] DWRITE_STRIKETHROUGH const *strikethrough, + [in] IUnknown *drawing_effect + ); + HRESULT DrawInlineObject( + [in] void *client_drawingcontext, + [in] FLOAT originX, + [in] FLOAT originY, + [in] IDWriteInlineObject *object, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] IUnknown *drawing_effect + ); +} + +[ +local, +object, +uuid(8339fde3-106f-47ab-8373-1c6295eb10b3) +] +interface IDWriteInlineObject : IUnknown +{ + HRESULT Draw( + [in] void *client_drawingontext, + [in] IDWriteTextRenderer *renderer, + [in] FLOAT originX, + [in] FLOAT originY, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] IUnknown *drawing_effect + ); + HRESULT GetMetrics( + [out] DWRITE_INLINE_OBJECT_METRICS *metrics + ); + HRESULT GetOverhangMetrics( + [out] DWRITE_OVERHANG_METRICS *overhangs + ); + HRESULT GetBreakConditions( + [out] DWRITE_BREAK_CONDITION *condition_before, + [out] DWRITE_BREAK_CONDITION *condition_after + ); +} + +[ +local, +object, +uuid(9c906818-31d7-4fd3-a151-7c5e225db55a) +] +interface IDWriteTextFormat : IUnknown +{ + HRESULT SetTextAlignment( + [in] DWRITE_TEXT_ALIGNMENT alignment + ); + HRESULT SetParagraphAlignment( + [in] DWRITE_PARAGRAPH_ALIGNMENT alignment + ); + HRESULT SetWordWrapping( + [in] DWRITE_WORD_WRAPPING wrapping + ); + HRESULT SetReadingDirection( + [in] DWRITE_READING_DIRECTION direction + ); + HRESULT SetFlowDirection( + [in] DWRITE_FLOW_DIRECTION direction + ); + HRESULT SetIncrementalTabStop( + [in] FLOAT tabstop + ); + HRESULT SetTrimming( + [in] DWRITE_TRIMMING const *trimming, + [in] IDWriteInlineObject *trimming_sign + ); + HRESULT SetLineSpacing( + [in] DWRITE_LINE_SPACING_METHOD spacing, + [in] FLOAT line_spacing, + [in] FLOAT baseline + ); + DWRITE_TEXT_ALIGNMENT GetTextAlignment(); + DWRITE_PARAGRAPH_ALIGNMENT GetParagraphAlignment(); + DWRITE_WORD_WRAPPING GetWordWrapping(); + DWRITE_READING_DIRECTION GetReadingDirection(); + DWRITE_FLOW_DIRECTION GetFlowDirection(); + FLOAT GetIncrementalTabStop(); + HRESULT GetTrimming( + [out] DWRITE_TRIMMING *options, + [out] IDWriteInlineObject **trimming_sign + ); + HRESULT GetLineSpacing( + [out] DWRITE_LINE_SPACING_METHOD *method, + [out] FLOAT *spacing, + [out] FLOAT *baseline + ); + HRESULT GetFontCollection( + [out] IDWriteFontCollection **collection + ); + UINT32 GetFontFamilyNameLength(); + HRESULT GetFontFamilyName( + [out] WCHAR *name, + [in] UINT32 size + ); + DWRITE_FONT_WEIGHT GetFontWeight(); + DWRITE_FONT_STYLE GetFontStyle(); + DWRITE_FONT_STRETCH GetFontStretch(); + FLOAT GetFontSize(); + UINT32 GetLocaleNameLength(); + HRESULT GetLocaleName( + [out] WCHAR *name, + [in] UINT32 size + ); +} + +[ +local, +object, +uuid(55f1112b-1dc2-4b3c-9541-f46894ed85b6) +] +interface IDWriteTypography : IUnknown +{ + HRESULT AddFontFeature( + [in] DWRITE_FONT_FEATURE feature + ); + UINT32 GetFontFeatureCount(); + HRESULT GetFontFeature( + [in] UINT32 index, + [out] DWRITE_FONT_FEATURE *feature + ); +} + +[ +local, +object, +uuid(5e5a32a3-8dff-4773-9ff6-0696eab77267) +] +interface IDWriteBitmapRenderTarget : IUnknown +{ + HRESULT DrawGlyphRun( + [in] FLOAT baselineOriginX, + [in] FLOAT baselineOriginY, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] DWRITE_GLYPH_RUN const *glyph_run, + [in] IDWriteRenderingParams *params, + [in] COLORREF textColor, + [out, defaultvalue(NULL)] RECT *blackbox_rect + ); + HDC GetMemoryDC(); + FLOAT GetPixelsPerDip(); + HRESULT SetPixelsPerDip( + [in] FLOAT pixels_per_dip + ); + HRESULT GetCurrentTransform( + [out] DWRITE_MATRIX *transform + ); + HRESULT SetCurrentTransform( + [in] DWRITE_MATRIX const *transform + ); + HRESULT GetSize( + [out] SIZE *size + ); + HRESULT Resize( + [in] UINT32 width, + [in] UINT32 height + ); +} + +cpp_quote("#ifndef _WINGDI_") +/* already defined in wingdi.h but needed for WIDL */ +#define LF_FACESIZE 32 + + typedef struct tagLOGFONTW + { + LONG lfHeight; + LONG lfWidth; + LONG lfEscapement; + LONG lfOrientation; + LONG lfWeight; + BYTE lfItalic; + BYTE lfUnderline; + BYTE lfStrikeOut; + BYTE lfCharSet; + BYTE lfOutPrecision; + BYTE lfClipPrecision; + BYTE lfQuality; + BYTE lfPitchAndFamily; + WCHAR lfFaceName[LF_FACESIZE]; + } LOGFONTW, *PLOGFONTW, *LPLOGFONTW; +cpp_quote("#endif /* _WINGDI_ */") + +[ +local, +object, +uuid(1edd9491-9853-4299-898f-6432983b6f3a) +] +interface IDWriteGdiInterop : IUnknown +{ + HRESULT CreateFontFromLOGFONT( + [in] LOGFONTW const *logfont, + [out] IDWriteFont **font + ); + HRESULT ConvertFontToLOGFONT( + [in] IDWriteFont *font, + [out] LOGFONTW *logfont, + [out] BOOL *is_systemfont + ); + HRESULT ConvertFontFaceToLOGFONT( + [in] IDWriteFontFace *font, + [out] LOGFONTW *logfont + ); + HRESULT CreateFontFaceFromHdc( + [in] HDC hdc, + [out] IDWriteFontFace **fontface + ); + HRESULT CreateBitmapRenderTarget( + [in] HDC hdc, + [in] UINT32 width, + [in] UINT32 height, + [out] IDWriteBitmapRenderTarget **target + ); +} + +[ +local, +object, +uuid(53737037-6d14-410b-9bfe-0b182bb70961) +] +interface IDWriteTextLayout : IDWriteTextFormat +{ + HRESULT SetMaxWidth( + [in] FLOAT maxWidth + ); + HRESULT SetMaxHeight( + [in] FLOAT maxHeight + ); + HRESULT SetFontCollection( + [in] IDWriteFontCollection *collection, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetFontFamilyName( + [in] WCHAR const *name, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetFontWeight( + [in] DWRITE_FONT_WEIGHT weight, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetFontStyle( + [in] DWRITE_FONT_STYLE style, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetFontStretch( + [in] DWRITE_FONT_STRETCH stretch, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetFontSize( + [in] FLOAT size, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetUnderline( + [in] BOOL underline, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetStrikethrough( + [in] BOOL strikethrough, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetDrawingEffect( + [in] IUnknown *effect, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetInlineObject( + [in] IDWriteInlineObject *object, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetTypography( + [in] IDWriteTypography *typography, + [in] DWRITE_TEXT_RANGE range + ); + HRESULT SetLocaleName( + [in] WCHAR const *locale, + [in] DWRITE_TEXT_RANGE range + ); + FLOAT GetMaxWidth(); + FLOAT GetMaxHeight(); + HRESULT GetFontCollection( + [in] UINT32 pos, + [out] IDWriteFontCollection **collection, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetFontFamilyNameLength( + [in] UINT32 pos, + [out] UINT32 *len, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetFontFamilyName( + [in] UINT32 position, + [out] WCHAR *name, + [in] UINT32 name_size, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetFontWeight( + [in] UINT32 position, + [out] DWRITE_FONT_WEIGHT *weight, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetFontStyle( + [in] UINT32 currentPosition, + [out] DWRITE_FONT_STYLE *style, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetFontStretch( + [in] UINT32 position, + [out] DWRITE_FONT_STRETCH *stretch, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetFontSize( + [in] UINT32 position, + [out] FLOAT *size, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetUnderline( + [in] UINT32 position, + [out] BOOL *has_underline, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetStrikethrough( + [in] UINT32 position, + [out] BOOL *has_strikethrough, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetDrawingEffect( + [in] UINT32 position, + [out] IUnknown **effect, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetInlineObject( + [in] UINT32 position, + [out] IDWriteInlineObject **object, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetTypography( + [in] UINT32 position, + [out] IDWriteTypography **typography, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetLocaleNameLength( + [in] UINT32 position, + [out] UINT32 *length, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT GetLocaleName( + [in] UINT32 position, + [out] WCHAR *name, + [in] UINT32 name_size, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); + HRESULT Draw( + [in] void *context, + [in] IDWriteTextRenderer *renderer, + [in] FLOAT originX, + [in] FLOAT originY + ); + HRESULT GetLineMetrics( + [out] DWRITE_LINE_METRICS *metrics, + [in] UINT32 max_count, + [out] UINT32 *actual_count + ); + HRESULT GetMetrics( + [out] DWRITE_TEXT_METRICS *metrics + ); + HRESULT GetOverhangMetrics( + [out] DWRITE_OVERHANG_METRICS *overhangs + ); + HRESULT GetClusterMetrics( + [out] DWRITE_CLUSTER_METRICS *metrics, + [in] UINT32 max_count, + [out] UINT32* act_count + ); + HRESULT DetermineMinWidth( + [out] FLOAT *min_width + ); + HRESULT HitTestPoint( + [in] FLOAT pointX, + [in] FLOAT pointY, + [out] BOOL *is_trailinghit, + [out] BOOL *is_inside, + [out] DWRITE_HIT_TEST_METRICS *metrics + ); + HRESULT HitTestTextPosition( + [in] UINT32 textPosition, + [in] BOOL is_trailinghit, + [out] FLOAT *pointX, + [out] FLOAT *pointY, + [out] DWRITE_HIT_TEST_METRICS *metrics + ); + HRESULT HitTestTextRange( + [in] UINT32 textPosition, + [in] UINT32 textLength, + [in] FLOAT originX, + [in] FLOAT originY, + [out] DWRITE_HIT_TEST_METRICS *metrics, + [in] UINT32 max_metricscount, + [out] UINT32 *actual_metricscount + ); +} + +[ +local, +object, +uuid(14885cc9-bab0-4f90-b6ed-5c366a2cd03d) +] +interface IDWriteNumberSubstitution : IUnknown +{ +} + +[ +local, +object, +uuid(688e1a58-5094-47c8-adc8-fbcea60ae92b) +] +interface IDWriteTextAnalysisSource : IUnknown +{ + HRESULT GetTextAtPosition( + [in] UINT32 position, + [out] WCHAR const **text, + [out] UINT32 *text_len + ); + HRESULT GetTextBeforePosition( + [in] UINT32 position, + [out] WCHAR const **text, + [out] UINT32* text_len + ); + DWRITE_READING_DIRECTION GetParagraphReadingDirection(); + HRESULT GetLocaleName( + [in] UINT32 position, + [out] UINT32 *text_len, + [out] WCHAR const **locale + ); + HRESULT GetNumberSubstitution( + [in] UINT32 position, + [out] UINT32 *text_len, + [out] IDWriteNumberSubstitution **substitution + ); +} + +[ +local, +object, +uuid(5810cd44-0ca0-4701-b3fa-bec5182ae4f6) +] +interface IDWriteTextAnalysisSink : IUnknown +{ + HRESULT SetScriptAnalysis( + [in] UINT32 position, + [in] UINT32 length, + [in] DWRITE_SCRIPT_ANALYSIS const* scriptanalysis + ); + HRESULT SetLineBreakpoints( + [in] UINT32 position, + [in] UINT32 length, + [in] DWRITE_LINE_BREAKPOINT const* breakpoints + ); + HRESULT SetBidiLevel( + [in] UINT32 position, + [in] UINT32 length, + [in] UINT8 explicitLevel, + [in] UINT8 resolvedLevel + ); + HRESULT SetNumberSubstitution( + [in] UINT32 position, + [in] UINT32 length, + [in] IDWriteNumberSubstitution *substitution + ); +} + +[ +local, +object, +uuid(b7e6163e-7f46-43b4-84b3-e4e6249c365d) +] +interface IDWriteTextAnalyzer : IUnknown +{ + HRESULT AnalyzeScript( + [in] IDWriteTextAnalysisSource *source, + [in] UINT32 position, + [in] UINT32 length, + [in] IDWriteTextAnalysisSink *sink + ); + HRESULT AnalyzeBidi( + [in] IDWriteTextAnalysisSource *source, + [in] UINT32 position, + [in] UINT32 length, + [in] IDWriteTextAnalysisSink *sink + ); + HRESULT AnalyzeNumberSubstitution( + [in] IDWriteTextAnalysisSource *source, + [in] UINT32 position, + [in] UINT32 length, + [in] IDWriteTextAnalysisSink *sink + ); + HRESULT AnalyzeLineBreakpoints( + [in] IDWriteTextAnalysisSource *source, + [in] UINT32 position, + [in] UINT32 length, + [in] IDWriteTextAnalysisSink *sink + ); + HRESULT GetGlyphs( + [in] WCHAR const *text, + [in] UINT32 length, + [in] IDWriteFontFace *font_face, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] DWRITE_SCRIPT_ANALYSIS const *analysis, + [in] WCHAR const *locale, + [in] IDWriteNumberSubstitution *substitution, + [in] DWRITE_TYPOGRAPHIC_FEATURES const **features, + [in] UINT32 const *feature_range_len, + [in] UINT32 feature_ranges, + [in] UINT32 max_glyph_count, + [out] UINT16 *clustermap, + [out] DWRITE_SHAPING_TEXT_PROPERTIES *text_props, + [out] UINT16 *glyph_indices, + [out] DWRITE_SHAPING_GLYPH_PROPERTIES *glyph_props, + [out] UINT32 *actual_glyph_count + ); + HRESULT GetGlyphPlacements( + [in] WCHAR const *text, + [in] UINT16 const *clustermap, + [in] DWRITE_SHAPING_TEXT_PROPERTIES* props, + [in] UINT32 text_len, + [in] UINT16 const *glyph_indices, + [in] DWRITE_SHAPING_GLYPH_PROPERTIES const *glyph_props, + [in] UINT32 glyph_count, + [in] IDWriteFontFace *font_face, + [in] FLOAT fontEmSize, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] DWRITE_SCRIPT_ANALYSIS const *analysis, + [in] WCHAR const *locale, + [in] DWRITE_TYPOGRAPHIC_FEATURES const **features, + [in] UINT32 const *feature_range_len, + [in] UINT32 feature_ranges, + [out] FLOAT *glyph_advances, + [out] DWRITE_GLYPH_OFFSET *glyph_offsets + ); + HRESULT GetGdiCompatibleGlyphPlacements( + [in] WCHAR const *text, + [in] UINT16 const *clustermap, + [in] DWRITE_SHAPING_TEXT_PROPERTIES *props, + [in] UINT32 text_len, + [in] UINT16 const *glyph_indices, + [in] DWRITE_SHAPING_GLYPH_PROPERTIES const *glyph_props, + [in] UINT32 glyph_count, + [in] IDWriteFontFace * font_face, + [in] FLOAT fontEmSize, + [in] FLOAT pixels_per_dip, + [in] DWRITE_MATRIX const *transform, + [in] BOOL use_gdi_natural, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] DWRITE_SCRIPT_ANALYSIS const *analysis, + [in] WCHAR const *locale, + [in] DWRITE_TYPOGRAPHIC_FEATURES const **features, + [in] UINT32 const* feature_range_lengths, + [in] UINT32 feature_ranges, + [out] FLOAT *glyph_advances, + [out] DWRITE_GLYPH_OFFSET *glyph_offsets + ); +} + +[ +local, +object, +uuid(7d97dbf7-e085-42d4-81e3-6a883bded118) +] +interface IDWriteGlyphRunAnalysis : IUnknown +{ + HRESULT GetAlphaTextureBounds( + [in] DWRITE_TEXTURE_TYPE type, + [out] RECT *bounds + ); + HRESULT CreateAlphaTexture( + [in] DWRITE_TEXTURE_TYPE type, + [in] RECT const *bounds, + [in] BYTE *alphaValues, + [in] UINT32 bufferSize + ); + HRESULT GetAlphaBlendParams( + [in] IDWriteRenderingParams *renderingParams, + [out] FLOAT *blendGamma, + [out] FLOAT *blendEnhancedContrast, + [out] FLOAT *blendClearTypeLevel + ); +} + +[ +local, +object, +uuid(b859ee5a-d838-4b5b-a2e8-1adc7d93db48) +] +interface IDWriteFactory : IUnknown +{ + HRESULT GetSystemFontCollection( + [out] IDWriteFontCollection **collection, + [in, defaultvalue(FALSE)] BOOL check_for_updates + ); + HRESULT CreateCustomFontCollection( + [in] IDWriteFontCollectionLoader *loader, + [in] void const *key, + [in] UINT32 key_size, + [out] IDWriteFontCollection **collection + ); + HRESULT RegisterFontCollectionLoader( + [in] IDWriteFontCollectionLoader *loader + ); + HRESULT UnregisterFontCollectionLoader( + [in] IDWriteFontCollectionLoader *loader + ); + HRESULT CreateFontFileReference( + [in] WCHAR const *path, + [in] FILETIME const *writetime, + [out] IDWriteFontFile **font_file + ); + HRESULT CreateCustomFontFileReference( + [in] void const *reference_key, + [in] UINT32 key_size, + [in] IDWriteFontFileLoader *loader, + [out] IDWriteFontFile **font_file + ); + HRESULT CreateFontFace( + [in] DWRITE_FONT_FACE_TYPE facetype, + [in] UINT32 files_number, + [in] IDWriteFontFile *const *font_files, + [in] UINT32 index, + [in] DWRITE_FONT_SIMULATIONS sim_flags, + [out] IDWriteFontFace **font_face + ); + HRESULT CreateRenderingParams( + [out] IDWriteRenderingParams **params + ); + HRESULT CreateMonitorRenderingParams( + [in] HMONITOR monitor, + [out] IDWriteRenderingParams **params + ); + HRESULT CreateCustomRenderingParams( + [in] FLOAT gamma, + [in] FLOAT enhancedContrast, + [in] FLOAT cleartype_level, + [in] DWRITE_PIXEL_GEOMETRY geometry, + [in] DWRITE_RENDERING_MODE mode, + [out] IDWriteRenderingParams **params + ); + HRESULT RegisterFontFileLoader( + [in] IDWriteFontFileLoader *loader + ); + HRESULT UnregisterFontFileLoader( + [in] IDWriteFontFileLoader *loader + ); + HRESULT CreateTextFormat( + [in] WCHAR const *family_name, + [in] IDWriteFontCollection *collection, + [in] DWRITE_FONT_WEIGHT weight, + [in] DWRITE_FONT_STYLE style, + [in] DWRITE_FONT_STRETCH stretch, + [in] FLOAT size, + [in] WCHAR const *locale, + [out] IDWriteTextFormat **format + ); + HRESULT CreateTypography( + [out] IDWriteTypography **typography + ); + HRESULT GetGdiInterop( + [out] IDWriteGdiInterop **gdi_interop + ); + HRESULT CreateTextLayout( + [in] WCHAR const* string, + [in] UINT32 len, + [in] IDWriteTextFormat *format, + [in] FLOAT max_width, + [in] FLOAT max_height, + [out] IDWriteTextLayout **layout + ); + HRESULT CreateGdiCompatibleTextLayout( + [in] WCHAR const *string, + [in] UINT32 len, + [in] IDWriteTextFormat *format, + [in] FLOAT layout_width, + [in] FLOAT layout_height, + [in] FLOAT pixels_per_dip, + [in] DWRITE_MATRIX const *transform, + [in] BOOL use_gdi_natural, + [out] IDWriteTextLayout **layout + ); + + HRESULT CreateEllipsisTrimmingSign( + [in] IDWriteTextFormat *format, + [out] IDWriteInlineObject **trimming_sign + ); + HRESULT CreateTextAnalyzer( + [out] IDWriteTextAnalyzer **analyzer + ); + HRESULT CreateNumberSubstitution( + [in] DWRITE_NUMBER_SUBSTITUTION_METHOD method, + [in] WCHAR const* locale, + [in] BOOL ignore_user_override, + [out] IDWriteNumberSubstitution **substitution + ); + HRESULT CreateGlyphRunAnalysis( + [in] DWRITE_GLYPH_RUN const *glyph_run, + [in] FLOAT pixels_per_dip, + [in] DWRITE_MATRIX const *transform, + [in] DWRITE_RENDERING_MODE rendering_mode, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] FLOAT baseline_x, + [in] FLOAT baseline_y, + [out] IDWriteGlyphRunAnalysis **analysis + ); +} + +cpp_quote("HRESULT WINAPI DWriteCreateFactory(DWRITE_FACTORY_TYPE,REFIID,IUnknown**);") + +/* error codes */ +cpp_quote("#define FACILITY_DWRITE 0x898") +cpp_quote("#define DWRITE_ERR_BASE 0x5000") +cpp_quote("#define MAKE_DWRITE_HR(severity, code) MAKE_HRESULT(severity, FACILITY_DWRITE, (DWRITE_ERR_BASE + code))") +cpp_quote("#define MAKE_DWRITE_HR_ERR(code) MAKE_DWRITE_HR(SEVERITY_ERROR, code)") diff --git a/WineFix/lib/d2d1/include/windows/dwrite_1.idl b/WineFix/lib/d2d1/include/windows/dwrite_1.idl new file mode 100644 index 0000000..771c5f3 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dwrite_1.idl @@ -0,0 +1,863 @@ +/* + * Copyright 2013 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dwrite.idl"; + +typedef enum DWRITE_PANOSE_FAMILY +{ + DWRITE_PANOSE_FAMILY_ANY, + DWRITE_PANOSE_FAMILY_NO_FIT, + DWRITE_PANOSE_FAMILY_TEXT_DISPLAY, + DWRITE_PANOSE_FAMILY_SCRIPT, + DWRITE_PANOSE_FAMILY_DECORATIVE, + DWRITE_PANOSE_FAMILY_SYMBOL, + DWRITE_PANOSE_FAMILY_PICTORIAL = DWRITE_PANOSE_FAMILY_SYMBOL +} DWRITE_PANOSE_FAMILY; + +typedef enum DWRITE_PANOSE_SERIF_STYLE +{ + DWRITE_PANOSE_SERIF_STYLE_ANY, + DWRITE_PANOSE_SERIF_STYLE_NO_FIT, + DWRITE_PANOSE_SERIF_STYLE_COVE, + DWRITE_PANOSE_SERIF_STYLE_OBTUSE_COVE, + DWRITE_PANOSE_SERIF_STYLE_SQUARE_COVE, + DWRITE_PANOSE_SERIF_STYLE_OBTUSE_SQUARE_COVE, + DWRITE_PANOSE_SERIF_STYLE_SQUARE, + DWRITE_PANOSE_SERIF_STYLE_THIN, + DWRITE_PANOSE_SERIF_STYLE_OVAL, + DWRITE_PANOSE_SERIF_STYLE_EXAGGERATED, + DWRITE_PANOSE_SERIF_STYLE_TRIANGLE, + DWRITE_PANOSE_SERIF_STYLE_NORMAL_SANS, + DWRITE_PANOSE_SERIF_STYLE_OBTUSE_SANS, + DWRITE_PANOSE_SERIF_STYLE_PERPENDICULAR_SANS, + DWRITE_PANOSE_SERIF_STYLE_FLARED, + DWRITE_PANOSE_SERIF_STYLE_ROUNDED, + DWRITE_PANOSE_SERIF_STYLE_SCRIPT, + DWRITE_PANOSE_SERIF_STYLE_PERP_SANS = DWRITE_PANOSE_SERIF_STYLE_PERPENDICULAR_SANS, + DWRITE_PANOSE_SERIF_STYLE_BONE = DWRITE_PANOSE_SERIF_STYLE_OVAL +} DWRITE_PANOSE_SERIF_STYLE; + +typedef enum DWRITE_PANOSE_WEIGHT +{ + DWRITE_PANOSE_WEIGHT_ANY, + DWRITE_PANOSE_WEIGHT_NO_FIT, + DWRITE_PANOSE_WEIGHT_VERY_LIGHT, + DWRITE_PANOSE_WEIGHT_LIGHT, + DWRITE_PANOSE_WEIGHT_THIN, + DWRITE_PANOSE_WEIGHT_BOOK, + DWRITE_PANOSE_WEIGHT_MEDIUM, + DWRITE_PANOSE_WEIGHT_DEMI, + DWRITE_PANOSE_WEIGHT_BOLD, + DWRITE_PANOSE_WEIGHT_HEAVY, + DWRITE_PANOSE_WEIGHT_BLACK, + DWRITE_PANOSE_WEIGHT_EXTRA_BLACK, + DWRITE_PANOSE_WEIGHT_NORD = DWRITE_PANOSE_WEIGHT_EXTRA_BLACK +} DWRITE_PANOSE_WEIGHT; + +typedef enum DWRITE_PANOSE_PROPORTION +{ + DWRITE_PANOSE_PROPORTION_ANY, + DWRITE_PANOSE_PROPORTION_NO_FIT, + DWRITE_PANOSE_PROPORTION_OLD_STYLE, + DWRITE_PANOSE_PROPORTION_MODERN, + DWRITE_PANOSE_PROPORTION_EVEN_WIDTH, + DWRITE_PANOSE_PROPORTION_EXPANDED, + DWRITE_PANOSE_PROPORTION_CONDENSED, + DWRITE_PANOSE_PROPORTION_VERY_EXPANDED, + DWRITE_PANOSE_PROPORTION_VERY_CONDENSED, + DWRITE_PANOSE_PROPORTION_MONOSPACED +} DWRITE_PANOSE_PROPORTION; + +typedef enum DWRITE_PANOSE_CONTRAST +{ + DWRITE_PANOSE_CONTRAST_ANY, + DWRITE_PANOSE_CONTRAST_NO_FIT, + DWRITE_PANOSE_CONTRAST_NONE, + DWRITE_PANOSE_CONTRAST_VERY_LOW, + DWRITE_PANOSE_CONTRAST_LOW, + DWRITE_PANOSE_CONTRAST_MEDIUM_LOW, + DWRITE_PANOSE_CONTRAST_MEDIUM, + DWRITE_PANOSE_CONTRAST_MEDIUM_HIGH, + DWRITE_PANOSE_CONTRAST_HIGH, + DWRITE_PANOSE_CONTRAST_VERY_HIGH, + DWRITE_PANOSE_CONTRAST_HORIZONTAL_LOW, + DWRITE_PANOSE_CONTRAST_HORIZONTAL_MEDIUM, + DWRITE_PANOSE_CONTRAST_HORIZONTAL_HIGH, + DWRITE_PANOSE_CONTRAST_BROKEN +} DWRITE_PANOSE_CONTRAST; + +typedef enum DWRITE_PANOSE_STROKE_VARIATION +{ + DWRITE_PANOSE_STROKE_VARIATION_ANY, + DWRITE_PANOSE_STROKE_VARIATION_NO_FIT, + DWRITE_PANOSE_STROKE_VARIATION_NO_VARIATION, + DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_DIAGONAL, + DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_TRANSITIONAL, + DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_VERTICAL, + DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_HORIZONTAL, + DWRITE_PANOSE_STROKE_VARIATION_RAPID_VERTICAL, + DWRITE_PANOSE_STROKE_VARIATION_RAPID_HORIZONTAL, + DWRITE_PANOSE_STROKE_VARIATION_INSTANT_VERTICAL, + DWRITE_PANOSE_STROKE_VARIATION_INSTANT_HORIZONTAL +} DWRITE_PANOSE_STROKE_VARIATION; + +typedef enum DWRITE_PANOSE_ARM_STYLE +{ + DWRITE_PANOSE_ARM_STYLE_ANY, + DWRITE_PANOSE_ARM_STYLE_NO_FIT, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_HORIZONTAL, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_WEDGE, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_VERTICAL, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_SINGLE_SERIF, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_DOUBLE_SERIF, + DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_HORIZONTAL, + DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_WEDGE, + DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_VERTICAL, + DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_SINGLE_SERIF, + DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_DOUBLE_SERIF, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_HORZ = DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_HORIZONTAL, + DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_VERT = DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_VERTICAL, + DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_HORZ = DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_HORIZONTAL, + DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_WEDGE = DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_WEDGE, + DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_VERT = DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_VERTICAL, + DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_SINGLE_SERIF = DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_SINGLE_SERIF, + DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_DOUBLE_SERIF = DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_DOUBLE_SERIF +} DWRITE_PANOSE_ARM_STYLE; + +typedef enum DWRITE_PANOSE_LETTERFORM +{ + DWRITE_PANOSE_LETTERFORM_ANY, + DWRITE_PANOSE_LETTERFORM_NO_FIT, + DWRITE_PANOSE_LETTERFORM_NORMAL_CONTACT, + DWRITE_PANOSE_LETTERFORM_NORMAL_WEIGHTED, + DWRITE_PANOSE_LETTERFORM_NORMAL_BOXED, + DWRITE_PANOSE_LETTERFORM_NORMAL_FLATTENED, + DWRITE_PANOSE_LETTERFORM_NORMAL_ROUNDED, + DWRITE_PANOSE_LETTERFORM_NORMAL_OFF_CENTER, + DWRITE_PANOSE_LETTERFORM_NORMAL_SQUARE, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_CONTACT, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_WEIGHTED, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_BOXED, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_FLATTENED, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_ROUNDED, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_OFF_CENTER, + DWRITE_PANOSE_LETTERFORM_OBLIQUE_SQUARE +} DWRITE_PANOSE_LETTERFORM; + +typedef enum DWRITE_PANOSE_MIDLINE +{ + DWRITE_PANOSE_MIDLINE_ANY, + DWRITE_PANOSE_MIDLINE_NO_FIT, + DWRITE_PANOSE_MIDLINE_STANDARD_TRIMMED, + DWRITE_PANOSE_MIDLINE_STANDARD_POINTED, + DWRITE_PANOSE_MIDLINE_STANDARD_SERIFED, + DWRITE_PANOSE_MIDLINE_HIGH_TRIMMED, + DWRITE_PANOSE_MIDLINE_HIGH_POINTED, + DWRITE_PANOSE_MIDLINE_HIGH_SERIFED, + DWRITE_PANOSE_MIDLINE_CONSTANT_TRIMMED, + DWRITE_PANOSE_MIDLINE_CONSTANT_POINTED, + DWRITE_PANOSE_MIDLINE_CONSTANT_SERIFED, + DWRITE_PANOSE_MIDLINE_LOW_TRIMMED, + DWRITE_PANOSE_MIDLINE_LOW_POINTED, + DWRITE_PANOSE_MIDLINE_LOW_SERIFED +} DWRITE_PANOSE_MIDLINE; + +typedef enum DWRITE_PANOSE_XHEIGHT +{ + DWRITE_PANOSE_XHEIGHT_ANY, + DWRITE_PANOSE_XHEIGHT_NO_FIT, + DWRITE_PANOSE_XHEIGHT_CONSTANT_SMALL, + DWRITE_PANOSE_XHEIGHT_CONSTANT_STANDARD, + DWRITE_PANOSE_XHEIGHT_CONSTANT_LARGE, + DWRITE_PANOSE_XHEIGHT_DUCKING_SMALL, + DWRITE_PANOSE_XHEIGHT_DUCKING_STANDARD, + DWRITE_PANOSE_XHEIGHT_DUCKING_LARGE, + DWRITE_PANOSE_XHEIGHT_CONSTANT_STD = DWRITE_PANOSE_XHEIGHT_CONSTANT_STANDARD, + DWRITE_PANOSE_XHEIGHT_DUCKING_STD = DWRITE_PANOSE_XHEIGHT_DUCKING_STANDARD +} DWRITE_PANOSE_XHEIGHT; + +typedef enum DWRITE_PANOSE_TOOL_KIND +{ + DWRITE_PANOSE_TOOL_KIND_ANY, + DWRITE_PANOSE_TOOL_KIND_NO_FIT, + DWRITE_PANOSE_TOOL_KIND_FLAT_NIB, + DWRITE_PANOSE_TOOL_KIND_PRESSURE_POINT, + DWRITE_PANOSE_TOOL_KIND_ENGRAVED, + DWRITE_PANOSE_TOOL_KIND_BALL, + DWRITE_PANOSE_TOOL_KIND_BRUSH, + DWRITE_PANOSE_TOOL_KIND_ROUGH, + DWRITE_PANOSE_TOOL_KIND_FELT_PEN_BRUSH_TIP, + DWRITE_PANOSE_TOOL_KIND_WILD_BRUSH +} DWRITE_PANOSE_TOOL_KIND; + +typedef enum DWRITE_PANOSE_SPACING +{ + DWRITE_PANOSE_SPACING_ANY, + DWRITE_PANOSE_SPACING_NO_FIT, + DWRITE_PANOSE_SPACING_PROPORTIONAL_SPACED, + DWRITE_PANOSE_SPACING_MONOSPACED +} DWRITE_PANOSE_SPACING; + +typedef enum DWRITE_PANOSE_ASPECT_RATIO +{ + DWRITE_PANOSE_ASPECT_RATIO_ANY, + DWRITE_PANOSE_ASPECT_RATIO_NO_FIT, + DWRITE_PANOSE_ASPECT_RATIO_VERY_CONDENSED, + DWRITE_PANOSE_ASPECT_RATIO_CONDENSED, + DWRITE_PANOSE_ASPECT_RATIO_NORMAL, + DWRITE_PANOSE_ASPECT_RATIO_EXPANDED, + DWRITE_PANOSE_ASPECT_RATIO_VERY_EXPANDED +} DWRITE_PANOSE_ASPECT_RATIO; + +typedef enum DWRITE_PANOSE_SCRIPT_TOPOLOGY +{ + DWRITE_PANOSE_SCRIPT_TOPOLOGY_ANY, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_NO_FIT, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_ROMAN_DISCONNECTED, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_ROMAN_TRAILING, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_ROMAN_CONNECTED, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_CURSIVE_DISCONNECTED, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_CURSIVE_TRAILING, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_CURSIVE_CONNECTED, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_BLACKLETTER_DISCONNECTED, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_BLACKLETTER_TRAILING, + DWRITE_PANOSE_SCRIPT_TOPOLOGY_BLACKLETTER_CONNECTED +} DWRITE_PANOSE_SCRIPT_TOPOLOGY; + +typedef enum DWRITE_PANOSE_SCRIPT_FORM +{ + DWRITE_PANOSE_SCRIPT_FORM_ANY, + DWRITE_PANOSE_SCRIPT_FORM_NO_FIT, + DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_NO_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_SOME_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_MORE_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_EXTREME_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_NO_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_SOME_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_MORE_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_EXTREME_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_NO_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_SOME_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_MORE_WRAPPING, + DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_EXTREME_WRAPPING +} DWRITE_PANOSE_SCRIPT_FORM; + +typedef enum DWRITE_PANOSE_FINIALS +{ + DWRITE_PANOSE_FINIALS_ANY, + DWRITE_PANOSE_FINIALS_NO_FIT, + DWRITE_PANOSE_FINIALS_NONE_NO_LOOPS, + DWRITE_PANOSE_FINIALS_NONE_CLOSED_LOOPS, + DWRITE_PANOSE_FINIALS_NONE_OPEN_LOOPS, + DWRITE_PANOSE_FINIALS_SHARP_NO_LOOPS, + DWRITE_PANOSE_FINIALS_SHARP_CLOSED_LOOPS, + DWRITE_PANOSE_FINIALS_SHARP_OPEN_LOOPS, + DWRITE_PANOSE_FINIALS_TAPERED_NO_LOOPS, + DWRITE_PANOSE_FINIALS_TAPERED_CLOSED_LOOPS, + DWRITE_PANOSE_FINIALS_TAPERED_OPEN_LOOPS, + DWRITE_PANOSE_FINIALS_ROUND_NO_LOOPS, + DWRITE_PANOSE_FINIALS_ROUND_CLOSED_LOOPS, + DWRITE_PANOSE_FINIALS_ROUND_OPEN_LOOPS +} DWRITE_PANOSE_FINIALS; + +typedef enum DWRITE_PANOSE_XASCENT +{ + DWRITE_PANOSE_XASCENT_ANY, + DWRITE_PANOSE_XASCENT_NO_FIT, + DWRITE_PANOSE_XASCENT_VERY_LOW, + DWRITE_PANOSE_XASCENT_LOW, + DWRITE_PANOSE_XASCENT_MEDIUM, + DWRITE_PANOSE_XASCENT_HIGH, + DWRITE_PANOSE_XASCENT_VERY_HIGH +} DWRITE_PANOSE_XASCENT; + +typedef enum DWRITE_PANOSE_DECORATIVE_CLASS +{ + DWRITE_PANOSE_DECORATIVE_CLASS_ANY, + DWRITE_PANOSE_DECORATIVE_CLASS_NO_FIT, + DWRITE_PANOSE_DECORATIVE_CLASS_DERIVATIVE, + DWRITE_PANOSE_DECORATIVE_CLASS_NONSTANDARD_TOPOLOGY, + DWRITE_PANOSE_DECORATIVE_CLASS_NONSTANDARD_ELEMENTS, + DWRITE_PANOSE_DECORATIVE_CLASS_NONSTANDARD_ASPECT, + DWRITE_PANOSE_DECORATIVE_CLASS_INITIALS, + DWRITE_PANOSE_DECORATIVE_CLASS_CARTOON, + DWRITE_PANOSE_DECORATIVE_CLASS_PICTURE_STEMS, + DWRITE_PANOSE_DECORATIVE_CLASS_ORNAMENTED, + DWRITE_PANOSE_DECORATIVE_CLASS_TEXT_AND_BACKGROUND, + DWRITE_PANOSE_DECORATIVE_CLASS_COLLAGE, + DWRITE_PANOSE_DECORATIVE_CLASS_MONTAGE +} DWRITE_PANOSE_DECORATIVE_CLASS; + +typedef enum DWRITE_PANOSE_ASPECT +{ + DWRITE_PANOSE_ASPECT_ANY, + DWRITE_PANOSE_ASPECT_NO_FIT, + DWRITE_PANOSE_ASPECT_SUPER_CONDENSED, + DWRITE_PANOSE_ASPECT_VERY_CONDENSED, + DWRITE_PANOSE_ASPECT_CONDENSED, + DWRITE_PANOSE_ASPECT_NORMAL, + DWRITE_PANOSE_ASPECT_EXTENDED, + DWRITE_PANOSE_ASPECT_VERY_EXTENDED, + DWRITE_PANOSE_ASPECT_SUPER_EXTENDED, + DWRITE_PANOSE_ASPECT_MONOSPACED +} DWRITE_PANOSE_ASPECT; + +typedef enum DWRITE_PANOSE_FILL +{ + DWRITE_PANOSE_FILL_ANY, + DWRITE_PANOSE_FILL_NO_FIT, + DWRITE_PANOSE_FILL_STANDARD_SOLID_FILL, + DWRITE_PANOSE_FILL_NO_FILL, + DWRITE_PANOSE_FILL_PATTERNED_FILL, + DWRITE_PANOSE_FILL_COMPLEX_FILL, + DWRITE_PANOSE_FILL_SHAPED_FILL, + DWRITE_PANOSE_FILL_DRAWN_DISTRESSED +} DWRITE_PANOSE_FILL; + +typedef enum DWRITE_PANOSE_LINING +{ + DWRITE_PANOSE_LINING_ANY, + DWRITE_PANOSE_LINING_NO_FIT, + DWRITE_PANOSE_LINING_NONE, + DWRITE_PANOSE_LINING_INLINE, + DWRITE_PANOSE_LINING_OUTLINE, + DWRITE_PANOSE_LINING_ENGRAVED, + DWRITE_PANOSE_LINING_SHADOW, + DWRITE_PANOSE_LINING_RELIEF, + DWRITE_PANOSE_LINING_BACKDROP +} DWRITE_PANOSE_LINING; + +typedef enum DWRITE_PANOSE_DECORATIVE_TOPOLOGY +{ + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_ANY, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_NO_FIT, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_STANDARD, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_SQUARE, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_MULTIPLE_SEGMENT, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_ART_DECO, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_UNEVEN_WEIGHTING, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_DIVERSE_ARMS, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_DIVERSE_FORMS, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_LOMBARDIC_FORMS, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_UPPER_CASE_IN_LOWER_CASE, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_IMPLIED_TOPOLOGY, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_HORSESHOE_E_AND_A, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_CURSIVE, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_BLACKLETTER, + DWRITE_PANOSE_DECORATIVE_TOPOLOGY_SWASH_VARIANCE +} DWRITE_PANOSE_DECORATIVE_TOPOLOGY; + +typedef enum DWRITE_PANOSE_CHARACTER_RANGES +{ + DWRITE_PANOSE_CHARACTER_RANGES_ANY, + DWRITE_PANOSE_CHARACTER_RANGES_NO_FIT, + DWRITE_PANOSE_CHARACTER_RANGES_EXTENDED_COLLECTION, + DWRITE_PANOSE_CHARACTER_RANGES_LITERALS, + DWRITE_PANOSE_CHARACTER_RANGES_NO_LOWER_CASE, + DWRITE_PANOSE_CHARACTER_RANGES_SMALL_CAPS +} DWRITE_PANOSE_CHARACTER_RANGES; + +typedef enum DWRITE_PANOSE_SYMBOL_KIND +{ + DWRITE_PANOSE_SYMBOL_KIND_ANY, + DWRITE_PANOSE_SYMBOL_KIND_NO_FIT, + DWRITE_PANOSE_SYMBOL_KIND_MONTAGES, + DWRITE_PANOSE_SYMBOL_KIND_PICTURES, + DWRITE_PANOSE_SYMBOL_KIND_SHAPES, + DWRITE_PANOSE_SYMBOL_KIND_SCIENTIFIC, + DWRITE_PANOSE_SYMBOL_KIND_MUSIC, + DWRITE_PANOSE_SYMBOL_KIND_EXPERT, + DWRITE_PANOSE_SYMBOL_KIND_PATTERNS, + DWRITE_PANOSE_SYMBOL_KIND_BOARDERS, + DWRITE_PANOSE_SYMBOL_KIND_ICONS, + DWRITE_PANOSE_SYMBOL_KIND_LOGOS, + DWRITE_PANOSE_SYMBOL_KIND_INDUSTRY_SPECIFIC +} DWRITE_PANOSE_SYMBOL_KIND; + +typedef enum DWRITE_PANOSE_SYMBOL_ASPECT_RATIO +{ + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_ANY, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NO_FIT, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NO_WIDTH, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_EXCEPTIONALLY_WIDE, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_SUPER_WIDE, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_VERY_WIDE, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_WIDE, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NORMAL, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NARROW, + DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_VERY_NARROW +} DWRITE_PANOSE_SYMBOL_ASPECT_RATIO; + +typedef enum DWRITE_OUTLINE_THRESHOLD +{ + DWRITE_OUTLINE_THRESHOLD_ANTIALIASED, + DWRITE_OUTLINE_THRESHOLD_ALIASED +} DWRITE_OUTLINE_THRESHOLD; + +typedef enum DWRITE_BASELINE +{ + DWRITE_BASELINE_DEFAULT, + DWRITE_BASELINE_ROMAN, + DWRITE_BASELINE_CENTRAL, + DWRITE_BASELINE_MATH, + DWRITE_BASELINE_HANGING, + DWRITE_BASELINE_IDEOGRAPHIC_BOTTOM, + DWRITE_BASELINE_IDEOGRAPHIC_TOP, + DWRITE_BASELINE_MINIMUM, + DWRITE_BASELINE_MAXIMUM +} DWRITE_BASELINE; + +typedef enum DWRITE_VERTICAL_GLYPH_ORIENTATION +{ + DWRITE_VERTICAL_GLYPH_ORIENTATION_DEFAULT, + DWRITE_VERTICAL_GLYPH_ORIENTATION_STACKED +} DWRITE_VERTICAL_GLYPH_ORIENTATION; + +typedef enum DWRITE_GLYPH_ORIENTATION_ANGLE +{ + DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES, + DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES, + DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES, + DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES +} DWRITE_GLYPH_ORIENTATION_ANGLE; + +typedef struct DWRITE_FONT_METRICS1 +{ + UINT16 designUnitsPerEm; + UINT16 ascent; + UINT16 descent; + INT16 lineGap; + UINT16 capHeight; + UINT16 xHeight; + INT16 underlinePosition; + UINT16 underlineThickness; + INT16 strikethroughPosition; + UINT16 strikethroughThickness; + INT16 glyphBoxLeft; + INT16 glyphBoxTop; + INT16 glyphBoxRight; + INT16 glyphBoxBottom; + INT16 subscriptPositionX; + INT16 subscriptPositionY; + INT16 subscriptSizeX; + INT16 subscriptSizeY; + INT16 superscriptPositionX; + INT16 superscriptPositionY; + INT16 superscriptSizeX; + INT16 superscriptSizeY; + BOOL hasTypographicMetrics; +} DWRITE_FONT_METRICS1; + +typedef struct DWRITE_CARET_METRICS +{ + INT16 slopeRise; + INT16 slopeRun; + INT16 offset; +} DWRITE_CARET_METRICS; + +typedef union DWRITE_PANOSE +{ + UINT8 values[10]; + UINT8 familyKind; + struct + { + UINT8 familyKind; + UINT8 serifStyle; + UINT8 weight; + UINT8 proportion; + UINT8 contrast; + UINT8 strokeVariation; + UINT8 armStyle; + UINT8 letterform; + UINT8 midline; + UINT8 xHeight; + } text; + struct + { + UINT8 familyKind; + UINT8 toolKind; + UINT8 weight; + UINT8 spacing; + UINT8 aspectRatio; + UINT8 contrast; + UINT8 scriptTopology; + UINT8 scriptForm; + UINT8 finials; + UINT8 xAscent; + } script; + struct + { + UINT8 familyKind; + UINT8 decorativeClass; + UINT8 weight; + UINT8 aspect; + UINT8 contrast; + UINT8 serifVariant; + UINT8 fill; + UINT8 lining; + UINT8 decorativeTopology; + UINT8 characterRange; + } decorative; + struct + { + UINT8 familyKind; + UINT8 symbolKind; + UINT8 weight; + UINT8 spacing; + UINT8 aspectRatioAndContrast; + UINT8 aspectRatio94; + UINT8 aspectRatio119; + UINT8 aspectRatio157; + UINT8 aspectRatio163; + UINT8 aspectRatio211; + } symbol; +} DWRITE_PANOSE; + +typedef struct DWRITE_UNICODE_RANGE +{ + UINT32 first; + UINT32 last; +} DWRITE_UNICODE_RANGE; + +typedef struct DWRITE_SCRIPT_PROPERTIES +{ + UINT32 isoScriptCode; + UINT32 isoScriptNumber; + UINT32 clusterLookahead; + UINT32 justificationCharacter; + UINT32 restrictCaretToClusters : 1; + UINT32 usesWordDividers : 1; + UINT32 isDiscreteWriting : 1; + UINT32 isBlockWriting : 1; + UINT32 isDistributedWithinCluster : 1; + UINT32 isConnectedWriting : 1; + UINT32 isCursiveWriting : 1; + UINT32 reserved : 25; +} DWRITE_SCRIPT_PROPERTIES; + +typedef struct DWRITE_JUSTIFICATION_OPPORTUNITY +{ + FLOAT expansionMinimum; + FLOAT expansionMaximum; + FLOAT compressionMaximum; + UINT32 expansionPriority : 8; + UINT32 compressionPriority : 8; + UINT32 allowResidualExpansion : 1; + UINT32 allowResidualCompression : 1; + UINT32 applyToLeadingEdge : 1; + UINT32 applyToTrailingEdge : 1; + UINT32 reserved : 12; +} DWRITE_JUSTIFICATION_OPPORTUNITY; + +interface IDWriteTextAnalysisSource1; +interface IDWriteTextAnalysisSink1; +interface IDWriteRenderingParams1; + +[ +local, +object, +uuid(30572f99-dac6-41db-a16e-0486307e606a) +] +interface IDWriteFactory1 : IDWriteFactory +{ + HRESULT GetEudcFontCollection( + [out] IDWriteFontCollection **collection, + [in, defaultvalue(FALSE)] BOOL check_for_updates + ); + HRESULT CreateCustomRenderingParams( + [in] FLOAT gamma, + [in] FLOAT enhcontrast, + [in] FLOAT enhcontrast_grayscale, + [in] FLOAT cleartype_level, + [in] DWRITE_PIXEL_GEOMETRY geometry, + [in] DWRITE_RENDERING_MODE mode, + [out] IDWriteRenderingParams1 **params + ); +} + +[ +local, +object, +uuid(a71efdb4-9fdb-4838-ad90-cfc3be8c3daf) +] +interface IDWriteFontFace1 : IDWriteFontFace +{ + void GetMetrics( + [out] DWRITE_FONT_METRICS1 *metrics + ); + HRESULT GetGdiCompatibleMetrics( + [in] FLOAT em_size, + [in] FLOAT pixels_per_dip, + [in] const DWRITE_MATRIX *transform, + [out] DWRITE_FONT_METRICS1 *metrics + ); + void GetCaretMetrics( + [out] DWRITE_CARET_METRICS *metrics + ); + HRESULT GetUnicodeRanges( + [in] UINT32 max_count, + [out] DWRITE_UNICODE_RANGE *ranges, + [out] UINT32 *count + ); + BOOL IsMonospacedFont(); + HRESULT GetDesignGlyphAdvances( + [in] UINT32 glyph_count, + [in] UINT16 const *indices, + [out] INT32 *advances, + [in, defaultvalue(FALSE)] BOOL is_sideways + ); + HRESULT GetGdiCompatibleGlyphAdvances( + [in] FLOAT em_size, + [in] FLOAT pixels_per_dip, + [in] const DWRITE_MATRIX *transform, + [in] BOOL use_gdi_natural, + [in] BOOL is_sideways, + [in] UINT32 glyph_count, + [in] const UINT16 *indices, + [out] INT32 *advances + ); + HRESULT GetKerningPairAdjustments( + [in] UINT32 glyph_count, + [in] const UINT16 *indices, + [out] INT32 *adjustments + ); + BOOL HasKerningPairs(); + HRESULT GetRecommendedRenderingMode( + [in] FLOAT font_emsize, + [in] FLOAT dpiX, + [in] FLOAT dpiY, + [in] const DWRITE_MATRIX *transform, + [in] BOOL is_sideways, + [in] DWRITE_OUTLINE_THRESHOLD threshold, + [in] DWRITE_MEASURING_MODE measuring_mode, + [out] DWRITE_RENDERING_MODE *rendering_mode + ); + HRESULT GetVerticalGlyphVariants( + [in] UINT32 glyph_count, + [in] const UINT16 *nominal_indices, + [out] UINT16 *vertical_indices + ); + BOOL HasVerticalGlyphVariants(); +} + +[ +local, +object, +uuid(acd16696-8c14-4f5d-877e-fe3fc1d32738) +] +interface IDWriteFont1 : IDWriteFont +{ + void GetMetrics( + [out] DWRITE_FONT_METRICS1 *metrics + ); + void GetPanose( + [out] DWRITE_PANOSE *panose + ); + HRESULT GetUnicodeRanges( + [in] UINT32 max_count, + [out] DWRITE_UNICODE_RANGE *ranges, + [out] UINT32 *count + ); + BOOL IsMonospacedFont(); +} + +[ +local, +object, +uuid(94413cf4-a6fc-4248-8b50-6674348fcad3) +] +interface IDWriteRenderingParams1 : IDWriteRenderingParams +{ + FLOAT GetGrayscaleEnhancedContrast(); +} + +[ +local, +object, +uuid(80dad800-e21f-4e83-96ce-bfcce500db7c) +] +interface IDWriteTextAnalyzer1 : IDWriteTextAnalyzer +{ + HRESULT ApplyCharacterSpacing( + [in] FLOAT leading_spacing, + [in] FLOAT trailing_spacing, + [in] FLOAT min_advance_width, + [in] UINT32 len, + [in] UINT32 glyph_count, + [in] UINT16 const *clustermap, + [in] FLOAT const *advances, + [in] DWRITE_GLYPH_OFFSET const *offsets, + [in] DWRITE_SHAPING_GLYPH_PROPERTIES const *props, + [out] FLOAT *modified_advances, + [out] DWRITE_GLYPH_OFFSET *modified_offsets + ); + HRESULT GetBaseline( + [in] IDWriteFontFace *face, + [in] DWRITE_BASELINE baseline, + [in] BOOL vertical, + [in] BOOL is_simulation_allowed, + [in] DWRITE_SCRIPT_ANALYSIS sa, + [in] const WCHAR *localeName, + [out] INT32 *baseline_coord, + [out] BOOL *exists + ); + HRESULT AnalyzeVerticalGlyphOrientation( + [in] IDWriteTextAnalysisSource1 *source, + [in] UINT32 text_pos, + [in] UINT32 len, + [out] IDWriteTextAnalysisSink1 *sink + ); + HRESULT GetGlyphOrientationTransform( + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] BOOL is_sideways, + [out] DWRITE_MATRIX *transform + ); + HRESULT GetScriptProperties( + [in] DWRITE_SCRIPT_ANALYSIS sa, + [out] DWRITE_SCRIPT_PROPERTIES *props + ); + HRESULT GetTextComplexity( + [in] const WCHAR *text, + [in] UINT32 len, + [in] IDWriteFontFace *face, + [out] BOOL *is_simple, + [out] UINT32 *len_read, + [out] UINT16 *indices + ); + HRESULT GetJustificationOpportunities( + [in] IDWriteFontFace *face, + [in] FLOAT font_em_size, + [in] DWRITE_SCRIPT_ANALYSIS sa, + [in] UINT32 length, + [in] UINT32 glyph_count, + [in] const WCHAR *text, + [in] const UINT16 *clustermap, + [in] const DWRITE_SHAPING_GLYPH_PROPERTIES *prop, + [out] DWRITE_JUSTIFICATION_OPPORTUNITY *jo + ); + HRESULT JustifyGlyphAdvances( + [in] FLOAT width, + [in] UINT32 glyph_count, + [in] const DWRITE_JUSTIFICATION_OPPORTUNITY *jo, + [in] const FLOAT *advances, + [in] const DWRITE_GLYPH_OFFSET *offsets, + [out] FLOAT *justifiedadvances, + [out] DWRITE_GLYPH_OFFSET *justifiedoffsets + ); + HRESULT GetJustifiedGlyphs( + [in] IDWriteFontFace *face, + [in] FLOAT font_em_size, + [in] DWRITE_SCRIPT_ANALYSIS sa, + [in] UINT32 length, + [in] UINT32 glyph_count, + [in] UINT32 max_glyphcount, + [in] const UINT16 *clustermap, + [in] const UINT16 *indices, + [in] const FLOAT *advances, + [in] const FLOAT *justifiedadvances, + [in] const DWRITE_GLYPH_OFFSET *justifiedoffsets, + [in] const DWRITE_SHAPING_GLYPH_PROPERTIES *prop, + [out] UINT32 *actual_count, + [out] UINT16 *modified_clustermap, + [out] UINT16 *modified_indices, + [out] FLOAT *modified_advances, + [out] DWRITE_GLYPH_OFFSET *modified_offsets + ); +} + +[ +local, +object, +uuid(639cfad8-0fb4-4b21-a58a-067920120009) +] +interface IDWriteTextAnalysisSource1 : IDWriteTextAnalysisSource +{ + HRESULT GetVerticalGlyphOrientation( + [in] UINT32 pos, + [out] UINT32 *length, + [out] DWRITE_VERTICAL_GLYPH_ORIENTATION *orientation, + [out] UINT8 *bidi_level + ); +} + +[ +local, +object, +uuid(b0d941a0-85e7-4d8b-9fd3-5ced9934482a) +] +interface IDWriteTextAnalysisSink1 : IDWriteTextAnalysisSink +{ + HRESULT SetGlyphOrientation( + [in] UINT32 pos, + [in] UINT32 length, + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] UINT8 adjusted_bidilevel, + [in] BOOL is_sideways, + [in] BOOL is_rtl + ); +} + +[ +local, +object, +uuid(9064d822-80a7-465c-a986-df65f78b8feb) +] +interface IDWriteTextLayout1 : IDWriteTextLayout +{ + HRESULT SetPairKerning( + [in] BOOL is_pairkerning_enabled, + [in] DWRITE_TEXT_RANGE range); + + HRESULT GetPairKerning( + [in] UINT32 position, + [out] BOOL *is_pairkerning_enabled, + [out] DWRITE_TEXT_RANGE *range); + + HRESULT SetCharacterSpacing( + [in] FLOAT leading_spacing, + [in] FLOAT trailing_spacing, + [in] FLOAT minimum_advance_width, + [in] DWRITE_TEXT_RANGE range); + + HRESULT GetCharacterSpacing( + [in] UINT32 position, + [out] FLOAT *leading_spacing, + [out] FLOAT *trailing_spacing, + [out] FLOAT *minimum_advance_width, + [out, defaultvalue(NULL)] DWRITE_TEXT_RANGE *range + ); +} + +typedef enum DWRITE_TEXT_ANTIALIAS_MODE +{ + DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE, + DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE +} DWRITE_TEXT_ANTIALIAS_MODE; + +[ +local, +object, +uuid(791e8298-3ef3-4230-9880-c9bdecc42064) +] +interface IDWriteBitmapRenderTarget1 : IDWriteBitmapRenderTarget +{ + DWRITE_TEXT_ANTIALIAS_MODE GetTextAntialiasMode(); + HRESULT SetTextAntialiasMode( + [in] DWRITE_TEXT_ANTIALIAS_MODE mode + ); +} diff --git a/WineFix/lib/d2d1/include/windows/dwrite_2.idl b/WineFix/lib/d2d1/include/windows/dwrite_2.idl new file mode 100644 index 0000000..c779906 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dwrite_2.idl @@ -0,0 +1,375 @@ +/* + * Copyright 2014 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dwrite_1.idl"; + +typedef enum DWRITE_OPTICAL_ALIGNMENT +{ + DWRITE_OPTICAL_ALIGNMENT_NONE, + DWRITE_OPTICAL_ALIGNMENT_NO_SIDE_BEARINGS +} DWRITE_OPTICAL_ALIGNMENT; + +typedef enum DWRITE_GRID_FIT_MODE +{ + DWRITE_GRID_FIT_MODE_DEFAULT, + DWRITE_GRID_FIT_MODE_DISABLED, + DWRITE_GRID_FIT_MODE_ENABLED +} DWRITE_GRID_FIT_MODE; + +typedef struct DWRITE_TEXT_METRICS1 +{ + /* DWRITE_TEXT_METRICS fields */ + FLOAT left; + FLOAT top; + FLOAT width; + FLOAT widthIncludingTrailingWhitespace; + FLOAT height; + FLOAT layoutWidth; + FLOAT layoutHeight; + UINT32 maxBidiReorderingDepth; + UINT32 lineCount; + /* DWRITE_TEXT_METRICS1 fields */ + FLOAT heightIncludingTrailingWhitespace; +} DWRITE_TEXT_METRICS1; + +cpp_quote("#ifndef D3DCOLORVALUE_DEFINED") +typedef struct _D3DCOLORVALUE +{ + union { + FLOAT r; + FLOAT dvR; + }; + union { + FLOAT g; + FLOAT dvG; + }; + union { + FLOAT b; + FLOAT dvB; + }; + union { + FLOAT a; + FLOAT dvA; + }; +} D3DCOLORVALUE; +cpp_quote("#define D3DCOLORVALUE_DEFINED") +cpp_quote("#endif") + +typedef D3DCOLORVALUE DWRITE_COLOR_F; + +typedef struct DWRITE_COLOR_GLYPH_RUN +{ + DWRITE_GLYPH_RUN glyphRun; + DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription; + FLOAT baselineOriginX; + FLOAT baselineOriginY; + DWRITE_COLOR_F runColor; + UINT16 paletteIndex; +} DWRITE_COLOR_GLYPH_RUN; + +[ + local, + object, + uuid(d3e0e934-22a0-427e-aae4-7d9574b59db1) +] +interface IDWriteTextRenderer1 : IDWriteTextRenderer +{ + HRESULT DrawGlyphRun( + [in] void *context, + [in] FLOAT originX, + [in] FLOAT originY, + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] DWRITE_MEASURING_MODE mode, + [in] DWRITE_GLYPH_RUN const *run, + [in] DWRITE_GLYPH_RUN_DESCRIPTION const *rundescr, + [in] IUnknown *effect + ); + HRESULT DrawUnderline( + [in] void *context, + [in] FLOAT originX, + [in] FLOAT originY, + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] DWRITE_UNDERLINE const *underline, + [in] IUnknown *effect + ); + HRESULT DrawStrikethrough( + [in] void *context, + [in] FLOAT originX, + [in] FLOAT originY, + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] DWRITE_STRIKETHROUGH const *strikethrough, + [in] IUnknown *effect + ); + HRESULT DrawInlineObject( + [in] void *context, + [in] FLOAT originX, + [in] FLOAT originY, + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] IDWriteInlineObject *inlineObject, + [in] BOOL is_sideways, + [in] BOOL is_rtl, + [in] IUnknown *effect + ); +} + +[ + local, + object, + uuid(efa008f9-f7a1-48bf-b05c-f224713cc0ff) +] +interface IDWriteFontFallback : IUnknown +{ + HRESULT MapCharacters( + [in] IDWriteTextAnalysisSource *source, + [in] UINT32 position, + [in] UINT32 length, + [in] IDWriteFontCollection *basecollection, + [in] const WCHAR *baseFamilyName, + [in] DWRITE_FONT_WEIGHT baseWeight, + [in] DWRITE_FONT_STYLE baseStyle, + [in] DWRITE_FONT_STRETCH baseStretch, + [out] UINT32 *mappedLength, + [out] IDWriteFont **mappedFont, + [out] FLOAT *scale + ); +} + +[ + local, + object, + uuid(5f174b49-0d8b-4cfb-8bca-f1cce9d06c67) +] +interface IDWriteTextFormat1 : IDWriteTextFormat +{ + HRESULT SetVerticalGlyphOrientation( + [in] DWRITE_VERTICAL_GLYPH_ORIENTATION orientation); + DWRITE_VERTICAL_GLYPH_ORIENTATION GetVerticalGlyphOrientation(); + HRESULT SetLastLineWrapping( + [in] BOOL lastline_wrapping_enabled + ); + BOOL GetLastLineWrapping(); + HRESULT SetOpticalAlignment( + [in] DWRITE_OPTICAL_ALIGNMENT alignment + ); + DWRITE_OPTICAL_ALIGNMENT GetOpticalAlignment(); + HRESULT SetFontFallback( + [in] IDWriteFontFallback *fallback + ); + HRESULT GetFontFallback( + [in] IDWriteFontFallback **fallback + ); +} + +[ + local, + object, + uuid(1093c18f-8d5e-43f0-b064-0917311b525e) +] +interface IDWriteTextLayout2 : IDWriteTextLayout1 +{ + HRESULT GetMetrics( + [out] DWRITE_TEXT_METRICS1 *metrics + ); + HRESULT SetVerticalGlyphOrientation( + [in] DWRITE_VERTICAL_GLYPH_ORIENTATION orientation + ); + DWRITE_VERTICAL_GLYPH_ORIENTATION GetVerticalGlyphOrientation(); + HRESULT SetLastLineWrapping( + [in] BOOL lastline_wrapping_enabled + ); + BOOL GetLastLineWrapping(); + HRESULT SetOpticalAlignment( + [in] DWRITE_OPTICAL_ALIGNMENT alignment + ); + DWRITE_OPTICAL_ALIGNMENT GetOpticalAlignment(); + HRESULT SetFontFallback( + [in] IDWriteFontFallback *fallback + ); + HRESULT GetFontFallback( + [out] IDWriteFontFallback **fallback + ); +} + +[ + local, + object, + uuid(553a9ff3-5693-4df7-b52b-74806f7f2eb9) +] +interface IDWriteTextAnalyzer2 : IDWriteTextAnalyzer1 +{ + HRESULT GetGlyphOrientationTransform( + [in] DWRITE_GLYPH_ORIENTATION_ANGLE angle, + [in] BOOL is_sideways, + [in] FLOAT originX, + [in] FLOAT originY, + [out] DWRITE_MATRIX *transform + ); + HRESULT GetTypographicFeatures( + [in] IDWriteFontFace *fontface, + [in] DWRITE_SCRIPT_ANALYSIS analysis, + [in] const WCHAR *localeName, + [in] UINT32 max_tagcount, + [out] UINT32 *actual_tagcount, + [out] DWRITE_FONT_FEATURE_TAG *tags + ); + HRESULT CheckTypographicFeature( + [in] IDWriteFontFace *fontface, + [in] DWRITE_SCRIPT_ANALYSIS analysis, + [in] const WCHAR *localeName, + [in] DWRITE_FONT_FEATURE_TAG feature, + [in] UINT32 glyph_count, + [in] const UINT16 *indices, + [out] UINT8 *feature_applies + ); +} + +[ + local, + object, + uuid(fd882d06-8aba-4fb8-b849-8be8b73e14de) +] +interface IDWriteFontFallbackBuilder : IUnknown +{ + HRESULT AddMapping( + [in] const DWRITE_UNICODE_RANGE *ranges, + [in] UINT32 rangesCount, + [in] WCHAR const **targetFamilyNames, + [in] UINT32 targetFamilyNamesCount, + [in, defaultvalue(NULL)] IDWriteFontCollection *collection, + [in, defaultvalue(NULL)] WCHAR const *localeName, + [in, defaultvalue(NULL)] WCHAR const *baseFamilyName, + [in, defaultvalue(1)] FLOAT scale + ); + HRESULT AddMappings( + [in] IDWriteFontFallback *fallback + ); + HRESULT CreateFontFallback( + [out] IDWriteFontFallback **fallback + ); +} + +[ + local, + object, + uuid(29748ed6-8c9c-4a6a-be0b-d912e8538944) +] +interface IDWriteFont2 : IDWriteFont1 +{ + BOOL IsColorFont(); +} + +[ + local, + object, + uuid(d8b768ff-64bc-4e66-982b-ec8e87f693f7) +] +interface IDWriteFontFace2 : IDWriteFontFace1 +{ + BOOL IsColorFont(); + UINT32 GetColorPaletteCount(); + UINT32 GetPaletteEntryCount(); + HRESULT GetPaletteEntries( + [in] UINT32 palette_index, + [in] UINT32 first_entry_index, + [in] UINT32 entry_count, + [out] DWRITE_COLOR_F *entries + ); + HRESULT GetRecommendedRenderingMode( + [in] FLOAT fontEmSize, + [in] FLOAT dpiX, + [in] FLOAT dpiY, + [in] DWRITE_MATRIX const *transform, + [in] BOOL is_sideways, + [in] DWRITE_OUTLINE_THRESHOLD threshold, + [in] DWRITE_MEASURING_MODE measuringmode, + [in] IDWriteRenderingParams *params, + [out] DWRITE_RENDERING_MODE *renderingmode, + [out] DWRITE_GRID_FIT_MODE *gridfitmode + ); +} + +[ + local, + object, + uuid(d31fbe17-f157-41a2-8d24-cb779e0560e8) +] +interface IDWriteColorGlyphRunEnumerator : IUnknown +{ + HRESULT MoveNext( + [out] BOOL *hasRun + ); + HRESULT GetCurrentRun( + [out] DWRITE_COLOR_GLYPH_RUN const **run + ); +} + +[ + local, + object, + uuid(f9d711c3-9777-40ae-87e8-3e5aF9bf0948) +] +interface IDWriteRenderingParams2 : IDWriteRenderingParams1 +{ + DWRITE_GRID_FIT_MODE GetGridFitMode(); +} + +[ + local, + object, + uuid(0439fc60-ca44-4994-8dee-3a9af7b732ec) +] +interface IDWriteFactory2 : IDWriteFactory1 +{ + HRESULT GetSystemFontFallback( + [out] IDWriteFontFallback **fallback + ); + HRESULT CreateFontFallbackBuilder( + [out] IDWriteFontFallbackBuilder **fallbackbuilder + ); + HRESULT TranslateColorGlyphRun( + [in] FLOAT originX, + [in] FLOAT originY, + [in] const DWRITE_GLYPH_RUN *run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *rundescr, + [in] DWRITE_MEASURING_MODE mode, + [in] const DWRITE_MATRIX *transform, + [in] UINT32 palette_index, + [out] IDWriteColorGlyphRunEnumerator **colorlayers + ); + HRESULT CreateCustomRenderingParams( + [in] FLOAT gamma, + [in] FLOAT contrast, + [in] FLOAT grayscalecontrast, + [in] FLOAT cleartypeLevel, + [in] DWRITE_PIXEL_GEOMETRY pixelGeometry, + [in] DWRITE_RENDERING_MODE renderingMode, + [in] DWRITE_GRID_FIT_MODE gridFitMode, + [out] IDWriteRenderingParams2 **params + ); + HRESULT CreateGlyphRunAnalysis( + [in] const DWRITE_GLYPH_RUN *run, + [in] const DWRITE_MATRIX *transform, + [in] DWRITE_RENDERING_MODE renderingMode, + [in] DWRITE_MEASURING_MODE measuringMode, + [in] DWRITE_GRID_FIT_MODE gridFitMode, + [in] DWRITE_TEXT_ANTIALIAS_MODE antialiasMode, + [in] FLOAT originX, + [in] FLOAT originY, + [out] IDWriteGlyphRunAnalysis **analysis + ); +} diff --git a/WineFix/lib/d2d1/include/windows/dwrite_3.idl b/WineFix/lib/d2d1/include/windows/dwrite_3.idl new file mode 100644 index 0000000..398e4a0 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dwrite_3.idl @@ -0,0 +1,1585 @@ +/* + * Copyright 2016 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dwrite_2.idl"; + +interface IDWriteFontFaceReference; +interface IDWriteFontFaceReference1; +interface IDWriteFontFace3; +interface IDWriteFontSet; +interface IDWriteFontDownloadQueue; +interface IDWriteFontFace5; +interface IDWriteFontList2; + +cpp_quote("#ifndef _WINGDI_") +/* already defined in wingdi.h but needed for WIDL */ +typedef struct FONTSIGNATURE FONTSIGNATURE; +cpp_quote("#endif /* _WINGDI_ */") + +/* already defined in d2d1.idl */ +typedef struct D2D1_GRADIENT_STOP D2D1_GRADIENT_STOP; + +typedef enum DWRITE_COLOR_COMPOSITE_MODE +{ + DWRITE_COLOR_COMPOSITE_CLEAR, + DWRITE_COLOR_COMPOSITE_SRC, + DWRITE_COLOR_COMPOSITE_DEST, + DWRITE_COLOR_COMPOSITE_SRC_OVER, + DWRITE_COLOR_COMPOSITE_DEST_OVER, + DWRITE_COLOR_COMPOSITE_SRC_IN, + DWRITE_COLOR_COMPOSITE_DEST_IN, + DWRITE_COLOR_COMPOSITE_SRC_OUT, + DWRITE_COLOR_COMPOSITE_DEST_OUT, + DWRITE_COLOR_COMPOSITE_SRC_ATOP, + DWRITE_COLOR_COMPOSITE_DEST_ATOP, + DWRITE_COLOR_COMPOSITE_XOR, + DWRITE_COLOR_COMPOSITE_PLUS, + DWRITE_COLOR_COMPOSITE_SCREEN, + DWRITE_COLOR_COMPOSITE_OVERLAY, + DWRITE_COLOR_COMPOSITE_DARKEN, + DWRITE_COLOR_COMPOSITE_LIGHTEN, + DWRITE_COLOR_COMPOSITE_COLOR_DODGE, + DWRITE_COLOR_COMPOSITE_COLOR_BURN, + DWRITE_COLOR_COMPOSITE_HARD_LIGHT, + DWRITE_COLOR_COMPOSITE_SOFT_LIGHT, + DWRITE_COLOR_COMPOSITE_DIFFERENCE, + DWRITE_COLOR_COMPOSITE_EXCLUSION, + DWRITE_COLOR_COMPOSITE_MULTIPLY, + DWRITE_COLOR_COMPOSITE_HSL_HUE, + DWRITE_COLOR_COMPOSITE_HSL_SATURATION, + DWRITE_COLOR_COMPOSITE_HSL_COLOR, + DWRITE_COLOR_COMPOSITE_HSL_LUMINOSITY, +} DWRITE_COLOR_COMPOSITE_MODE; + +typedef enum DWRITE_LOCALITY +{ + DWRITE_LOCALITY_REMOTE, + DWRITE_LOCALITY_PARTIAL, + DWRITE_LOCALITY_LOCAL +} DWRITE_LOCALITY; + +typedef enum DWRITE_RENDERING_MODE1 +{ + DWRITE_RENDERING_MODE1_DEFAULT, + DWRITE_RENDERING_MODE1_ALIASED, + DWRITE_RENDERING_MODE1_GDI_CLASSIC, + DWRITE_RENDERING_MODE1_GDI_NATURAL, + DWRITE_RENDERING_MODE1_NATURAL, + DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC, + DWRITE_RENDERING_MODE1_OUTLINE, + DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED +} DWRITE_RENDERING_MODE1; + +typedef enum DWRITE_FONT_PROPERTY_ID +{ + DWRITE_FONT_PROPERTY_ID_NONE, + DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FAMILY_NAME, + DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FAMILY_NAME, + DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FACE_NAME, + DWRITE_FONT_PROPERTY_ID_FULL_NAME, + DWRITE_FONT_PROPERTY_ID_WIN32_FAMILY_NAME, + DWRITE_FONT_PROPERTY_ID_POSTSCRIPT_NAME, + DWRITE_FONT_PROPERTY_ID_DESIGN_SCRIPT_LANGUAGE_TAG, + DWRITE_FONT_PROPERTY_ID_SUPPORTED_SCRIPT_LANGUAGE_TAG, + DWRITE_FONT_PROPERTY_ID_SEMANTIC_TAG, + DWRITE_FONT_PROPERTY_ID_WEIGHT, + DWRITE_FONT_PROPERTY_ID_STRETCH, + DWRITE_FONT_PROPERTY_ID_STYLE, + DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME, + DWRITE_FONT_PROPERTY_ID_TOTAL = DWRITE_FONT_PROPERTY_ID_STYLE + 1, + DWRITE_FONT_PROPERTY_ID_TOTAL_RS3 = DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME + 1, + DWRITE_FONT_PROPERTY_ID_FAMILY_NAME = DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FAMILY_NAME, + DWRITE_FONT_PROPERTY_ID_PREFERRED_FAMILY_NAME = DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FAMILY_NAME, + DWRITE_FONT_PROPERTY_ID_FACE_NAME = DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FACE_NAME, +} DWRITE_FONT_PROPERTY_ID; + +typedef struct DWRITE_FONT_PROPERTY +{ + DWRITE_FONT_PROPERTY_ID propertyId; + WCHAR const *propertyValue; + WCHAR const *localeName; +} DWRITE_FONT_PROPERTY; + +cpp_quote("#ifdef __cplusplus") +cpp_quote("#define DWRITE_MAKE_FONT_AXIS_TAG(a,b,c,d) (static_cast(DWRITE_MAKE_OPENTYPE_TAG(a,b,c,d)))") +cpp_quote("#else") +cpp_quote("#define DWRITE_MAKE_FONT_AXIS_TAG(a,b,c,d) (DWRITE_MAKE_OPENTYPE_TAG(a,b,c,d))") +cpp_quote("#endif") + +typedef enum DWRITE_FONT_AXIS_TAG +{ + DWRITE_FONT_AXIS_TAG_WEIGHT = 0x74686777, /* 'wght' */ + DWRITE_FONT_AXIS_TAG_WIDTH = 0x68746477, /* 'wdth' */ + DWRITE_FONT_AXIS_TAG_SLANT = 0x746e6c73, /* 'slnt' */ + DWRITE_FONT_AXIS_TAG_OPTICAL_SIZE = 0x7a73706f, /* 'opsz' */ + DWRITE_FONT_AXIS_TAG_ITALIC = 0x6c617469, /* 'ital' */ +} DWRITE_FONT_AXIS_TAG; + +typedef enum DWRITE_FONT_SOURCE_TYPE +{ + DWRITE_FONT_SOURCE_TYPE_UNKNOWN, + DWRITE_FONT_SOURCE_TYPE_PER_MACHINE, + DWRITE_FONT_SOURCE_TYPE_PER_USER, + DWRITE_FONT_SOURCE_TYPE_APPX_PACKAGE, + DWRITE_FONT_SOURCE_TYPE_REMOTE_FONT_PROVIDER +} DWRITE_FONT_SOURCE_TYPE; + +typedef struct DWRITE_FONT_AXIS_VALUE +{ + DWRITE_FONT_AXIS_TAG axisTag; + FLOAT value; +} DWRITE_FONT_AXIS_VALUE; + +typedef struct DWRITE_FONT_AXIS_RANGE +{ + DWRITE_FONT_AXIS_TAG axisTag; + FLOAT minValue; + FLOAT maxValue; +} DWRITE_FONT_AXIS_RANGE; + +typedef enum DWRITE_AUTOMATIC_FONT_AXES +{ + DWRITE_AUTOMATIC_FONT_AXES_NONE, + DWRITE_AUTOMATIC_FONT_AXES_OPTICAL_SIZE, +} DWRITE_AUTOMATIC_FONT_AXES; + +typedef enum DWRITE_FONT_AXIS_ATTRIBUTES +{ + DWRITE_FONT_AXIS_ATTRIBUTES_NONE, + DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE, + DWRITE_FONT_AXIS_ATTRIBUTES_HIDDEN, +} DWRITE_FONT_AXIS_ATTRIBUTES; + +typedef enum DWRITE_FONT_FAMILY_MODEL +{ + DWRITE_FONT_FAMILY_MODEL_TYPOGRAPHIC, + DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE, +} DWRITE_FONT_FAMILY_MODEL; + +typedef enum DWRITE_PAINT_TYPE +{ + DWRITE_PAINT_TYPE_NONE, + DWRITE_PAINT_TYPE_LAYERS, + DWRITE_PAINT_TYPE_SOLID_GLYPH, + DWRITE_PAINT_TYPE_SOLID, + DWRITE_PAINT_TYPE_LINEAR_GRADIENT, + DWRITE_PAINT_TYPE_RADIAL_GRADIENT, + DWRITE_PAINT_TYPE_SWEEP_GRADIENT, + DWRITE_PAINT_TYPE_GLYPH, + DWRITE_PAINT_TYPE_COLOR_GLYPH, + DWRITE_PAINT_TYPE_TRANSFORM, + DWRITE_PAINT_TYPE_COMPOSITE, +} DWRITE_PAINT_TYPE; + +cpp_quote("#ifndef DWRITE_PAINT_FEATURE_LEVEL_DEFINED") +cpp_quote("#define DWRITE_PAINT_FEATURE_LEVEL_DEFINED") +typedef enum DWRITE_PAINT_FEATURE_LEVEL +{ + DWRITE_PAINT_FEATURE_LEVEL_NONE = 0, + DWRITE_PAINT_FEATURE_LEVEL_COLR_V0 = 1, + DWRITE_PAINT_FEATURE_LEVEL_COLR_V1 = 2, +} DWRITE_PAINT_FEATURE_LEVEL; +cpp_quote("#endif /* DWRITE_PAINT_FEATURE_LEVEL_DEFINED */") + +typedef enum DWRITE_PAINT_ATTRIBUTES +{ + DWRITE_PAINT_ATTRIBUTES_NONE = 0, + DWRITE_PAINT_ATTRIBUTES_USES_PALETTE = 0x01, + DWRITE_PAINT_ATTRIBUTES_USES_TEXT_COLOR = 0x02, +} DWRITE_PAINT_ATTRIBUTES; + +cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(DWRITE_PAINT_ATTRIBUTES)") + +typedef struct DWRITE_PAINT_COLOR +{ + DWRITE_COLOR_F value; + UINT16 paletteEntryIndex; + float alphaMultiplier; + DWRITE_PAINT_ATTRIBUTES colorAttributes; +} DWRITE_PAINT_COLOR; + +typedef struct DWRITE_PAINT_ELEMENT +{ + DWRITE_PAINT_TYPE paintType; + union PAINT_UNION + { + struct PAINT_LAYERS + { + UINT32 childCount; + } layers; + struct PAINT_SOLID_GLYPH + { + UINT32 glyphIndex; + DWRITE_PAINT_COLOR color; + } solidGlyph; + DWRITE_PAINT_COLOR solid; + struct PAINT_LINEAR_GRADIENT + { + UINT32 extendMode; + UINT32 gradientStopCount; + float x0; + float y0; + float x1; + float y1; + float x2; + float y2; + } linearGradient; + struct PAINT_RADIAL_GRADIENT + { + UINT32 extendMode; + UINT32 gradientStopCount; + float x0; + float y0; + float radius0; + float x1; + float y1; + float radius1; + } radialGradient; + struct PAINT_SWEEP_GRADIENT + { + UINT32 extendMode; + UINT32 gradientStopCount; + float centerX; + float centerY; + float startAngle; + float endAngle; + } sweepGradient; + struct PAINT_GLYPH + { + UINT32 glyphIndex; + } glyph; + struct PAINT_COLOR_GLYPH + { + UINT32 glyphIndex; + D2D_RECT_F clipBox; + } colorGlyph; + DWRITE_MATRIX transform; + struct PAINT_COMPOSITE + { + DWRITE_COLOR_COMPOSITE_MODE mode; + } composite; + } paint; +} DWRITE_PAINT_ELEMENT; + +[ + local, + object, + uuid(b06fe5b9-43ec-4393-881b-dbe4dc72fda7) +] +interface IDWriteFontDownloadListener : IUnknown +{ + void DownloadCompleted( + [in] IDWriteFontDownloadQueue *queue, + [in] IUnknown *context, + [in] HRESULT result + ); +} + +[ + local, + object, + uuid(b71e6052-5aea-4fa3-832e-f60d431f7e91) +] +interface IDWriteFontDownloadQueue : IUnknown +{ + HRESULT AddListener( + [in] IDWriteFontDownloadListener *listener, + [out] UINT32 *token + ); + HRESULT RemoveListener( + [in] UINT32 token + ); + BOOL IsEmpty(); + HRESULT BeginDownload( + [in] IUnknown *context + ); + HRESULT CancelDownload(); + UINT64 GetGenerationCount(); +} + +[ + local, + object, + uuid(b7924baa-391b-412a-8c5c-e44cc2d867dc) +] +interface IDWriteRenderingParams3 : IDWriteRenderingParams2 +{ + DWRITE_RENDERING_MODE1 GetRenderingMode1(); +} + +[ + local, + object, + uuid(cfee3140-1157-47ca-8b85-31bfcf3f2d0e) +] +interface IDWriteStringList : IUnknown +{ + UINT32 GetCount(); + HRESULT GetLocaleNameLength( + [in] UINT32 index, + [out] UINT32 *length + ); + HRESULT GetLocaleName( + [in] UINT32 index, + [out] WCHAR *name, + [in] UINT32 size + ); + HRESULT GetStringLength( + [in] UINT32 index, + [out] UINT32 *length + ); + HRESULT GetString( + [in] UINT32 index, + [out] WCHAR *string, + [in] UINT32 size + ); +} + +[ + local, + object, + uuid(53585141-d9f8-4095-8321-d73cf6bd116b) +] +interface IDWriteFontSet : IUnknown +{ + UINT32 GetFontCount(); + HRESULT GetFontFaceReference( + [in] UINT32 index, + [out] IDWriteFontFaceReference **reference + ); + HRESULT FindFontFaceReference( + [in] IDWriteFontFaceReference *reference, + [out] UINT32 *index, + [out] BOOL *exists + ); + HRESULT FindFontFace( + [in] IDWriteFontFace *fontface, + [out] UINT32 *index, + [out] BOOL *exists + ); + HRESULT GetPropertyValues__( + [in] DWRITE_FONT_PROPERTY_ID id, + [out] IDWriteStringList **values + ); + HRESULT GetPropertyValues_( + [in] DWRITE_FONT_PROPERTY_ID id, + [in] WCHAR const *preferred_locales, + [out] IDWriteStringList **values + ); + HRESULT GetPropertyValues( + [in] UINT32 index, + [in] DWRITE_FONT_PROPERTY_ID id, + [out] BOOL *exists, + [out] IDWriteLocalizedStrings **values + ); + HRESULT GetPropertyOccurrenceCount( + [in] DWRITE_FONT_PROPERTY const *property, + [out] UINT32 *count + ); + HRESULT GetMatchingFonts_( + [in] WCHAR const *family, + [in] DWRITE_FONT_WEIGHT weight, + [in] DWRITE_FONT_STRETCH stretch, + [in] DWRITE_FONT_STYLE style, + [out] IDWriteFontSet **fontset + ); + HRESULT GetMatchingFonts( + [in] DWRITE_FONT_PROPERTY const *props, + [in] UINT32 count, + [out] IDWriteFontSet **fontset + ); +} + +[ + local, + object, + uuid(1f803a76-6871-48e8-987f-b975551c50f2) +] +interface IDWriteFontResource : IUnknown +{ + HRESULT GetFontFile( + [out] IDWriteFontFile **fontfile + ); + UINT32 GetFontFaceIndex(); + UINT32 GetFontAxisCount(); + HRESULT GetDefaultFontAxisValues( + [out] DWRITE_FONT_AXIS_VALUE *values, + [in] UINT32 num_values + ); + HRESULT GetFontAxisRanges( + [out] DWRITE_FONT_AXIS_RANGE *ranges, + [in] UINT32 num_ranges + ); + DWRITE_FONT_AXIS_ATTRIBUTES GetFontAxisAttributes( + [in] UINT32 axis + ); + HRESULT GetAxisNames( + [in] UINT32 axis, + [out] IDWriteLocalizedStrings **names + ); + UINT32 GetAxisValueNameCount( + [in] UINT32 axis + ); + HRESULT GetAxisValueNames( + [in] UINT32 axis, + [in] UINT32 axis_value, + [out] DWRITE_FONT_AXIS_RANGE *axis_range, + [out] IDWriteLocalizedStrings **names + ); + BOOL HasVariations(); + HRESULT CreateFontFace( + [in] DWRITE_FONT_SIMULATIONS simulations, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [out] IDWriteFontFace5 **fontface + ); + HRESULT CreateFontFaceReference( + [in] DWRITE_FONT_SIMULATIONS simulations, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [out] IDWriteFontFaceReference1 **reference + ); +} + +[ + local, + object, + uuid(7e9fda85-6c92-4053-bc47-7ae3530db4d3) +] +interface IDWriteFontSet1 : IDWriteFontSet +{ + HRESULT GetMatchingFonts( + [in] DWRITE_FONT_PROPERTY const *property, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [out] IDWriteFontSet1 **fontset + ); + HRESULT GetFirstFontResources( + [out] IDWriteFontSet1 **fontset + ); + HRESULT GetFilteredFonts__( + [in] UINT32 const *indices, + [in] UINT32 num_indices, + [out] IDWriteFontSet1 **fontset + ); + HRESULT GetFilteredFonts_( + [in] DWRITE_FONT_AXIS_RANGE const *axis_ranges, + [in] UINT32 num_ranges, + [in] BOOL select_any_range, + [out] IDWriteFontSet1 **fontset + ); + HRESULT GetFilteredFonts( + [in] DWRITE_FONT_PROPERTY const *props, + [in] UINT32 num_properties, + [in] BOOL select_any_property, + [out] IDWriteFontSet1 **fontset + ); + HRESULT GetFilteredFontIndices_( + [in] DWRITE_FONT_AXIS_RANGE const *ranges, + [in] UINT32 num_ranges, + [in] BOOL select_any_range, + [out] UINT32 *indices, + [in] UINT32 num_indices, + [out] UINT32 *actual_num_indices + ); + HRESULT GetFilteredFontIndices( + [in] DWRITE_FONT_PROPERTY const *props, + [in] UINT32 num_properties, + [in] BOOL select_any_range, + [out] UINT32 *indices, + [in] UINT32 num_indices, + [out] UINT32 *actual_num_indices + ); + HRESULT GetFontAxisRanges_( + [in] UINT32 font_index, + [out] DWRITE_FONT_AXIS_RANGE *axis_ranges, + [in] UINT32 num_ranges, + [out] UINT32 *actual_num_ranges + ); + HRESULT GetFontAxisRanges( + [out] DWRITE_FONT_AXIS_RANGE *axis_ranges, + [in] UINT32 num_ranges, + [out] UINT32 *actual_num_ranges + ); + HRESULT GetFontFaceReference( + [in] UINT32 index, + [out] IDWriteFontFaceReference1 **reference + ); + HRESULT CreateFontResource( + [in] UINT32 index, + [out] IDWriteFontResource **resource + ); + HRESULT CreateFontFace( + [in] UINT32 index, + [out] IDWriteFontFace5 **fontface + ); + DWRITE_LOCALITY GetFontLocality( + [in] UINT32 index + ); +} + +[ + local, + object, + uuid(29748ed6-8c9c-4a6a-be0b-d912e8538944) +] +interface IDWriteFont3 : IDWriteFont2 +{ + HRESULT CreateFontFace( + [out] IDWriteFontFace3 **fontface + ); + BOOL Equals( + [in] IDWriteFont *font + ); + HRESULT GetFontFaceReference( + [out] IDWriteFontFaceReference **reference + ); + BOOL HasCharacter( + [in] UINT32 character + ); + DWRITE_LOCALITY GetLocality(); +} + +[ + local, + object, + uuid(da20d8ef-812a-4c43-9802-62ec4abd7adf) +] +interface IDWriteFontFamily1 : IDWriteFontFamily +{ + DWRITE_LOCALITY GetFontLocality( + [in] UINT32 index + ); + HRESULT GetFont( + [in] UINT32 index, + [out] IDWriteFont3 **font + ); + HRESULT GetFontFaceReference( + [in] UINT32 index, + [out] IDWriteFontFaceReference **reference + ); +} + +[ + local, + object, + uuid(3ed49e77-a398-4261-b9cf-c126c2131ef3) +] +interface IDWriteFontFamily2 : IDWriteFontFamily1 +{ + HRESULT GetMatchingFonts( + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [out] IDWriteFontList2 **fontlist + ); + HRESULT GetFontSet( + [out] IDWriteFontSet1 **fontset + ); +} + +[ + local, + object, + uuid(53585141-d9f8-4095-8321-d73cf6bd116c) +] +interface IDWriteFontCollection1 : IDWriteFontCollection +{ + HRESULT GetFontSet( + [out] IDWriteFontSet **fontset + ); + HRESULT GetFontFamily( + [in] UINT32 index, + [out] IDWriteFontFamily1 **family + ); +} + +[ + local, + object, + uuid(514039c6-4617-4064-bf8b-92ea83e506e0) +] +interface IDWriteFontCollection2 : IDWriteFontCollection1 +{ + HRESULT GetFontFamily( + [in] UINT32 index, + [out] IDWriteFontFamily2 **family + ); + HRESULT GetMatchingFonts( + [in] const WCHAR *familyname, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [out] IDWriteFontList2 **fontlist + ); + DWRITE_FONT_FAMILY_MODEL GetFontFamilyModel(); + HRESULT GetFontSet( + [out] IDWriteFontSet1 **fontset + ); +} + +[ + local, + object, + uuid(a4d055a6-f9e3-4e25-93b7-9e309f3af8e9) +] +interface IDWriteFontCollection3 : IDWriteFontCollection2 +{ + HANDLE GetExpirationEvent(); +} + +[ + local, + object, + uuid(5e7fa7ca-dde3-424c-89f0-9fcd6fed58cd) +] +interface IDWriteFontFaceReference : IUnknown +{ + HRESULT CreateFontFace( + [out] IDWriteFontFace3 **fontface + ); + HRESULT CreateFontFaceWithSimulations( + [in] DWRITE_FONT_SIMULATIONS simulations, + [out] IDWriteFontFace3 **fontface + ); + BOOL Equals( + [in] IDWriteFontFaceReference *reference + ); + UINT32 GetFontFaceIndex(); + DWRITE_FONT_SIMULATIONS GetSimulations(); + HRESULT GetFontFile( + [out] IDWriteFontFile **fontfile + ); + UINT64 GetLocalFileSize(); + UINT64 GetFileSize(); + HRESULT GetFileTime( + [out] FILETIME *writetime + ); + DWRITE_LOCALITY GetLocality(); + HRESULT EnqueueFontDownloadRequest(); + HRESULT EnqueueCharacterDownloadRequest( + [in] WCHAR const *chars, + [in] UINT32 count + ); + HRESULT EnqueueGlyphDownloadRequest( + [in] UINT16 const *glyphs, + [in] UINT32 count + ); + HRESULT EnqueueFileFragmentDownloadRequest( + [in] UINT64 offset, + [in] UINT64 size + ); +} + +[ + local, + object, + uuid(c081fe77-2fd1-41ac-a5a3-34983c4ba61a) +] +interface IDWriteFontFaceReference1 : IDWriteFontFaceReference +{ + HRESULT CreateFontFace( + [out] IDWriteFontFace5 **fontface + ); + UINT32 GetFontAxisValueCount(); + HRESULT GetFontAxisValues( + [out] DWRITE_FONT_AXIS_VALUE *values, + [in] UINT32 num_values + ); +} + +[ + local, + object, + uuid(da20d8ef-812a-4c43-9802-62ec4abd7ade) +] +interface IDWriteFontList1 : IDWriteFontList +{ + DWRITE_LOCALITY GetFontLocality( + [in] UINT32 index + ); + HRESULT GetFont( + [in] UINT32 index, + [out] IDWriteFont3 **font + ); + HRESULT GetFontFaceReference( + [in] UINT32 index, + [out] IDWriteFontFaceReference **reference + ); +} + +[ + local, + object, + uuid(c0763a34-77af-445a-b735-08c37b0a5bf5) +] +interface IDWriteFontList2 : IDWriteFontList1 +{ + HRESULT GetFontSet( + [out] IDWriteFontSet1 **fontset + ); +} + +[ + local, + object, + uuid(dc7ead19-e54c-43af-b2da-4e2b79ba3f7f) +] +interface IDWriteFontSet2 : IDWriteFontSet1 +{ + HANDLE GetExpirationEvent(); +} + +[ + local, + object, + uuid(7c073ef2-a7f4-4045-8c32-8ab8ae640f90) +] +interface IDWriteFontSet3 : IDWriteFontSet2 +{ + DWRITE_FONT_SOURCE_TYPE GetFontSourceType( + [in] UINT32 index + ); + UINT32 GetFontSourceNameLength( + [in] UINT32 index + ); + HRESULT GetFontSourceName( + [in] UINT32 index, + [out] WCHAR *buffer, + [in] UINT32 buffer_size + ); +} + +[ + local, + object, + uuid(eec175fc-bea9-4c86-8b53-ccbdd7df0c82) +] +interface IDWriteFontSet4 : IDWriteFontSet3 +{ + UINT32 ConvertWeightStretchStyleToFontAxisValues( + [in] DWRITE_FONT_AXIS_VALUE const *input_axis_values, + [in] UINT32 input_axis_count, + [in] DWRITE_FONT_WEIGHT weight, + [in] DWRITE_FONT_STRETCH stretch, + [in] DWRITE_FONT_STYLE style, + [in] float size, + [out] DWRITE_FONT_AXIS_VALUE *output_axis_values + ); + HRESULT GetMatchingFonts( + [in] WCHAR const *family_name, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 axis_value_count, + [in] DWRITE_FONT_SIMULATIONS allowed_simulations, + [out] IDWriteFontSet4 **fonts + ); +} + +[ + local, + object, + uuid(d37d7598-09be-4222-a236-2081341cc1f2) +] +interface IDWriteFontFace3 : IDWriteFontFace2 +{ + HRESULT GetFontFaceReference( + [out] IDWriteFontFaceReference **reference + ); + void GetPanose( + [out] DWRITE_PANOSE *panose + ); + DWRITE_FONT_WEIGHT GetWeight(); + DWRITE_FONT_STRETCH GetStretch(); + DWRITE_FONT_STYLE GetStyle(); + HRESULT GetFamilyNames( + [out] IDWriteLocalizedStrings **names + ); + HRESULT GetFaceNames( + [out] IDWriteLocalizedStrings **names + ); + HRESULT GetInformationalStrings( + [in] DWRITE_INFORMATIONAL_STRING_ID stringid, + [out] IDWriteLocalizedStrings **strings, + [out] BOOL *exists + ); + BOOL HasCharacter( + [in] UINT32 character + ); + HRESULT GetRecommendedRenderingMode( + [in] FLOAT emsize, + [in] FLOAT dpi_x, + [in] FLOAT dpi_y, + [in] DWRITE_MATRIX const *transform, + [in] BOOL is_sideways, + [in] DWRITE_OUTLINE_THRESHOLD threshold, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] IDWriteRenderingParams *params, + [out] DWRITE_RENDERING_MODE1 *rendering_mode, + [out] DWRITE_GRID_FIT_MODE *gridfit_mode + ); + BOOL IsCharacterLocal( + [in] UINT32 character + ); + BOOL IsGlyphLocal( + [in] UINT16 glyph + ); + HRESULT AreCharactersLocal( + [in] WCHAR const *characters, + [in] UINT32 count, + [in] BOOL enqueue_if_not, + [out] BOOL *are_local + ); + HRESULT AreGlyphsLocal( + [in] UINT16 const *glyphs, + [in] UINT32 count, + [in] BOOL enqueue_if_not, + [out] BOOL *are_local + ); +} + + +typedef struct DWRITE_LINE_METRICS1 +{ + UINT32 length; + UINT32 trailingWhitespaceLength; + UINT32 newlineLength; + FLOAT height; + FLOAT baseline; + BOOL isTrimmed; + FLOAT leadingBefore; + FLOAT leadingAfter; +} DWRITE_LINE_METRICS1; + +typedef enum DWRITE_FONT_LINE_GAP_USAGE +{ + DWRITE_FONT_LINE_GAP_USAGE_DEFAULT, + DWRITE_FONT_LINE_GAP_USAGE_DISABLED, + DWRITE_FONT_LINE_GAP_USAGE_ENABLED +} DWRITE_FONT_LINE_GAP_USAGE; + +typedef struct DWRITE_LINE_SPACING +{ + DWRITE_LINE_SPACING_METHOD method; + FLOAT height; + FLOAT baseline; + FLOAT leadingBefore; + DWRITE_FONT_LINE_GAP_USAGE fontLineGapUsage; +} DWRITE_LINE_SPACING; + +[ + local, + object, + uuid(f67e0edd-9e3d-4ecc-8c32-4183253dfe70) +] +interface IDWriteTextFormat2 : IDWriteTextFormat1 +{ + HRESULT SetLineSpacing( + [in] DWRITE_LINE_SPACING const *spacing + ); + HRESULT GetLineSpacing( + [out] DWRITE_LINE_SPACING *spacing + ); +} + +[ + local, + object, + uuid(6d3b5641-e550-430d-a85b-b7bf48a93427) +] +interface IDWriteTextFormat3 : IDWriteTextFormat2 +{ + HRESULT SetFontAxisValues( + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values + ); + UINT32 GetFontAxisValueCount(); + HRESULT GetFontAxisValues( + [out] DWRITE_FONT_AXIS_VALUE *axis_values, + [in] UINT32 num_values + ); + DWRITE_AUTOMATIC_FONT_AXES GetAutomaticFontAxes(); + HRESULT SetAutomaticFontAxes( + [in] DWRITE_AUTOMATIC_FONT_AXES axes + ); +} + +[ + local, + object, + uuid(07ddcd52-020e-4de8-ac33-6c953d83f92d) +] +interface IDWriteTextLayout3 : IDWriteTextLayout2 +{ + HRESULT InvalidateLayout(); + HRESULT SetLineSpacing( + [in] DWRITE_LINE_SPACING const *spacing + ); + HRESULT GetLineSpacing( + [out] DWRITE_LINE_SPACING *spacing + ); + HRESULT GetLineMetrics( + [out] DWRITE_LINE_METRICS1 *metrics, + [in] UINT32 max_count, + [out] UINT32 *count + ); +} + +[ + local, + object, + uuid(05a9bf42-223f-4441-b5fb-8263685f55e9) +] +interface IDWriteTextLayout4 : IDWriteTextLayout3 +{ + HRESULT SetFontAxisValues( + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [in] DWRITE_TEXT_RANGE range + ); + UINT32 GetFontAxisValueCount( + [in] UINT32 pos + ); + HRESULT GetFontAxisValues( + [in] UINT32 pos, + [out] DWRITE_FONT_AXIS_VALUE *values, + [in] UINT32 num_values, + [out] DWRITE_TEXT_RANGE *range + ); + DWRITE_AUTOMATIC_FONT_AXES GetAutomaticFontAxes(); + HRESULT SetAutomaticFontAxes( + [in] DWRITE_AUTOMATIC_FONT_AXES axes + ); +} + +[ + local, + object, + uuid(2397599d-dd0d-4681-bd6a-f4f31eaade77) +] +interface IDWriteFontFallback1 : IDWriteFontFallback +{ + HRESULT MapCharacters( + [in] IDWriteTextAnalysisSource *source, + [in] UINT32 pos, + [in] UINT32 length, + [in] IDWriteFontCollection *base_collection, + [in] const WCHAR *familyname, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [out] UINT32 *mapped_length, + [out] FLOAT *scale, + [out] IDWriteFontFace5 **fontface + ); +} + +[ + local, + object, + uuid(4556be70-3abd-4f70-90be-421780a6f515) +] +interface IDWriteGdiInterop1 : IDWriteGdiInterop +{ + HRESULT CreateFontFromLOGFONT( + [in] LOGFONTW const *logfont, + [in] IDWriteFontCollection *collection, + [out] IDWriteFont **font + ); + + /* GetFontSignature() methods are listed in reversed order to make + resulting vtable order compatible. */ + HRESULT GetFontSignature_( + [in] IDWriteFontFace *fontface, + [out] FONTSIGNATURE *fontsig + ); + HRESULT GetFontSignature( + [in] IDWriteFont *font, + [out] FONTSIGNATURE *fontsig + ); + HRESULT GetMatchingFontsByLOGFONT( + [in] LOGFONTW const *logfont, + [in] IDWriteFontSet *fontset, + [out] IDWriteFontSet **subset + ); +} + +[ + local, + object, + uuid(2f642afe-9c68-4f40-b8be-457401afcb3d) +] +interface IDWriteFontSetBuilder : IUnknown +{ + HRESULT AddFontFaceReference_( + [in] IDWriteFontFaceReference *ref, + [in] DWRITE_FONT_PROPERTY const *props, + [in] UINT32 prop_count + ); + HRESULT AddFontFaceReference( + [in] IDWriteFontFaceReference *ref); + HRESULT AddFontSet( + [in] IDWriteFontSet *fontset + ); + HRESULT CreateFontSet( + [out] IDWriteFontSet **fontset + ); +} + +[ + local, + object, + uuid(3ff7715f-3cdc-4dc6-9b72-ec5621dccafd) +] +interface IDWriteFontSetBuilder1 : IDWriteFontSetBuilder +{ + HRESULT AddFontFile( + [in] IDWriteFontFile *file + ); +} + +[ + local, + object, + uuid(ee5ba612-b131-463c-8f4f-3189b9401e45) +] +interface IDWriteFontSetBuilder2 : IDWriteFontSetBuilder1 +{ + HRESULT AddFont( + [in] IDWriteFontFile *fontfile, + [in] UINT32 face_index, + [in] DWRITE_FONT_SIMULATIONS simulations, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_values, + [in] DWRITE_FONT_AXIS_RANGE const *axis_ranges, + [in] UINT32 num_ranges, + [in] DWRITE_FONT_PROPERTY const *props, + [in] UINT32 num_properties + ); + HRESULT AddFontFile( + [in] const WCHAR *filepath + ); +} + +[ + local, + object, + uuid(9a1b41c3-d3bb-466a-87fc-fe67556a3b65) +] +interface IDWriteFactory3 : IDWriteFactory2 +{ + HRESULT CreateGlyphRunAnalysis( + [in] DWRITE_GLYPH_RUN const *run, + [in] DWRITE_MATRIX const *transform, + [in] DWRITE_RENDERING_MODE1 rendering_mode, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] DWRITE_GRID_FIT_MODE gridfit_mode, + [in] DWRITE_TEXT_ANTIALIAS_MODE antialias_mode, + [in] FLOAT origin_x, + [in] FLOAT origin_y, + [out] IDWriteGlyphRunAnalysis **analysis + ); + HRESULT CreateCustomRenderingParams( + [in] FLOAT gamma, + [in] FLOAT enhanced_contrast, + [in] FLOAT grayscale_enhanced_contrast, + [in] FLOAT cleartype_level, + [in] DWRITE_PIXEL_GEOMETRY pixel_geometry, + [in] DWRITE_RENDERING_MODE1 rendering_mode, + [in] DWRITE_GRID_FIT_MODE gridfit_mode, + [out] IDWriteRenderingParams3 **params + ); + /* CreateFontFaceReference methods are listed in reversed order to make + resulting vtable order compatible. */ + HRESULT CreateFontFaceReference_( + [in] IDWriteFontFile *file, + [in] UINT32 index, + [in] DWRITE_FONT_SIMULATIONS simulations, + [out] IDWriteFontFaceReference **reference + ); + HRESULT CreateFontFaceReference( + [in] WCHAR const *path, + [in] FILETIME const *writetime, + [in] UINT32 index, + [in] DWRITE_FONT_SIMULATIONS simulations, + [out] IDWriteFontFaceReference **reference + ); + HRESULT GetSystemFontSet( + [out] IDWriteFontSet **fontset + ); + HRESULT CreateFontSetBuilder( + [out] IDWriteFontSetBuilder **builder + ); + HRESULT CreateFontCollectionFromFontSet( + [in] IDWriteFontSet *fontset, + [out] IDWriteFontCollection1 **collection + ); + HRESULT GetSystemFontCollection( + [in] BOOL include_downloadable, + [out] IDWriteFontCollection1 **collection, + [in] BOOL check_for_updates + ); + HRESULT GetFontDownloadQueue( + [out] IDWriteFontDownloadQueue **queue + ); +} + +typedef struct DWRITE_GLYPH_IMAGE_DATA +{ + void const *imageData; + UINT32 imageDataSize; + UINT32 uniqueDataId; + UINT32 pixelsPerEm; + D2D1_SIZE_U pixelSize; + D2D1_POINT_2L horizontalLeftOrigin; + D2D1_POINT_2L horizontalRightOrigin; + D2D1_POINT_2L verticalTopOrigin; + D2D1_POINT_2L verticalBottomOrigin; +} DWRITE_GLYPH_IMAGE_DATA; + +[ + local, + object, + uuid(27f2a904-4eb8-441d-9678-0563f53e3e2f) +] +interface IDWriteFontFace4 : IDWriteFontFace3 +{ + HRESULT GetGlyphImageFormats_( + [in] UINT16 glyph, + [in] UINT32 ppem_first, + [in] UINT32 ppem_last, + [out] DWRITE_GLYPH_IMAGE_FORMATS *formats + ); + DWRITE_GLYPH_IMAGE_FORMATS GetGlyphImageFormats(); + HRESULT GetGlyphImageData( + [in] UINT16 glyph, + [in] UINT32 ppem, + [in] DWRITE_GLYPH_IMAGE_FORMATS format, + [out] DWRITE_GLYPH_IMAGE_DATA *data, + [out] void **context + ); + void ReleaseGlyphImageData( + [in] void *context + ); +} + +[ + local, + object, + uuid(98eff3a5-b667-479a-b145-e2fa5b9fdc29) +] +interface IDWriteFontFace5 : IDWriteFontFace4 +{ + UINT32 GetFontAxisValueCount(); + HRESULT GetFontAxisValues( + [out] DWRITE_FONT_AXIS_VALUE *values, + [in] UINT32 value_count); + BOOL HasVariations(); + HRESULT GetFontResource( + [out] IDWriteFontResource **resource + ); + BOOL Equals( + [in] IDWriteFontFace *fontface + ); +} + +[ + local, + object, + uuid(c4b1fe1b-6e84-47d5-b54c-a597981b06ad) +] +interface IDWriteFontFace6 : IDWriteFontFace5 +{ + HRESULT GetFamilyNames( + [in] DWRITE_FONT_FAMILY_MODEL font_family_model, + [out] IDWriteLocalizedStrings **names + ); + HRESULT GetFaceNames( + [in] DWRITE_FONT_FAMILY_MODEL font_family_model, + [out] IDWriteLocalizedStrings **names + ); +} + +[ + local, + object, + uuid(8128e912-3b97-42a5-ab6c-24aad3a86e54) +] +interface IDWritePaintReader : IUnknown +{ + HRESULT SetCurrentGlyph( + [in] UINT32 glyph_index, + [out] DWRITE_PAINT_ELEMENT *paint_element, + [in] UINT32 struct_size, + [out] D2D_RECT_F *clip_box, + [out, defaultvalue(NULL)] DWRITE_PAINT_ATTRIBUTES *glyph_attributes + ); + HRESULT SetTextColor( + [in] DWRITE_COLOR_F const *text_color + ); + HRESULT SetColorPaletteIndex( + [in] UINT32 color_palette_index + ); + HRESULT SetCustomColorPalette( + [in] DWRITE_COLOR_F const *palette_entries, + [in] UINT32 palette_entry_count + ); + HRESULT MoveToFirstChild( + [out] DWRITE_PAINT_ELEMENT *paint_element, + [in] UINT32 struct_size + ); + HRESULT MoveToNextSibling( + [out] DWRITE_PAINT_ELEMENT *paint_element, + [in] UINT32 struct_size + ); + HRESULT MoveToParent(void); + HRESULT GetGradientStops( + [in] UINT32 first_gradient_stop_index, + [in] UINT32 gradient_stop_count, + [out] D2D1_GRADIENT_STOP *gradient_stops + ); + HRESULT GetGradientStopColors( + [in] UINT32 first_gradient_stop_index, + [in] UINT32 gradient_stop_count, + [out] DWRITE_PAINT_COLOR *gradient_stop_colors + ); +} + +[ + local, + object, + uuid(3945b85b-bc95-40f7-b72c-8b73bfc7e13b) +] +interface IDWriteFontFace7 : IDWriteFontFace6 +{ + DWRITE_PAINT_FEATURE_LEVEL GetPaintFeatureLevel( + [in] DWRITE_GLYPH_IMAGE_FORMATS glyph_image_format + ); + HRESULT CreatePaintReader( + [in] DWRITE_GLYPH_IMAGE_FORMATS glyph_image_format, + [in] DWRITE_PAINT_FEATURE_LEVEL paint_feature_level, + [out] IDWritePaintReader **paint_reader + ); +} + +typedef struct DWRITE_COLOR_GLYPH_RUN1 DWRITE_COLOR_GLYPH_RUN1; + +cpp_quote("struct DWRITE_COLOR_GLYPH_RUN1") +cpp_quote("{") +cpp_quote(" DWRITE_GLYPH_RUN glyphRun;") +cpp_quote(" DWRITE_GLYPH_RUN_DESCRIPTION *glyphRunDescription;") +cpp_quote(" FLOAT baselineOriginX;") +cpp_quote(" FLOAT baselineOriginY;") +cpp_quote(" DWRITE_COLOR_F runColor;") +cpp_quote(" UINT16 paletteIndex;") +cpp_quote("#ifdef _WIN64") +cpp_quote(" UINT32 _pad;") +cpp_quote("#endif") +cpp_quote(" DWRITE_GLYPH_IMAGE_FORMATS glyphImageFormat;") +cpp_quote(" DWRITE_MEASURING_MODE measuringMode;") +cpp_quote("};") + +[ + local, + object, + uuid(7c5f86da-c7a1-4f05-b8e1-55a179fe5a35) +] +interface IDWriteColorGlyphRunEnumerator1 : IDWriteColorGlyphRunEnumerator +{ + HRESULT GetCurrentRun( + [out] DWRITE_COLOR_GLYPH_RUN1 const **run + ); +} + +[ + local, + object, + uuid(4b0b5bd3-0797-4549-8ac5-fe915cc53856) +] +interface IDWriteFactory4 : IDWriteFactory3 +{ + HRESULT TranslateColorGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] DWRITE_GLYPH_RUN const *run, + [in] DWRITE_GLYPH_RUN_DESCRIPTION const *run_desc, + [in] DWRITE_GLYPH_IMAGE_FORMATS desired_formats, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] DWRITE_MATRIX const *transform, + [in] UINT32 palette, + [out] IDWriteColorGlyphRunEnumerator1 **layers + ); + HRESULT ComputeGlyphOrigins_( + [in] DWRITE_GLYPH_RUN const *run, + [in] D2D1_POINT_2F baseline_origin, + [out] D2D1_POINT_2F *origins + ); + HRESULT ComputeGlyphOrigins( + [in] DWRITE_GLYPH_RUN const *run, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] D2D1_POINT_2F baseline_origin, + [in] DWRITE_MATRIX const *transform, + [out] D2D1_POINT_2F *origins + ); +} + +[ + local, + object, + uuid(ce25f8fd-863b-4d13-9651-c1f88dc73fe2) +] +interface IDWriteAsyncResult : IUnknown +{ + HANDLE GetWaitHandle(); + HRESULT GetResult(); +} + +typedef struct DWRITE_FILE_FRAGMENT +{ + UINT64 fileOffset; + UINT64 fragmentSize; +} DWRITE_FILE_FRAGMENT; + +[ + local, + object, + uuid(4db3757a-2c72-4ed9-b2b6-1ababe1aff9c) +] +interface IDWriteRemoteFontFileStream : IDWriteFontFileStream +{ + HRESULT GetLocalFileSize( + [out] UINT64 *size + ); + HRESULT GetFileFragmentLocality( + [in] UINT64 offset, + [in] UINT64 size, + [out] BOOL *is_local, + [out] UINT64 *partial_size + ); + DWRITE_LOCALITY GetLocality(); + HRESULT BeginDownload( + [in] GUID const *operation_id, + [in] DWRITE_FILE_FRAGMENT const *fragments, + [in] UINT32 fragment_count, + [out] IDWriteAsyncResult **async_result + ); +} + +typedef enum DWRITE_CONTAINER_TYPE +{ + DWRITE_CONTAINER_TYPE_UNKNOWN, + DWRITE_CONTAINER_TYPE_WOFF, + DWRITE_CONTAINER_TYPE_WOFF2, +} DWRITE_CONTAINER_TYPE; + +[ + local, + object, + uuid(68648c83-6ede-46c0-ab46-20083a887fde) +] +interface IDWriteRemoteFontFileLoader : IDWriteFontFileLoader +{ + HRESULT CreateRemoteStreamFromKey( + [in] void const *key, + [in] UINT32 key_size, + [out] IDWriteRemoteFontFileStream **stream + ); + HRESULT GetLocalityFromKey( + [in] void const *key, + [in] UINT32 key_size, + [out] DWRITE_LOCALITY *locality + ); + HRESULT CreateFontFileReferenceFromUrl( + [in] IDWriteFactory *factory, + [in] WCHAR const *base_url, + [in] WCHAR const *file_url, + [out] IDWriteFontFile **fontfile + ); +} + +[ + local, + object, + uuid(dc102f47-a12d-4b1c-822d-9e117e33043f) +] +interface IDWriteInMemoryFontFileLoader : IDWriteFontFileLoader +{ + HRESULT CreateInMemoryFontFileReference( + [in] IDWriteFactory *factory, + [in] void const *data, + [in] UINT32 data_size, + [in] IUnknown *owner, + [out] IDWriteFontFile **fontfile + ); + UINT32 GetFileCount(); +} + +[ + local, + object, + uuid(958db99a-be2a-4f09-af7d-65189803d1d3) +] +interface IDWriteFactory5 : IDWriteFactory4 +{ + HRESULT CreateFontSetBuilder( + [out] IDWriteFontSetBuilder1 **fontset_builder + ); + HRESULT CreateInMemoryFontFileLoader( + [out] IDWriteInMemoryFontFileLoader **loader + ); + HRESULT CreateHttpFontFileLoader( + [in] WCHAR const *referrer_url, + [in] WCHAR const *extra_headers, + [out] IDWriteRemoteFontFileLoader **loader + ); + DWRITE_CONTAINER_TYPE AnalyzeContainerType( + [in] void const *data, + [in] UINT32 data_size + ); + HRESULT UnpackFontFile( + [in] DWRITE_CONTAINER_TYPE container_type, + [in] void const *data, + [in] UINT32 data_size, + [out] IDWriteFontFileStream **stream + ); +} + +[ + local, + object, + uuid(f3744d80-21f7-42eb-b35d-995bc72fc223) +] +interface IDWriteFactory6 : IDWriteFactory5 +{ + HRESULT CreateFontFaceReference( + [in] IDWriteFontFile *file, + [in] UINT32 face_index, + [in] DWRITE_FONT_SIMULATIONS simulations, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_axis, + [out] IDWriteFontFaceReference1 **face_ref + ); + HRESULT CreateFontResource( + [in] IDWriteFontFile *file, + [in] UINT32 face_index, + [out] IDWriteFontResource **resource + ); + HRESULT GetSystemFontSet( + [in] BOOL include_downloadable, + [out] IDWriteFontSet1 **fontset + ); + HRESULT GetSystemFontCollection( + [in] BOOL include_downloadable, + [in] DWRITE_FONT_FAMILY_MODEL family_model, + [out] IDWriteFontCollection2 **collection + ); + HRESULT CreateFontCollectionFromFontSet( + [in] IDWriteFontSet *fontset, + [in] DWRITE_FONT_FAMILY_MODEL family_model, + [out] IDWriteFontCollection2 **collection + ); + HRESULT CreateFontSetBuilder( + [out] IDWriteFontSetBuilder2 **builder + ); + HRESULT CreateTextFormat( + [in] const WCHAR *familyname, + [in] IDWriteFontCollection *collection, + [in] DWRITE_FONT_AXIS_VALUE const *axis_values, + [in] UINT32 num_axis, + [in] FLOAT fontsize, + [in] const WCHAR *localename, + [out] IDWriteTextFormat3 **format + ); +} + +[ + local, + object, + uuid(35d0e0b3-9076-4d2e-a016-a91b568a06b4) +] +interface IDWriteFactory7 : IDWriteFactory6 +{ + HRESULT GetSystemFontSet( + [in] BOOL include_downloadable, + [out] IDWriteFontSet2 **fontset + ); + HRESULT GetSystemFontCollection( + [in] BOOL include_downloadable, + [in] DWRITE_FONT_FAMILY_MODEL family_model, + [out] IDWriteFontCollection3 **collection + ); +} + +[ + local, + object, + uuid(ee0a7fb5-def4-4c23-a454-c9c7dc878398) +] +interface IDWriteFactory8 : IDWriteFactory7 +{ + HRESULT TranslateColorGlyphRun( + [in] D2D1_POINT_2F origin, + [in] DWRITE_GLYPH_RUN const *glyph_run, + [in] DWRITE_GLYPH_RUN_DESCRIPTION const *glyph_run_desc, + [in] DWRITE_GLYPH_IMAGE_FORMATS image_formats, + [in] DWRITE_PAINT_FEATURE_LEVEL feature_level, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] DWRITE_MATRIX const *world_and_dpi_transform, + [in] UINT32 palette_index, + [out] IDWriteColorGlyphRunEnumerator1 **enumerator); +} + +typedef struct DWRITE_BITMAP_DATA_BGRA32 +{ + UINT32 width; + UINT32 height; + UINT32 *pixels; +} DWRITE_BITMAP_DATA_BGRA32; + +[ + local, + object, + uuid(c553a742-fc01-44da-a66e-b8b9ed6c3995) +] +interface IDWriteBitmapRenderTarget2 : IDWriteBitmapRenderTarget1 +{ + HRESULT GetBitmapData([out] DWRITE_BITMAP_DATA_BGRA32 *bitmap_data); +} + +[ + local, + object, + uuid(aeec37db-c337-40f1-8e2a-9a41b167b238) +] +interface IDWriteBitmapRenderTarget3 : IDWriteBitmapRenderTarget2 +{ + DWRITE_PAINT_FEATURE_LEVEL GetPaintFeatureLevel(); + HRESULT DrawPaintGlyphRun( + [in] FLOAT origin_x, + [in] FLOAT origin_y, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] DWRITE_GLYPH_RUN const *run, + [in] DWRITE_GLYPH_IMAGE_FORMATS image_format, + [in] COLORREF text_color, + [in] UINT32 palette_index, + [out] RECT *black_box); + HRESULT DrawGlyphRunWithColorSupport( + [in] FLOAT origin_x, + [in] FLOAT origin_y, + [in] DWRITE_MEASURING_MODE measuring_mode, + [in] DWRITE_GLYPH_RUN const *run, + [in] IDWriteRenderingParams *params, + [in] COLORREF text_color, + [in] UINT32 palette_index, + [out] RECT *black_box); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgi.idl b/WineFix/lib/d2d1/include/windows/dxgi.idl new file mode 100644 index 0000000..65c5a4b --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgi.idl @@ -0,0 +1,503 @@ +/* + * Copyright 2007 Andras Kovacs + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgitype.idl"; + +const UINT _FACDXGI = 0x87a; + +cpp_quote("#define MAKE_DXGI_STATUS(x) MAKE_HRESULT(0, _FACDXGI, x)") +cpp_quote("#define MAKE_DXGI_HRESULT(x) MAKE_HRESULT(1, _FACDXGI, x)") + +cpp_quote("#if 0") +typedef HANDLE HMONITOR; +typedef struct _LUID { + DWORD LowPart; + LONG HighPart; +} LUID, *PLUID; +cpp_quote("#endif") + +const UINT DXGI_CPU_ACCESS_NONE = 0; +const UINT DXGI_CPU_ACCESS_DYNAMIC = 1; +const UINT DXGI_CPU_ACCESS_READ_WRITE = 2; +const UINT DXGI_CPU_ACCESS_SCRATCH = 3; +const UINT DXGI_CPU_ACCESS_FIELD = 15; + +typedef UINT DXGI_USAGE; +const DXGI_USAGE DXGI_USAGE_SHADER_INPUT = 0x10L; +const DXGI_USAGE DXGI_USAGE_RENDER_TARGET_OUTPUT = 0x20L; +const DXGI_USAGE DXGI_USAGE_BACK_BUFFER = 0x40L; +const DXGI_USAGE DXGI_USAGE_SHARED = 0x80L; +const DXGI_USAGE DXGI_USAGE_READ_ONLY = 0x100L; +const DXGI_USAGE DXGI_USAGE_DISCARD_ON_PRESENT = 0x200L; +const DXGI_USAGE DXGI_USAGE_UNORDERED_ACCESS = 0x400L; + +const UINT DXGI_ENUM_MODES_INTERLACED = 1; +const UINT DXGI_ENUM_MODES_SCALING = 2; + +const UINT DXGI_RESOURCE_PRIORITY_MINIMUM = 0x28000000; +const UINT DXGI_RESOURCE_PRIORITY_LOW = 0x50000000; +const UINT DXGI_RESOURCE_PRIORITY_NORMAL = 0x78000000; +const UINT DXGI_RESOURCE_PRIORITY_HIGH = 0xa0000000; +const UINT DXGI_RESOURCE_PRIORITY_MAXIMUM = 0xc8000000; + +const UINT DXGI_MAP_READ = 0x1; +const UINT DXGI_MAP_WRITE = 0x2; +const UINT DXGI_MAP_DISCARD = 0x4; + +typedef enum DXGI_SWAP_EFFECT { + DXGI_SWAP_EFFECT_DISCARD = 0, + DXGI_SWAP_EFFECT_SEQUENTIAL = 1, + DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL = 3, + DXGI_SWAP_EFFECT_FLIP_DISCARD = 4 +} DXGI_SWAP_EFFECT; + +typedef enum DXGI_RESIDENCY { + DXGI_RESIDENCY_FULLY_RESIDENT = 1, + DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY = 2, + DXGI_RESIDENCY_EVICTED_TO_DISK = 3, +} DXGI_RESIDENCY; + +typedef struct DXGI_SURFACE_DESC { + UINT Width; + UINT Height; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; +} DXGI_SURFACE_DESC; + +typedef struct DXGI_MAPPED_RECT { + INT Pitch; + BYTE *pBits; +} DXGI_MAPPED_RECT; + +typedef struct DXGI_OUTPUT_DESC { + WCHAR DeviceName[32]; + RECT DesktopCoordinates; + BOOL AttachedToDesktop; + DXGI_MODE_ROTATION Rotation; + HMONITOR Monitor; +} DXGI_OUTPUT_DESC; + +typedef struct DXGI_FRAME_STATISTICS { + UINT PresentCount; + UINT PresentRefreshCount; + UINT SyncRefreshCount; + LARGE_INTEGER SyncQPCTime; + LARGE_INTEGER SyncGPUTime; +} DXGI_FRAME_STATISTICS; + +typedef struct DXGI_ADAPTER_DESC { + WCHAR Description[128]; + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + SIZE_T DedicatedVideoMemory; + SIZE_T DedicatedSystemMemory; + SIZE_T SharedSystemMemory; + LUID AdapterLuid; +} DXGI_ADAPTER_DESC; + +typedef enum DXGI_SWAP_CHAIN_FLAG +{ + DXGI_SWAP_CHAIN_FLAG_NONPREROTATED = 0x0001, + DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH = 0x0002, + DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE = 0x0004, + DXGI_SWAP_CHAIN_FLAG_RESTRICTED_CONTENT = 0x0008, + DXGI_SWAP_CHAIN_FLAG_RESTRICT_SHARED_RESOURCE_DRIVER = 0x0010, + DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY = 0x0020, + DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT = 0x0040, + DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER = 0x0080, + DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO = 0x0100, + DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO = 0x0200, + DXGI_SWAP_CHAIN_FLAG_HW_PROTECTED = 0x0400, + DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING = 0x0800, + DXGI_SWAP_CHAIN_FLAG_RESTRICTED_TO_ALL_HOLOGRAPHIC_DISPLAYS = 0x1000, +} DXGI_SWAP_CHAIN_FLAG; + +typedef struct DXGI_SWAP_CHAIN_DESC { + DXGI_MODE_DESC BufferDesc; + DXGI_SAMPLE_DESC SampleDesc; + DXGI_USAGE BufferUsage; + UINT BufferCount; + HWND OutputWindow; + BOOL Windowed; + DXGI_SWAP_EFFECT SwapEffect; + UINT Flags; +} DXGI_SWAP_CHAIN_DESC; + +typedef struct DXGI_SHARED_RESOURCE { + HANDLE Handle; +} DXGI_SHARED_RESOURCE; + +[ + object, + local, + uuid(aec22fb8-76f3-4639-9be0-28eb43a67a2e) +] +interface IDXGIObject : IUnknown +{ + HRESULT SetPrivateData( + [in] REFGUID guid, + [in] UINT data_size, + [in] const void *data + ); + HRESULT SetPrivateDataInterface( + [in] REFGUID guid, + [in] const IUnknown *object + ); + HRESULT GetPrivateData( + [in] REFGUID guid, + [in, out] UINT *data_size, + [out] void *data + ); + HRESULT GetParent( + [in] REFIID riid, + [out] void **parent + ); +} + +[ + object, + local, + uuid(3d3e0379-f9de-4d58-bb6c-18d62992f1a6) +] +interface IDXGIDeviceSubObject : IDXGIObject +{ + HRESULT GetDevice( + [in] REFIID riid, + [out] void **device + ); +} + +[ + object, + uuid(035f3ab4-482e-4e50-b41f-8a7f8bd8960b), + local, + pointer_default(unique) +] +interface IDXGIResource : IDXGIDeviceSubObject +{ + HRESULT GetSharedHandle([out] HANDLE *pSharedHandle); + HRESULT GetUsage([out] DXGI_USAGE *pUsage); + HRESULT SetEvictionPriority([in] UINT EvictionPriority); + HRESULT GetEvictionPriority([out, retval] UINT *pEvictionPriority); +} + +[ + object, + uuid(9d8e1289-d7b3-465f-8126-250e349af85d), + local, + pointer_default(unique) +] +interface IDXGIKeyedMutex : IDXGIDeviceSubObject +{ + HRESULT AcquireSync([in] UINT64 Key, [in] DWORD dwMilliseconds); + HRESULT ReleaseSync([in] UINT64 Key); +} + +[ + object, + local, + uuid(cafcb56c-6ac3-4889-bf47-9e23bbd260ec) +] +interface IDXGISurface : IDXGIDeviceSubObject +{ + HRESULT GetDesc( + [out] DXGI_SURFACE_DESC *desc + ); + HRESULT Map( + [out] DXGI_MAPPED_RECT *mapped_rect, + [in] UINT flags + ); + HRESULT Unmap( + ); +} + +[ + object, + local, + uuid(4ae63092-6327-4c1b-80ae-bfe12ea32b86) +] +interface IDXGISurface1 : IDXGISurface +{ + HRESULT GetDC( + [in] BOOL discard, + [out] HDC *hdc + ); + HRESULT ReleaseDC( + [in] RECT *dirty_rect + ); +} + +[ + object, + local, + uuid(ae02eedb-c735-4690-8d52-5a8dc20213aa) +] +interface IDXGIOutput : IDXGIObject +{ + HRESULT GetDesc( + [out] DXGI_OUTPUT_DESC *desc + ); + HRESULT GetDisplayModeList( + [in] DXGI_FORMAT format, + [in] UINT flags, + [in, out] UINT *mode_count, + [out] DXGI_MODE_DESC *desc + ); + HRESULT FindClosestMatchingMode( + [in] const DXGI_MODE_DESC *mode, + [out] DXGI_MODE_DESC *closest_match, + [in] IUnknown *device + ); + HRESULT WaitForVBlank( + ); + HRESULT TakeOwnership( + [in] IUnknown *device, + [in] BOOL exclusive + ); + void ReleaseOwnership( + ); + HRESULT GetGammaControlCapabilities( + [out] DXGI_GAMMA_CONTROL_CAPABILITIES *gamma_caps + ); + HRESULT SetGammaControl( + [in] const DXGI_GAMMA_CONTROL *gamma_control + ); + HRESULT GetGammaControl( + [out] DXGI_GAMMA_CONTROL *gamma_control + ); + HRESULT SetDisplaySurface( + [in] IDXGISurface *surface + ); + HRESULT GetDisplaySurfaceData( + [in] IDXGISurface *surface + ); + HRESULT GetFrameStatistics( + [out] DXGI_FRAME_STATISTICS *stats + ); +} + +[ + object, + local, + uuid(2411e7e1-12ac-4ccf-bd14-9798e8534dc0) +] +interface IDXGIAdapter : IDXGIObject +{ + HRESULT EnumOutputs( + [in] UINT output_idx, + [in, out] IDXGIOutput **output + ); + HRESULT GetDesc( + [out] DXGI_ADAPTER_DESC *desc + ); + HRESULT CheckInterfaceSupport( + [in] REFGUID guid, + [out] LARGE_INTEGER *umd_version + ); +} + +cpp_quote("#define DXGI_MAX_SWAP_CHAIN_BUFFERS (16)") + +cpp_quote("#define DXGI_PRESENT_TEST __MSABI_LONG(0x00000001U)") +cpp_quote("#define DXGI_PRESENT_DO_NOT_SEQUENCE __MSABI_LONG(0x00000002U)") +cpp_quote("#define DXGI_PRESENT_RESTART __MSABI_LONG(0x00000004U)") +cpp_quote("#define DXGI_PRESENT_DO_NOT_WAIT __MSABI_LONG(0x00000008U)") +cpp_quote("#define DXGI_PRESENT_STEREO_PREFER_RIGHT __MSABI_LONG(0x00000010U)") +cpp_quote("#define DXGI_PRESENT_STEREO_TEMPORARY_MONO __MSABI_LONG(0x00000020U)") +cpp_quote("#define DXGI_PRESENT_RESTRICT_TO_OUTPUT __MSABI_LONG(0x00000040U)") +cpp_quote("#define DXGI_PRESENT_USE_DURATION __MSABI_LONG(0x00000100U)") +cpp_quote("#define DXGI_PRESENT_ALLOW_TEARING __MSABI_LONG(0x00000200U)") + +[ + object, + local, + uuid(310d36a0-d2e7-4c0a-aa04-6a9d23b8886a) +] +interface IDXGISwapChain : IDXGIDeviceSubObject +{ + HRESULT Present( + [in] UINT sync_interval, + [in] UINT flags + ); + HRESULT GetBuffer( + [in] UINT buffer_idx, + [in] REFIID riid, + [in, out] void **surface + ); + HRESULT SetFullscreenState( + [in] BOOL fullscreen, + [in] IDXGIOutput *target + ); + HRESULT GetFullscreenState( + [out] BOOL *fullscreen, + [out] IDXGIOutput **target + ); + HRESULT GetDesc( + [out] DXGI_SWAP_CHAIN_DESC *desc + ); + HRESULT ResizeBuffers( + [in] UINT buffer_count, + [in] UINT width, + [in] UINT height, + [in] DXGI_FORMAT format, + [in] UINT flags + ); + HRESULT ResizeTarget( + [in] const DXGI_MODE_DESC *target_mode_desc + ); + HRESULT GetContainingOutput( + [out] IDXGIOutput **output + ); + HRESULT GetFrameStatistics( + [out] DXGI_FRAME_STATISTICS *stats + ); + HRESULT GetLastPresentCount( + [out] UINT *last_present_count + ); +} + +cpp_quote("#define DXGI_MWA_NO_WINDOW_CHANGES 0x1") +cpp_quote("#define DXGI_MWA_NO_ALT_ENTER 0x2") +cpp_quote("#define DXGI_MWA_NO_PRINT_SCREEN 0x4") +cpp_quote("#define DXGI_MWA_VALID 0x7") + +[ + object, + local, + uuid(7b7166ec-21c7-44ae-b21a-c9ae321ae369) +] +interface IDXGIFactory : IDXGIObject +{ + HRESULT EnumAdapters( + [in] UINT adapter_idx, + [out] IDXGIAdapter **adapter + ); + HRESULT MakeWindowAssociation( + [in] HWND window, + [in] UINT flags + ); + HRESULT GetWindowAssociation( + [in] HWND *window + ); + HRESULT CreateSwapChain( + [in] IUnknown *device, + [in] DXGI_SWAP_CHAIN_DESC *desc, + [out] IDXGISwapChain **swapchain + ); + HRESULT CreateSoftwareAdapter( + [in] HMODULE swrast, + [out] IDXGIAdapter **adapter + ); +} + +[local] HRESULT __stdcall CreateDXGIFactory(REFIID riid, void **factory); +[local] HRESULT __stdcall CreateDXGIFactory1(REFIID riid, void **factory); + +[ + object, + local, + uuid(54ec77fa-1377-44e6-8c32-88fd5f44c84c) +] +interface IDXGIDevice : IDXGIObject +{ + HRESULT GetAdapter( + [out] IDXGIAdapter **adapter + ); + HRESULT CreateSurface( + [in] const DXGI_SURFACE_DESC *desc, + [in] UINT surface_count, + [in] DXGI_USAGE usage, + [in] const DXGI_SHARED_RESOURCE *shared_resource, + [out] IDXGISurface **surface + ); + HRESULT QueryResourceResidency( + [in] IUnknown *const *resources, + [out] DXGI_RESIDENCY *residency, + [in] UINT resource_count + ); + HRESULT SetGPUThreadPriority( + [in] INT priority + ); + HRESULT GetGPUThreadPriority( + [out] INT *priority + ); +} + +typedef enum DXGI_ADAPTER_FLAG { + DXGI_ADAPTER_FLAG_NONE = 0, + DXGI_ADAPTER_FLAG_REMOTE = 1, + DXGI_ADAPTER_FLAG_SOFTWARE = 2, + DXGI_ADAPTER_FLAG_FORCE_DWORD = 0xFFFFFFFF +} DXGI_ADAPTER_FLAG; + +typedef struct DXGI_ADAPTER_DESC1 { + WCHAR Description[128]; + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + SIZE_T DedicatedVideoMemory; + SIZE_T DedicatedSystemMemory; + SIZE_T SharedSystemMemory; + LUID AdapterLuid; + UINT Flags; +} DXGI_ADAPTER_DESC1; + +typedef struct DXGI_DISPLAY_COLOR_SPACE { + FLOAT PrimaryCoordinates[8][2]; + FLOAT WhitePoints[16][2]; +} DXGI_DISPLAY_COLOR_SPACE; + +[ + object, + uuid(29038f61-3839-4626-91fd-086879011a05), + local, + pointer_default(unique) +] +interface IDXGIAdapter1 : IDXGIAdapter +{ + HRESULT GetDesc1([out] DXGI_ADAPTER_DESC1 *pDesc); +} + +[ + object, + uuid(77db970f-6276-48ba-ba28-070143b4392c), + local, + pointer_default(unique) +] +interface IDXGIDevice1 : IDXGIDevice +{ + HRESULT SetMaximumFrameLatency([in] UINT MaxLatency); + HRESULT GetMaximumFrameLatency([out] UINT *pMaxLatency); +} + +[ + object, + uuid(770aae78-f26f-4dba-a829-253c83d1b387), + local, + pointer_default(unique) + ] +interface IDXGIFactory1 : IDXGIFactory +{ + HRESULT EnumAdapters1([in] UINT Adapter, [out] IDXGIAdapter1 **ppAdapter); + BOOL IsCurrent(); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgi1_2.idl b/WineFix/lib/d2d1/include/windows/dxgi1_2.idl new file mode 100644 index 0000000..921a66e --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgi1_2.idl @@ -0,0 +1,423 @@ +/* + * Copyright 2014 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgi.idl"; + +const UINT DXGI_ENUM_MODES_STEREO = 0x4; +const UINT DXGI_ENUM_MODES_DISABLED_STEREO = 0x8; + +const DWORD DXGI_SHARED_RESOURCE_READ = 0x80000000; +const DWORD DXGI_SHARED_RESOURCE_WRITE = 0x00000001; + +typedef enum _DXGI_OFFER_RESOURCE_PRIORITY { + DXGI_OFFER_RESOURCE_PRIORITY_LOW = 1, + DXGI_OFFER_RESOURCE_PRIORITY_NORMAL, + DXGI_OFFER_RESOURCE_PRIORITY_HIGH +} DXGI_OFFER_RESOURCE_PRIORITY; + +typedef enum DXGI_ALPHA_MODE { + DXGI_ALPHA_MODE_UNSPECIFIED = 0, + DXGI_ALPHA_MODE_PREMULTIPLIED = 1, + DXGI_ALPHA_MODE_STRAIGHT = 2, + DXGI_ALPHA_MODE_IGNORE = 3, + DXGI_ALPHA_MODE_FORCE_DWORD = 0xffffffff +} DXGI_ALPHA_MODE; + +typedef struct DXGI_OUTDUPL_MOVE_RECT +{ + POINT SourcePoint; + RECT DestinationRect; +} DXGI_OUTDUPL_MOVE_RECT; + +typedef struct DXGI_OUTDUPL_DESC +{ + DXGI_MODE_DESC ModeDesc; + DXGI_MODE_ROTATION Rotation; + BOOL DesktopImageInSystemMemory; +} DXGI_OUTDUPL_DESC; + +typedef struct DXGI_OUTDUPL_POINTER_POSITION +{ + POINT Position; + BOOL Visible; +} DXGI_OUTDUPL_POINTER_POSITION; + +typedef enum DXGI_OUTDUPL_POINTER_SHAPE_TYPE +{ + DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME = 0x00000001, + DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR = 0x00000002, + DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR = 0x00000004 +} DXGI_OUTDUPL_POINTER_SHAPE_TYPE; + +typedef struct DXGI_OUTDUPL_POINTER_SHAPE_INFO +{ + UINT Type; + UINT Width; + UINT Height; + UINT Pitch; + POINT HotSpot; +} DXGI_OUTDUPL_POINTER_SHAPE_INFO; + +typedef struct DXGI_OUTDUPL_FRAME_INFO +{ + LARGE_INTEGER LastPresentTime; + LARGE_INTEGER LastMouseUpdateTime; + UINT AccumulatedFrames; + BOOL RectsCoalesced; + BOOL ProtectedContentMaskedOut; + DXGI_OUTDUPL_POINTER_POSITION PointerPosition; + UINT TotalMetadataBufferSize; + UINT PointerShapeBufferSize; +} DXGI_OUTDUPL_FRAME_INFO; + +typedef struct DXGI_MODE_DESC1 +{ + UINT Width; + UINT Height; + DXGI_RATIONAL RefreshRate; + DXGI_FORMAT Format; + DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; + DXGI_MODE_SCALING Scaling; + BOOL Stereo; +} DXGI_MODE_DESC1; + +[ + object, + uuid(191cfac3-a341-470d-b26e-a864f428319c), + local, + pointer_default(unique) +] +interface IDXGIOutputDuplication : IDXGIObject +{ + void GetDesc( + [out] DXGI_OUTDUPL_DESC *desc + ); + + HRESULT AcquireNextFrame( + [in] UINT timeout_in_milliseconds, + [out] DXGI_OUTDUPL_FRAME_INFO *frame_info, + [out] IDXGIResource **desktop_resource + ); + + HRESULT GetFrameDirtyRects( + [in] UINT dirty_rects_buffer_size, + [out] RECT *dirty_rects_buffer, + [out] UINT *dirty_rects_buffer_size_required + ); + + HRESULT GetFrameMoveRects( + [in] UINT move_rects_buffer_size, + [out] DXGI_OUTDUPL_MOVE_RECT *move_rect_buffer, + [out] UINT *move_rects_buffer_size_required + ); + + HRESULT GetFramePointerShape( + [in] UINT pointer_shape_buffer_size, + [out] void *pointer_shape_buffer, + [out] UINT *pointer_shape_buffer_size_required, + [out] DXGI_OUTDUPL_POINTER_SHAPE_INFO *pointer_shape_info + ); + + HRESULT MapDesktopSurface( + [out] DXGI_MAPPED_RECT *locked_rect + ); + + HRESULT UnMapDesktopSurface(); + + HRESULT ReleaseFrame(); +} + +[ + object, + uuid(aba496dd-b617-4cb8-a866-bc44d7eb1fa2), + local, + pointer_default(unique) +] +interface IDXGISurface2 : IDXGISurface1 +{ + HRESULT GetResource( + [in] REFIID iid, + [out] void **parent_resource, + [out] UINT *subresource_idx + ); +} + +[ + object, + uuid(30961379-4609-4a41-998e-54fe567ee0c1), + local, + pointer_default(unique) +] +interface IDXGIResource1 : IDXGIResource +{ + HRESULT CreateSubresourceSurface( + UINT index, + [out] IDXGISurface2 **surface + ); + HRESULT CreateSharedHandle( + [in] const SECURITY_ATTRIBUTES *attributes, + [in] DWORD access, + [in] const WCHAR *name, + [out] HANDLE *handle + ); +} + +[ + object, + uuid(ea9dbf1a-c88e-4486-854a-98aa0138f30c), + local, + pointer_default(unique) +] +interface IDXGIDisplayControl : IUnknown +{ + BOOL IsStereoEnabled(); + void SetStereoEnabled(BOOL enabled); +} + +[ + object, + uuid(05008617-fbfd-4051-a790-144884b4f6a9), + local, + pointer_default(unique) +] +interface IDXGIDevice2 : IDXGIDevice1 +{ + HRESULT OfferResources( + [in] UINT NumResources, + [in, size_is(NumResources)] IDXGIResource *const *ppResources, + [in] DXGI_OFFER_RESOURCE_PRIORITY Priority); + + HRESULT ReclaimResources( + [in] UINT NumResources, + [in, size_is(NumResources)] IDXGIResource *const *ppResources, + [out, size_is(NumResources)] BOOL *pDiscarded); + + HRESULT EnqueueSetEvent( + [in] HANDLE hEvent); +} + +typedef enum DXGI_SCALING { + DXGI_SCALING_STRETCH = 0, + DXGI_SCALING_NONE = 1, + DXGI_SCALING_ASPECT_RATIO_STRETCH = 2, +} DXGI_SCALING; + +typedef struct DXGI_SWAP_CHAIN_DESC1 { + UINT Width; + UINT Height; + DXGI_FORMAT Format; + BOOL Stereo; + DXGI_SAMPLE_DESC SampleDesc; + DXGI_USAGE BufferUsage; + UINT BufferCount; + DXGI_SCALING Scaling; + DXGI_SWAP_EFFECT SwapEffect; + DXGI_ALPHA_MODE AlphaMode; + UINT Flags; +} DXGI_SWAP_CHAIN_DESC1; + +typedef struct DXGI_SWAP_CHAIN_FULLSCREEN_DESC { + DXGI_RATIONAL RefreshRate; + DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; + DXGI_MODE_SCALING Scaling; + BOOL Windowed; +} DXGI_SWAP_CHAIN_FULLSCREEN_DESC; + +typedef struct DXGI_PRESENT_PARAMETERS { + UINT DirtyRectsCount; + RECT *pDirtyRects; + RECT *pScrollRect; + POINT *pScrollOffset; +} DXGI_PRESENT_PARAMETERS; + +[ + object, + uuid(790a45f7-0d42-4876-983a-0a55cfe6f4aa), + local, + pointer_default(unique) +] +interface IDXGISwapChain1 : IDXGISwapChain +{ + HRESULT GetDesc1( + [out] DXGI_SWAP_CHAIN_DESC1 *pDesc); + + HRESULT GetFullscreenDesc( + [out] DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc); + + HRESULT GetHwnd( + [out] HWND *pHwnd); + + HRESULT GetCoreWindow( + [in] REFIID refiid, + [out] void **ppUnk); + + HRESULT Present1( + [in] UINT SyncInterval, + [in] UINT PresentFlags, + [in] const DXGI_PRESENT_PARAMETERS *pPresentParameters); + + BOOL IsTemporaryMonoSupported(); + + HRESULT GetRestrictToOutput( + [out] IDXGIOutput **ppRestrictToOutput); + + HRESULT SetBackgroundColor( + [in] const DXGI_RGBA *pColor); + + HRESULT GetBackgroundColor( + [out] DXGI_RGBA *pColor); + + HRESULT SetRotation( + [in] DXGI_MODE_ROTATION Rotation); + + HRESULT GetRotation( + [out] DXGI_MODE_ROTATION *pRotation); +} + +[ + object, + uuid(50c83a1c-e072-4c48-87b0-3630fa36a6d0), + local, + pointer_default(unique) +] +interface IDXGIFactory2 : IDXGIFactory1 +{ + BOOL IsWindowedStereoEnabled(); + + HRESULT CreateSwapChainForHwnd( + [in] IUnknown *pDevice, + [in] HWND hWnd, + [in] const DXGI_SWAP_CHAIN_DESC1 *pDesc, + [in] const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pFullscreenDesc, + [in] IDXGIOutput *pRestrictToOutput, + [out] IDXGISwapChain1 **ppSwapChain); + + HRESULT CreateSwapChainForCoreWindow( + [in] IUnknown *pDevice, + [in] IUnknown *pWindow, + [in] const DXGI_SWAP_CHAIN_DESC1 *pDesc, + [in] IDXGIOutput *pRestrictToOutput, + [out] IDXGISwapChain1 **ppSwapChain); + + HRESULT GetSharedResourceAdapterLuid( + [in] HANDLE hResource, + [out] LUID *pLuid); + + HRESULT RegisterStereoStatusWindow( + [in] HWND WindowHandle, + [in] UINT wMsg, + [out] DWORD *pdwCookie); + + HRESULT RegisterStereoStatusEvent( + [in] HANDLE hEvent, + [out] DWORD *pdwCookie); + + void UnregisterStereoStatus( + [in] DWORD dwCookie); + + HRESULT RegisterOcclusionStatusWindow( + [in] HWND WindowHandle, + [in] UINT wMsg, + [out] DWORD *pdwCookie); + + HRESULT RegisterOcclusionStatusEvent( + [in] HANDLE hEvent, + [out] DWORD *pdwCookie); + + void UnregisterOcclusionStatus( + [in] DWORD dwCookie); + + HRESULT CreateSwapChainForComposition( + [in] IUnknown *pDevice, + [in] const DXGI_SWAP_CHAIN_DESC1 *pDesc, + [in] IDXGIOutput *pRestrictToOutput, + [out] IDXGISwapChain1 **ppSwapChain); +} + +typedef enum DXGI_GRAPHICS_PREEMPTION_GRANULARITY { + DXGI_GRAPHICS_PREEMPTION_DMA_BUFFER_BOUNDARY, + DXGI_GRAPHICS_PREEMPTION_PRIMITIVE_BOUNDARY, + DXGI_GRAPHICS_PREEMPTION_TRIANGLE_BOUNDARY, + DXGI_GRAPHICS_PREEMPTION_PIXEL_BOUNDARY, + DXGI_GRAPHICS_PREEMPTION_INSTRUCTION_BOUNDARY +} DXGI_GRAPHICS_PREEMPTION_GRANULARITY; + +typedef enum DXGI_COMPUTE_PREEMPTION_GRANULARITY { + DXGI_COMPUTE_PREEMPTION_DMA_BUFFER_BOUNDARY, + DXGI_COMPUTE_PREEMPTION_DISPATCH_BOUNDARY, + DXGI_COMPUTE_PREEMPTION_THREAD_GROUP_BOUNDARY, + DXGI_COMPUTE_PREEMPTION_THREAD_BOUNDARY, + DXGI_COMPUTE_PREEMPTION_INSTRUCTION_BOUNDARY +} DXGI_COMPUTE_PREEMPTION_GRANULARITY; + +typedef struct DXGI_ADAPTER_DESC2 { + WCHAR Description[128]; + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + SIZE_T DedicatedVideoMemory; + SIZE_T DedicatedSystemMemory; + SIZE_T SharedSystemMemory; + LUID AdapterLuid; + UINT Flags; + DXGI_GRAPHICS_PREEMPTION_GRANULARITY GraphicsPreemptionGranularity; + DXGI_COMPUTE_PREEMPTION_GRANULARITY ComputePreemptionGranularity; +} DXGI_ADAPTER_DESC2; + +[ + object, + uuid(0aa1ae0a-fa0e-4b84-8644-e05ff8e5acb5), + local, + pointer_default(unique) +] +interface IDXGIAdapter2 : IDXGIAdapter1 +{ + HRESULT GetDesc2([out] DXGI_ADAPTER_DESC2 *pDesc); +} + +[ + object, + uuid(00cddea8-939b-4b83-a340-a685226666cc), + local, + pointer_default(unique) +] +interface IDXGIOutput1 : IDXGIOutput +{ + HRESULT GetDisplayModeList1( + [in] DXGI_FORMAT enum_format, + [in] UINT flags, + [in, out] UINT *num_modes, + [out] DXGI_MODE_DESC1 *desc + ); + + HRESULT FindClosestMatchingMode1( + [in] const DXGI_MODE_DESC1 *mode_to_match, + [out] DXGI_MODE_DESC1 *closest_match, + [in] IUnknown *concerned_device + ); + + HRESULT GetDisplaySurfaceData1( + [in] IDXGIResource *destination + ); + + HRESULT DuplicateOutput( + [in] IUnknown *device, + [out] IDXGIOutputDuplication **output_duplication + ); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgi1_3.idl b/WineFix/lib/d2d1/include/windows/dxgi1_3.idl new file mode 100644 index 0000000..b43ca23 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgi1_3.idl @@ -0,0 +1,231 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgi1_2.idl"; + +typedef struct DXGI_MATRIX_3X2_F +{ + float _11; + float _12; + float _21; + float _22; + float _31; + float _32; +} DXGI_MATRIX_3X2_F; + +typedef struct DXGI_DECODE_SWAP_CHAIN_DESC +{ + UINT Flags; +} DXGI_DECODE_SWAP_CHAIN_DESC; + +typedef enum DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS +{ + DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAG_NOMINAL_RANGE = 0x1, + DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAG_BT709 = 0x2, + DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAG_xvYCC = 0x4, +} DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS; + +typedef enum DXGI_FRAME_PRESENTATION_MODE +{ + DXGI_FRAME_PRESENTATION_MODE_COMPOSED = 0, + DXGI_FRAME_PRESENTATION_MODE_OVERLAY = 1, + DXGI_FRAME_PRESENTATION_MODE_NONE = 2, + DXGI_FRAME_PRESENTATION_MODE_COMPOSITION_FAILURE = 3, +} DXGI_FRAME_PRESENTATION_MODE; + +typedef struct DXGI_FRAME_STATISTICS_MEDIA +{ + UINT PresentCount; + UINT PresentRefreshCount; + UINT SyncRefreshCount; + LARGE_INTEGER SyncQPCTime; + LARGE_INTEGER SyncGPUTime; + DXGI_FRAME_PRESENTATION_MODE CompositionMode; + UINT ApprovedPresentDuration; +} DXGI_FRAME_STATISTICS_MEDIA; + +typedef enum DXGI_OVERLAY_SUPPORT_FLAG +{ + DXGI_OVERLAY_SUPPORT_FLAG_DIRECT = 0x1, + DXGI_OVERLAY_SUPPORT_FLAG_SCALING = 0x2, +} DXGI_OVERLAY_SUPPORT_FLAG; + +[ + object, + uuid(6007896c-3244-4afd-bf18-a6d3beda5023), + local, + pointer_default(unique) +] +interface IDXGIDevice3 : IDXGIDevice2 +{ + void Trim(); +} + +[ + object, + uuid(a8be2ac4-199f-4946-b331-79599fb98de7), + local, + pointer_default(unique) +] +interface IDXGISwapChain2 : IDXGISwapChain1 +{ + HRESULT SetSourceSize(UINT width, UINT height); + + HRESULT GetSourceSize( + [out] UINT *width, + [out] UINT *height + ); + + HRESULT SetMaximumFrameLatency(UINT max_latency); + + HRESULT GetMaximumFrameLatency( + [out] UINT *max_latency + ); + + HANDLE GetFrameLatencyWaitableObject(); + + HRESULT SetMatrixTransform(const DXGI_MATRIX_3X2_F *matrix); + + HRESULT GetMatrixTransform( + [out] DXGI_MATRIX_3X2_F *matrix + ); +} + +[ + object, + uuid(595e39d1-2724-4663-99b1-da969de28364), + local, + pointer_default(unique) +] +interface IDXGIOutput2 : IDXGIOutput1 +{ + BOOL SupportsOverlays(); +} + +[ + object, + uuid(25483823-cd46-4c7d-86ca-47aa95b837bd), + local, + pointer_default(unique) +] +interface IDXGIFactory3 : IDXGIFactory2 +{ + UINT GetCreationFlags(); +} + +[ + object, + uuid(2633066b-4514-4c7a-8fd8-12ea98059d18), + local, + pointer_default(unique) +] +interface IDXGIDecodeSwapChain : IUnknown +{ + HRESULT PresentBuffer(UINT buffer_to_present, UINT sync_interval, UINT flags); + + HRESULT SetSourceRect(const RECT *rect); + + HRESULT SetTargetRect(const RECT *rect); + + HRESULT SetDestSize(UINT width, UINT height); + + HRESULT GetSourceRect( + [out] RECT *rect + ); + + HRESULT GetTargetRect( + [out] RECT *rect + ); + + HRESULT GetDestSize( + [out] UINT *width, + [out] UINT *height + ); + + HRESULT SetColorSpace(DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS colorspace); + + DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS GetColorSpace(); +} + +[ + object, + uuid(41e7d1f2-a591-4f7b-a2e5-fa9c843e1c12), + local, + pointer_default(unique) +] +interface IDXGIFactoryMedia : IUnknown +{ + HRESULT CreateSwapChainForCompositionSurfaceHandle( + [in] IUnknown *device, + [in] HANDLE surface, + [in] const DXGI_SWAP_CHAIN_DESC1 *desc, + [in] IDXGIOutput *restrict_to_output, + [out] IDXGISwapChain1 **swapchain + ); + + HRESULT CreateDecodeSwapChainForCompositionSurfaceHandle( + [in] IUnknown *device, + [in] HANDLE surface, + [in] DXGI_DECODE_SWAP_CHAIN_DESC *desc, + [in] IDXGIResource *yuv_decode_buffers, + [in] IDXGIOutput *restrict_to_output, + [out] IDXGIDecodeSwapChain **swapchain + ); +} + +[ + object, + uuid(dd95b90b-f05f-4f6a-bd65-25bfb264bd84), + local, + pointer_default(unique) +] +interface IDXGISwapChainMedia : IUnknown +{ + HRESULT GetFrameStatisticsMedia( + [out] DXGI_FRAME_STATISTICS_MEDIA *stats + ); + + HRESULT SetPresentDuration(UINT duration); + + HRESULT CheckPresentDurationSupport( + UINT desired_present_duration, + [out] UINT *closest_smaller_present_duration, + [out] UINT *closest_larger_present_duration + ); +} + +[ + object, + uuid(8a6bb301-7e7e-41F4-a8e0-5b32f7f99b18), + local, + pointer_default(unique) +] +interface IDXGIOutput3 : IDXGIOutput2 +{ + HRESULT CheckOverlaySupport( + [in] DXGI_FORMAT enum_format, + [out] IUnknown *concerned_device, + [out] UINT *flags + ); +} + +const UINT DXGI_CREATE_FACTORY_DEBUG = 0x1; + +[local] HRESULT __stdcall CreateDXGIFactory2(UINT flags, REFIID iid, void **factory); + +[local] HRESULT __stdcall DXGIGetDebugInterface1(UINT flags, REFIID iid, void **debug); diff --git a/WineFix/lib/d2d1/include/windows/dxgi1_4.idl b/WineFix/lib/d2d1/include/windows/dxgi1_4.idl new file mode 100644 index 0000000..0f63df2 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgi1_4.idl @@ -0,0 +1,140 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgi1_3.idl"; + +typedef enum DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG +{ + DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT = 0x1, + DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_OVERLAY_PRESENT = 0x2, +} DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG; + +typedef enum DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG +{ + DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT = 0x1, +} DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG; + +typedef enum DXGI_MEMORY_SEGMENT_GROUP +{ + DXGI_MEMORY_SEGMENT_GROUP_LOCAL = 0x0, + DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL = 0x1, +} DXGI_MEMORY_SEGMENT_GROUP; + +typedef struct DXGI_QUERY_VIDEO_MEMORY_INFO +{ + UINT64 Budget; + UINT64 CurrentUsage; + UINT64 AvailableForReservation; + UINT64 CurrentReservation; +} DXGI_QUERY_VIDEO_MEMORY_INFO; + +[ + object, + uuid(94d99bdb-f1f8-4ab0-b236-7da0170edab1), + local, + pointer_default(unique) +] +interface IDXGISwapChain3 : IDXGISwapChain2 +{ + UINT GetCurrentBackBufferIndex(); + HRESULT CheckColorSpaceSupport( + [in] DXGI_COLOR_SPACE_TYPE colour_space, + [out] UINT *colour_space_support + ); + HRESULT SetColorSpace1( + [in] DXGI_COLOR_SPACE_TYPE colour_space + ); + HRESULT ResizeBuffers1( + [in] UINT buffer_count, + [in] UINT width, + [in] UINT height, + [in] DXGI_FORMAT format, + [in] UINT flags, + [in] const UINT *node_mask, + [in] IUnknown *const *present_queue + ); +} + +[ + object, + uuid(dc7dca35-2196-414d-9F53-617884032a60), + local, + pointer_default(unique) +] +interface IDXGIOutput4 : IDXGIOutput3 +{ + HRESULT CheckOverlayColorSpaceSupport( + [in] DXGI_FORMAT format, + [in] DXGI_COLOR_SPACE_TYPE colour_space, + [in] IUnknown *device, + [out] UINT *flags + ); +} + +[ + object, + uuid(1bc6ea02-ef36-464f-bf0c-21ca39e5168a), + local, + pointer_default(unique) +] +interface IDXGIFactory4 : IDXGIFactory3 +{ + HRESULT EnumAdapterByLuid( + [in] LUID luid, + [in] REFIID iid, + [out] void **adapter + ); + HRESULT EnumWarpAdapter( + [in] REFIID iid, + [out] void **adapter + ); +} + +[ + object, + uuid(645967a4-1392-4310-a798-8053ce3e93fd), + local, + pointer_default(unique) +] +interface IDXGIAdapter3 : IDXGIAdapter2 +{ + HRESULT RegisterHardwareContentProtectionTeardownStatusEvent( + [in] HANDLE event, + [out] DWORD *cookie + ); + void UnregisterHardwareContentProtectionTeardownStatus( + [in] DWORD cookie + ); + HRESULT QueryVideoMemoryInfo( + [in] UINT node_index, + [in] DXGI_MEMORY_SEGMENT_GROUP segment_group, + [out] DXGI_QUERY_VIDEO_MEMORY_INFO *memory_info + ); + HRESULT SetVideoMemoryReservation( + [in] UINT node_index, + [in] DXGI_MEMORY_SEGMENT_GROUP segment_group, + [in] UINT64 reservation + ); + HRESULT RegisterVideoMemoryBudgetChangeNotificationEvent( + [in] HANDLE event, + [out] DWORD *cookie + ); + void UnregisterVideoMemoryBudgetChangeNotification( + [in] DWORD cookie + ); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgi1_5.idl b/WineFix/lib/d2d1/include/windows/dxgi1_5.idl new file mode 100644 index 0000000..7919f01 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgi1_5.idl @@ -0,0 +1,133 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgi1_4.idl"; + +typedef enum DXGI_OUTDUPL_FLAG +{ + DXGI_OUTDUPL_COMPOSITED_UI_CAPTURE_ONLY = 0x1, +} DXGI_OUTDUPL_FLAG; + +typedef enum DXGI_HDR_METADATA_TYPE +{ + DXGI_HDR_METADATA_TYPE_NONE = 0x0, + DXGI_HDR_METADATA_TYPE_HDR10 = 0x1, + DXGI_HDR_METADATA_TYPE_HDR10PLUS = 0x2, +} DXGI_HDR_METADATA_TYPE; + +typedef enum _DXGI_OFFER_RESOURCE_FLAGS +{ + DXGI_OFFER_RESOURCE_FLAG_ALLOW_DECOMMIT = 0x1, +} DXGI_OFFER_RESOURCE_FLAGS; + +typedef enum _DXGI_RECLAIM_RESOURCE_RESULTS +{ + DXGI_RECLAIM_RESOURCE_RESULT_OK = 0x0, + DXGI_RECLAIM_RESOURCE_RESULT_DISCARDED = 0x1, + DXGI_RECLAIM_RESOURCE_RESULT_NOT_COMMITTED = 0x2, +} DXGI_RECLAIM_RESOURCE_RESULTS; + +typedef enum DXGI_FEATURE +{ + DXGI_FEATURE_PRESENT_ALLOW_TEARING = 0x0, +} DXGI_FEATURE; + +typedef struct DXGI_HDR_METADATA_HDR10 +{ + UINT16 RedPrimary[2]; + UINT16 GreenPrimary[2]; + UINT16 BluePrimary[2]; + UINT16 WhitePoint[2]; + UINT MaxMasteringLuminance; + UINT MinMasteringLuminance; + UINT16 MaxContentLightLevel; + UINT16 MaxFrameAverageLightLevel; +} DXGI_HDR_METADATA_HDR10; + +typedef struct DXGI_HDR_METADATA_HDR10PLUS +{ + BYTE Data[72]; +} DXGI_HDR_METADATA_HDR10PLUS; + +[ + object, + uuid(80a07424-ab52-42eb-833c-0c42fd282d98), + local, + pointer_default(unique) +] +interface IDXGIOutput5 : IDXGIOutput4 +{ + HRESULT DuplicateOutput1( + [in] IUnknown *device, + [in] UINT flags, + [in] UINT format_count, + [in] const DXGI_FORMAT *formats, + [out] IDXGIOutputDuplication **duplication + ); +} + +[ + object, + uuid(3d585d5a-bd4a-489e-b1f4-3dbcb6452ffb), + local, + pointer_default(unique) +] +interface IDXGISwapChain4 : IDXGISwapChain3 +{ + HRESULT SetHDRMetaData( + [in] DXGI_HDR_METADATA_TYPE type, + [in] UINT size, + [in] void *metadata + ); +} + +[ + object, + uuid(95b4f95f-d8da-4ca4-9ee6-3b76d5968a10), + local, + pointer_default(unique) +] +interface IDXGIDevice4 : IDXGIDevice3 +{ + HRESULT OfferResources1( + [in] UINT resource_count, + [in] IDXGIResource *const *resources, + [in] DXGI_OFFER_RESOURCE_PRIORITY priority, + [in] UINT flags + ); + HRESULT ReclaimResources1( + [in] UINT resource_count, + [in] IDXGIResource *const *resources, + [out] DXGI_RECLAIM_RESOURCE_RESULTS *results + ); +} + +[ + object, + uuid(7632e1f5-ee65-4dca-87fd-84cd75f8838d), + local, + pointer_default(unique) +] +interface IDXGIFactory5 : IDXGIFactory4 +{ + HRESULT CheckFeatureSupport( + DXGI_FEATURE feature, + [in, out] void *support_data, + UINT support_data_size + ); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgi1_6.idl b/WineFix/lib/d2d1/include/windows/dxgi1_6.idl new file mode 100644 index 0000000..5657f73 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgi1_6.idl @@ -0,0 +1,141 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgi1_5.idl"; + +typedef enum DXGI_ADAPTER_FLAG3 +{ + DXGI_ADAPTER_FLAG3_NONE = 0x0, + DXGI_ADAPTER_FLAG3_REMOTE = 0x1, + DXGI_ADAPTER_FLAG3_SOFTWARE = 0x2, + DXGI_ADAPTER_FLAG3_ACG_COMPATIBLE = 0x4, + DXGI_ADAPTER_FLAG3_SUPPORT_MONITORED_FENCES = 0x8, + DXGI_ADAPTER_FLAG3_SUPPORT_NON_MONITORED_FENCES = 0x10, + DXGI_ADAPTER_FLAG3_KEYED_MUTEX_CONFORMANCE = 0x20, + DXGI_ADAPTER_FLAG3_FORCE_DWORD = 0xffffffff, +} DXGI_ADAPTER_FLAG3; + +typedef enum DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAGS +{ + DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAG_FULLSCREEN = 0x1, + DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAG_WINDOWED = 0x2, + DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAG_CURSOR_STRETCHED = 0x4, +} DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAGS; + +typedef enum DXGI_GPU_PREFERENCE +{ + DXGI_GPU_PREFERENCE_UNSPECIFIED = 0x0, + DXGI_GPU_PREFERENCE_MINIMUM_POWER = 0x1, + DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE = 0x2, +} DXGI_GPU_PREFERENCE; + +typedef struct DXGI_ADAPTER_DESC3 +{ + WCHAR Description[128]; + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + SIZE_T DedicatedVideoMemory; + SIZE_T DedicatedSystemMemory; + SIZE_T SharedSystemMemory; + LUID AdapterLuid; + DXGI_ADAPTER_FLAG3 Flags; + DXGI_GRAPHICS_PREEMPTION_GRANULARITY GraphicsPreemptionGranularity; + DXGI_COMPUTE_PREEMPTION_GRANULARITY ComputePreemptionGranularity; +} DXGI_ADAPTER_DESC3; + +typedef struct DXGI_OUTPUT_DESC1 +{ + WCHAR DeviceName[32]; + RECT DesktopCoordinates; + BOOL AttachedToDesktop; + DXGI_MODE_ROTATION Rotation; + HMONITOR Monitor; + UINT BitsPerColor; + DXGI_COLOR_SPACE_TYPE ColorSpace; + FLOAT RedPrimary[2]; + FLOAT GreenPrimary[2]; + FLOAT BluePrimary[2]; + FLOAT WhitePoint[2]; + FLOAT MinLuminance; + FLOAT MaxLuminance; + FLOAT MaxFullFrameLuminance; +} DXGI_OUTPUT_DESC1; + +[ + object, + uuid(3c8d99d1-4fbf-4181-a82c-af66bf7bd24e), + local, + pointer_default(unique) +] +interface IDXGIAdapter4 : IDXGIAdapter3 +{ + HRESULT GetDesc3( + [out] DXGI_ADAPTER_DESC3 *desc + ); +} + +[ + object, + uuid(068346e8-aaec-4b84-add7-137f513f77a1), + local, + pointer_default(unique) +] +interface IDXGIOutput6 : IDXGIOutput5 +{ + HRESULT GetDesc1( + [out] DXGI_OUTPUT_DESC1 *desc + ); + HRESULT CheckHardwareCompositionSupport( + [out] UINT *flags + ); +} + +[ + object, + uuid(c1b6694f-ff09-44a9-b03c-77900a0a1d17), + local, + pointer_default(unique) +] +interface IDXGIFactory6 : IDXGIFactory5 +{ + HRESULT EnumAdapterByGpuPreference( + [in] UINT adapter_idx, + [in] DXGI_GPU_PREFERENCE gpu_preference, + [in] REFIID iid, + [out] void **adapter + ); +} + +[ + object, + uuid(a4966eed-76db-44da-84c1-ee9a7afb20a8), + local, + pointer_default(unique) +] +interface IDXGIFactory7 : IDXGIFactory6 +{ + HRESULT RegisterAdaptersChangedEvent( + [in] HANDLE event, + [out] DWORD *cookie + ); + HRESULT UnregisterAdaptersChangedEvent( + [in] DWORD cookie + ); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgicommon.idl b/WineFix/lib/d2d1/include/windows/dxgicommon.idl new file mode 100644 index 0000000..29c8f6a --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgicommon.idl @@ -0,0 +1,66 @@ +/* + * Copyright 2017 Ihsan Akmal + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +cpp_quote("#if 0") +typedef unsigned int UINT; +cpp_quote("#endif") + +const UINT DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN = 0xffffffff; +const UINT DXGI_CENTER_MULTISAMPLE_QUALITY_PATTERN = 0xfffffffe; + +typedef enum DXGI_COLOR_SPACE_TYPE +{ + DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 = 0x00, + DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 = 0x01, + DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709 = 0x02, + DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020 = 0x03, + DXGI_COLOR_SPACE_RESERVED = 0x04, + DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 = 0x05, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 = 0x06, + DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601 = 0x07, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 = 0x08, + DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709 = 0x09, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 = 0x0a, + DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 = 0x0b, + DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 = 0x0c, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020 = 0x0d, + DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020 = 0x0e, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020 = 0x0f, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020 = 0x10, + DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020 = 0x11, + DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020 = 0x12, + DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020 = 0x13, + DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709 = 0x14, + DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020 = 0x15, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709 = 0x16, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020 = 0x17, + DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020 = 0x18, + DXGI_COLOR_SPACE_CUSTOM = 0xffffffff, +} DXGI_COLOR_SPACE_TYPE; + +typedef struct DXGI_SAMPLE_DESC +{ + UINT Count; + UINT Quality; +} DXGI_SAMPLE_DESC; + +typedef struct DXGI_RATIONAL +{ + UINT Numerator; + UINT Denominator; +} DXGI_RATIONAL; diff --git a/WineFix/lib/d2d1/include/windows/dxgidebug.idl b/WineFix/lib/d2d1/include/windows/dxgidebug.idl new file mode 100644 index 0000000..f1c40af --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgidebug.idl @@ -0,0 +1,259 @@ +/* + * Copyright 2015 Steve Lhomme + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; + +const UINT DXGI_DEBUG_BINARY_VERSION = 1; + +typedef GUID DXGI_DEBUG_ID; + +cpp_quote("DEFINE_GUID(DXGI_DEBUG_ALL, 0xe48ae283, 0xda80, 0x490b,0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x08);") +cpp_quote("DEFINE_GUID(DXGI_DEBUG_DX, 0x35cdd7fc, 0x13b2, 0x421d,0xa5, 0xd7, 0x7e, 0x44, 0x51, 0x28, 0x7d, 0x64);") +cpp_quote("DEFINE_GUID(DXGI_DEBUG_DXGI, 0x25cddaa4, 0xb1c6, 0x47e1,0xac, 0x3e, 0x98, 0x87, 0x5b, 0x5a, 0x2e, 0x2a);") +cpp_quote("DEFINE_GUID(DXGI_DEBUG_APP, 0x06cd6e01, 0x4219, 0x4ebd,0x87, 0x09, 0x27, 0xed, 0x23, 0x36, 0x0c, 0x62);") + +typedef enum DXGI_DEBUG_RLO_FLAGS { + DXGI_DEBUG_RLO_SUMMARY = 0x0001, + DXGI_DEBUG_RLO_DETAIL = 0x0002, + DXGI_DEBUG_RLO_IGNORE_INTERNAL = 0x0004, + DXGI_DEBUG_RLO_ALL = 0x0007 +} DXGI_DEBUG_RLO_FLAGS; + +typedef enum DXGI_INFO_QUEUE_MESSAGE_CATEGORY { + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_UNKNOWN, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_MISCELLANEOUS, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_INITIALIZATION, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_CLEANUP, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_COMPILATION, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_CREATION, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_SETTING, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_GETTING, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_RESOURCE_MANIPULATION, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_EXECUTION, + DXGI_INFO_QUEUE_MESSAGE_CATEGORY_SHADER, +} DXGI_INFO_QUEUE_MESSAGE_CATEGORY; + +typedef enum DXGI_INFO_QUEUE_MESSAGE_SEVERITY { + DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, + DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, + DXGI_INFO_QUEUE_MESSAGE_SEVERITY_WARNING, + DXGI_INFO_QUEUE_MESSAGE_SEVERITY_INFO, + DXGI_INFO_QUEUE_MESSAGE_SEVERITY_MESSAGE +} DXGI_INFO_QUEUE_MESSAGE_SEVERITY; + +typedef int DXGI_INFO_QUEUE_MESSAGE_ID; +cpp_quote("#define DXGI_INFO_QUEUE_MESSAGE_ID_STRING_FROM_APPLICATION 0") + +typedef struct DXGI_INFO_QUEUE_MESSAGE { + DXGI_DEBUG_ID Producer; + DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category; + DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity; + DXGI_INFO_QUEUE_MESSAGE_ID ID; + const char *pDescription; + SIZE_T DescriptionByteLength; +} DXGI_INFO_QUEUE_MESSAGE; + +typedef struct DXGI_INFO_QUEUE_FILTER_DESC { + UINT NumCategories; + DXGI_INFO_QUEUE_MESSAGE_CATEGORY *pCategoryList; + UINT NumSeverities; + DXGI_INFO_QUEUE_MESSAGE_SEVERITY *pSeverityList; + UINT NumIDs; + DXGI_INFO_QUEUE_MESSAGE_ID *pIDList; +} DXGI_INFO_QUEUE_FILTER_DESC; + +typedef struct DXGI_INFO_QUEUE_FILTER { + DXGI_INFO_QUEUE_FILTER_DESC AllowList; + DXGI_INFO_QUEUE_FILTER_DESC DenyList; +} DXGI_INFO_QUEUE_FILTER; + +cpp_quote("#define DXGI_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024") + +cpp_quote("HRESULT WINAPI DXGIGetDebugInterface(REFIID riid, void **ppDebug);") + +[ + uuid(d67441c7-672a-476f-9e82-cd55b44949ce), + object, + local, + pointer_default(unique) +] +interface IDXGIInfoQueue : IUnknown +{ + HRESULT SetMessageCountLimit( + [in] DXGI_DEBUG_ID producer, + [in] UINT64 limit); + + void ClearStoredMessages( + [in] DXGI_DEBUG_ID producer); + + HRESULT GetMessage( + [in] DXGI_DEBUG_ID producer, + [in] UINT64 index, + [out] DXGI_INFO_QUEUE_MESSAGE *message, + [in, out] SIZE_T *length); + + UINT64 GetNumStoredMessagesAllowedByRetrievalFilters( + [in] DXGI_DEBUG_ID producer); + + UINT64 GetNumStoredMessages( + [in] DXGI_DEBUG_ID producer); + + UINT64 GetNumMessagesDiscardedByMessageCountLimit( + [in] DXGI_DEBUG_ID producer); + + UINT64 GetMessageCountLimit( + [in] DXGI_DEBUG_ID producer); + + UINT64 GetNumMessagesAllowedByStorageFilter( + [in] DXGI_DEBUG_ID producer); + + UINT64 GetNumMessagesDeniedByStorageFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT AddStorageFilterEntries( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_FILTER *filter); + + HRESULT GetStorageFilter( + [in] DXGI_DEBUG_ID producer, + [out] DXGI_INFO_QUEUE_FILTER *filter, + [in, out] SIZE_T *length); + + void ClearStorageFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushEmptyStorageFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushDenyAllStorageFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushCopyOfStorageFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushStorageFilter( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_FILTER *filter); + + void PopStorageFilter( + [in] DXGI_DEBUG_ID producer); + + UINT GetStorageFilterStackSize( + [in] DXGI_DEBUG_ID producer); + + HRESULT AddRetrievalFilterEntries( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_FILTER *filter); + + HRESULT GetRetrievalFilter( + [in] DXGI_DEBUG_ID producer, + [out] DXGI_INFO_QUEUE_FILTER *filter, + [in, out] SIZE_T *length); + + void ClearRetrievalFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushEmptyRetrievalFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushDenyAllRetrievalFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushCopyOfRetrievalFilter( + [in] DXGI_DEBUG_ID producer); + + HRESULT PushRetrievalFilter( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_FILTER *filter); + + void PopRetrievalFilter( + [in] DXGI_DEBUG_ID producer); + + UINT GetRetrievalFilterStackSize( + [in] DXGI_DEBUG_ID producer); + + HRESULT AddMessage( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_CATEGORY category, + [in] DXGI_INFO_QUEUE_MESSAGE_SEVERITY severity, + [in] DXGI_INFO_QUEUE_MESSAGE_ID id, + [in] LPCSTR description); + + HRESULT AddApplicationMessage( + [in] DXGI_INFO_QUEUE_MESSAGE_SEVERITY severity, + [in] LPCSTR description); + + HRESULT SetBreakOnCategory( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_CATEGORY category, + [in] BOOL enable); + + HRESULT SetBreakOnSeverity( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_SEVERITY severity, + [in] BOOL enable); + + HRESULT SetBreakOnID( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_ID id, + [in] BOOL enable); + + BOOL GetBreakOnCategory( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_CATEGORY category); + + BOOL GetBreakOnSeverity( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_SEVERITY severity); + + BOOL GetBreakOnID( + [in] DXGI_DEBUG_ID producer, + [in] DXGI_INFO_QUEUE_MESSAGE_ID id); + + void SetMuteDebugOutput( + [in] DXGI_DEBUG_ID producer, + [in] BOOL mute); + + BOOL GetMuteDebugOutput( + [in] DXGI_DEBUG_ID producer); +} + +[ + object, + local, + uuid(119e7452-de9e-40fe-8806-88f90c12b441) +] +interface IDXGIDebug : IUnknown +{ + HRESULT ReportLiveObjects( + [in] GUID apiid, + [in] DXGI_DEBUG_RLO_FLAGS flags); +} + +[ + uuid(c5a05f0c-16f2-4adf-9f4d-a8c4d58ac550), + object, + local, + pointer_default(unique) +] +interface IDXGIDebug1 : IDXGIDebug +{ + void EnableLeakTrackingForThread(); + void DisableLeakTrackingForThread(); + BOOL IsLeakTrackingEnabledForThread(); +} diff --git a/WineFix/lib/d2d1/include/windows/dxgiformat.idl b/WineFix/lib/d2d1/include/windows/dxgiformat.idl new file mode 100644 index 0000000..5f85064 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgiformat.idl @@ -0,0 +1,145 @@ +/* + * Copyright 2016 Józef Kucia for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +const unsigned int DXGI_FORMAT_DEFINED = 1; + +typedef enum DXGI_FORMAT +{ + DXGI_FORMAT_UNKNOWN = 0x00, + DXGI_FORMAT_R32G32B32A32_TYPELESS = 0x01, + DXGI_FORMAT_R32G32B32A32_FLOAT = 0x02, + DXGI_FORMAT_R32G32B32A32_UINT = 0x03, + DXGI_FORMAT_R32G32B32A32_SINT = 0x04, + DXGI_FORMAT_R32G32B32_TYPELESS = 0x05, + DXGI_FORMAT_R32G32B32_FLOAT = 0x06, + DXGI_FORMAT_R32G32B32_UINT = 0x07, + DXGI_FORMAT_R32G32B32_SINT = 0x08, + DXGI_FORMAT_R16G16B16A16_TYPELESS = 0x09, + DXGI_FORMAT_R16G16B16A16_FLOAT = 0x0a, + DXGI_FORMAT_R16G16B16A16_UNORM = 0x0b, + DXGI_FORMAT_R16G16B16A16_UINT = 0x0c, + DXGI_FORMAT_R16G16B16A16_SNORM = 0x0d, + DXGI_FORMAT_R16G16B16A16_SINT = 0x0e, + DXGI_FORMAT_R32G32_TYPELESS = 0x0f, + DXGI_FORMAT_R32G32_FLOAT = 0x10, + DXGI_FORMAT_R32G32_UINT = 0x11, + DXGI_FORMAT_R32G32_SINT = 0x12, + DXGI_FORMAT_R32G8X24_TYPELESS = 0x13, + DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 0x14, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 0x15, + DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 0x16, + DXGI_FORMAT_R10G10B10A2_TYPELESS = 0x17, + DXGI_FORMAT_R10G10B10A2_UNORM = 0x18, + DXGI_FORMAT_R10G10B10A2_UINT = 0x19, + DXGI_FORMAT_R11G11B10_FLOAT = 0x1a, + DXGI_FORMAT_R8G8B8A8_TYPELESS = 0x1b, + DXGI_FORMAT_R8G8B8A8_UNORM = 0x1c, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 0x1d, + DXGI_FORMAT_R8G8B8A8_UINT = 0x1e, + DXGI_FORMAT_R8G8B8A8_SNORM = 0x1f, + DXGI_FORMAT_R8G8B8A8_SINT = 0x20, + DXGI_FORMAT_R16G16_TYPELESS = 0x21, + DXGI_FORMAT_R16G16_FLOAT = 0x22, + DXGI_FORMAT_R16G16_UNORM = 0x23, + DXGI_FORMAT_R16G16_UINT = 0x24, + DXGI_FORMAT_R16G16_SNORM = 0x25, + DXGI_FORMAT_R16G16_SINT = 0x26, + DXGI_FORMAT_R32_TYPELESS = 0x27, + DXGI_FORMAT_D32_FLOAT = 0x28, + DXGI_FORMAT_R32_FLOAT = 0x29, + DXGI_FORMAT_R32_UINT = 0x2a, + DXGI_FORMAT_R32_SINT = 0x2b, + DXGI_FORMAT_R24G8_TYPELESS = 0x2c, + DXGI_FORMAT_D24_UNORM_S8_UINT = 0x2d, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 0x2e, + DXGI_FORMAT_X24_TYPELESS_G8_UINT = 0x2f, + DXGI_FORMAT_R8G8_TYPELESS = 0x30, + DXGI_FORMAT_R8G8_UNORM = 0x31, + DXGI_FORMAT_R8G8_UINT = 0x32, + DXGI_FORMAT_R8G8_SNORM = 0x33, + DXGI_FORMAT_R8G8_SINT = 0x34, + DXGI_FORMAT_R16_TYPELESS = 0x35, + DXGI_FORMAT_R16_FLOAT = 0x36, + DXGI_FORMAT_D16_UNORM = 0x37, + DXGI_FORMAT_R16_UNORM = 0x38, + DXGI_FORMAT_R16_UINT = 0x39, + DXGI_FORMAT_R16_SNORM = 0x3a, + DXGI_FORMAT_R16_SINT = 0x3b, + DXGI_FORMAT_R8_TYPELESS = 0x3c, + DXGI_FORMAT_R8_UNORM = 0x3d, + DXGI_FORMAT_R8_UINT = 0x3e, + DXGI_FORMAT_R8_SNORM = 0x3f, + DXGI_FORMAT_R8_SINT = 0x40, + DXGI_FORMAT_A8_UNORM = 0x41, + DXGI_FORMAT_R1_UNORM = 0x42, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 0x43, + DXGI_FORMAT_R8G8_B8G8_UNORM = 0x44, + DXGI_FORMAT_G8R8_G8B8_UNORM = 0x45, + DXGI_FORMAT_BC1_TYPELESS = 0x46, + DXGI_FORMAT_BC1_UNORM = 0x47, + DXGI_FORMAT_BC1_UNORM_SRGB = 0x48, + DXGI_FORMAT_BC2_TYPELESS = 0x49, + DXGI_FORMAT_BC2_UNORM = 0x4a, + DXGI_FORMAT_BC2_UNORM_SRGB = 0x4b, + DXGI_FORMAT_BC3_TYPELESS = 0x4c, + DXGI_FORMAT_BC3_UNORM = 0x4d, + DXGI_FORMAT_BC3_UNORM_SRGB = 0x4e, + DXGI_FORMAT_BC4_TYPELESS = 0x4f, + DXGI_FORMAT_BC4_UNORM = 0x50, + DXGI_FORMAT_BC4_SNORM = 0x51, + DXGI_FORMAT_BC5_TYPELESS = 0x52, + DXGI_FORMAT_BC5_UNORM = 0x53, + DXGI_FORMAT_BC5_SNORM = 0x54, + DXGI_FORMAT_B5G6R5_UNORM = 0x55, + DXGI_FORMAT_B5G5R5A1_UNORM = 0x56, + DXGI_FORMAT_B8G8R8A8_UNORM = 0x57, + DXGI_FORMAT_B8G8R8X8_UNORM = 0x58, + DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 0x59, + DXGI_FORMAT_B8G8R8A8_TYPELESS = 0x5a, + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 0x5b, + DXGI_FORMAT_B8G8R8X8_TYPELESS = 0x5c, + DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 0x5d, + DXGI_FORMAT_BC6H_TYPELESS = 0x5e, + DXGI_FORMAT_BC6H_UF16 = 0x5f, + DXGI_FORMAT_BC6H_SF16 = 0x60, + DXGI_FORMAT_BC7_TYPELESS = 0x61, + DXGI_FORMAT_BC7_UNORM = 0x62, + DXGI_FORMAT_BC7_UNORM_SRGB = 0x63, + DXGI_FORMAT_AYUV = 0x64, + DXGI_FORMAT_Y410 = 0x65, + DXGI_FORMAT_Y416 = 0x66, + DXGI_FORMAT_NV12 = 0x67, + DXGI_FORMAT_P010 = 0x68, + DXGI_FORMAT_P016 = 0x69, + DXGI_FORMAT_420_OPAQUE = 0x6a, + DXGI_FORMAT_YUY2 = 0x6b, + DXGI_FORMAT_Y210 = 0x6c, + DXGI_FORMAT_Y216 = 0x6d, + DXGI_FORMAT_NV11 = 0x6e, + DXGI_FORMAT_AI44 = 0x6f, + DXGI_FORMAT_IA44 = 0x70, + DXGI_FORMAT_P8 = 0x71, + DXGI_FORMAT_A8P8 = 0x72, + DXGI_FORMAT_B4G4R4A4_UNORM = 0x73, + + DXGI_FORMAT_P208 = 0x82, + DXGI_FORMAT_V208 = 0x83, + DXGI_FORMAT_V408 = 0x84, + + DXGI_FORMAT_FORCE_UINT = 0xffffffff, +} DXGI_FORMAT; diff --git a/WineFix/lib/d2d1/include/windows/dxgitype.idl b/WineFix/lib/d2d1/include/windows/dxgitype.idl new file mode 100644 index 0000000..a9ed571 --- /dev/null +++ b/WineFix/lib/d2d1/include/windows/dxgitype.idl @@ -0,0 +1,94 @@ +/* + * Copyright 2007 Andras Kovacs + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "dxgicommon.idl"; +import "dxgiformat.idl"; + +cpp_quote("#if 0") +typedef unsigned int UINT; +typedef long BOOL; +cpp_quote("#endif") + +typedef enum DXGI_MODE_ROTATION +{ + DXGI_MODE_ROTATION_UNSPECIFIED = 0x0, + DXGI_MODE_ROTATION_IDENTITY = 0x1, + DXGI_MODE_ROTATION_ROTATE90 = 0x2, + DXGI_MODE_ROTATION_ROTATE180 = 0x3, + DXGI_MODE_ROTATION_ROTATE270 = 0x4, +} DXGI_MODE_ROTATION; + +typedef enum DXGI_MODE_SCANLINE_ORDER +{ + DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED = 0x0, + DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE = 0x1, + DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST = 0x2, + DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST = 0x3, +} DXGI_MODE_SCANLINE_ORDER; + +typedef enum DXGI_MODE_SCALING +{ + DXGI_MODE_SCALING_UNSPECIFIED = 0x0, + DXGI_MODE_SCALING_CENTERED = 0x1, + DXGI_MODE_SCALING_STRETCHED = 0x2, +} DXGI_MODE_SCALING; + +cpp_quote("#ifndef D3DCOLORVALUE_DEFINED") +cpp_quote("#define D3DCOLORVALUE_DEFINED") +typedef struct _D3DCOLORVALUE +{ + float r; + float g; + float b; + float a; +} D3DCOLORVALUE; +cpp_quote("#endif") +typedef D3DCOLORVALUE DXGI_RGBA; + +typedef struct DXGI_MODE_DESC +{ + UINT Width; + UINT Height; + DXGI_RATIONAL RefreshRate; + DXGI_FORMAT Format; + DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; + DXGI_MODE_SCALING Scaling; +} DXGI_MODE_DESC; + +typedef struct DXGI_GAMMA_CONTROL_CAPABILITIES +{ + BOOL ScaleAndOffsetSupported; + float MaxConvertedValue; + float MinConvertedValue; + UINT NumGammaControlPoints; + float ControlPointPositions[1025]; +} DXGI_GAMMA_CONTROL_CAPABILITIES; + +typedef struct DXGI_RGB +{ + float Red; + float Green; + float Blue; +} DXGI_RGB; + +typedef struct DXGI_GAMMA_CONTROL +{ + DXGI_RGB Scale; + DXGI_RGB Offset; + DXGI_RGB GammaCurve[1025]; +} DXGI_GAMMA_CONTROL; diff --git a/WineFix/lib/d2d1/include/wine/debug.h b/WineFix/lib/d2d1/include/wine/debug.h new file mode 100644 index 0000000..f818ad5 --- /dev/null +++ b/WineFix/lib/d2d1/include/wine/debug.h @@ -0,0 +1,220 @@ +/* + * Wine debugging interface - Simplified for standalone builds + * + * This is a simplified version of Wine's debug.h that works with MinGW headers + * For full Wine debug functionality, use the complete Wine build system + */ + +#ifndef __WINE_WINE_DEBUG_H +#define __WINE_WINE_DEBUG_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Debug channel structure */ +struct __wine_debug_channel +{ + unsigned char flags; + char name[15]; +}; + +/* Debug classes */ +enum __wine_debug_class +{ + __WINE_DBCL_FIXME, + __WINE_DBCL_ERR, + __WINE_DBCL_WARN, + __WINE_DBCL_TRACE, + __WINE_DBCL_INIT = 7 +}; + +/* Simplified debug macros for standalone build */ +#define WINE_DECLARE_DEBUG_CHANNEL(chan) \ + static struct __wine_debug_channel __wine_dbch_##chan = { 0, #chan } + +#define WINE_DEFAULT_DEBUG_CHANNEL(chan) \ + static struct __wine_debug_channel __wine_dbch_##chan = { 0, #chan }; \ + static struct __wine_debug_channel * const __wine_dbch___default = &__wine_dbch_##chan + +/* Stub implementations - print to stderr for now */ +static inline int __wine_dbg_vprintf(const char *format, va_list args) +{ + return vfprintf(stderr, format, args); +} + +static inline int __wine_dbg_printf(const char *format, ...) +{ + va_list args; + int ret; + va_start(args, format); + ret = __wine_dbg_vprintf(format, args); + va_end(args); + return ret; +} + +static inline const char* wine_dbg_sprintf(const char *format, ...) +{ + static char buffer[512]; + va_list args; + va_start(args, format); + vsnprintf(buffer, sizeof(buffer), format, args); + va_end(args); + return buffer; +} + +static inline const char* wine_dbgstr_a(const char *str) +{ + if (!str) return "(null)"; + return wine_dbg_sprintf("\"%s\"", str); +} + +static inline const char* wine_dbgstr_w(const WCHAR *str) +{ + if (!str) return "(null)"; + static char buffer[512]; + WideCharToMultiByte(CP_UTF8, 0, str, -1, buffer, sizeof(buffer), NULL, NULL); + return wine_dbg_sprintf("\"%s\"", buffer); +} + +static inline const char* wine_dbgstr_guid(const GUID *guid) +{ + if (!guid) return "(null)"; + return wine_dbg_sprintf("{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", + guid->Data1, guid->Data2, guid->Data3, + guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], + guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]); +} + +static inline const char* wine_dbgstr_longlong(LONGLONG ll) +{ + return wine_dbg_sprintf("%lld", (long long)ll); +} + +static inline const char* debugstr_wn(const WCHAR *str, int n) +{ + if (!str) return "(null)"; + static char buffer[512]; + int len = n < 0 ? -1 : n; + if (len > 255) len = 255; + WideCharToMultiByte(CP_UTF8, 0, str, len, buffer, sizeof(buffer), NULL, NULL); + return wine_dbg_sprintf("\"%s\"", buffer); +} + +static inline const char* wine_dbgstr_rect(const RECT *rect) +{ + if (!rect) return "(null)"; + return wine_dbg_sprintf("(%ld,%ld)-(%ld,%ld)", + rect->left, rect->top, rect->right, rect->bottom); +} + +static inline const char* debugstr_a(const char *str) { return wine_dbgstr_a(str); } +static inline const char* debugstr_w(const WCHAR *str) { return wine_dbgstr_w(str); } +static inline const char* debugstr_guid(const GUID *guid) { return wine_dbgstr_guid(guid); } + +/* Debug output control - simplified stubs */ +static inline unsigned char __wine_dbg_get_channel_flags(struct __wine_debug_channel *channel) +{ + return 0; /* Debugging disabled by default in standalone builds */ +} + +static inline int wine_dbg_log(enum __wine_debug_class cls, + struct __wine_debug_channel *channel, + const char *func, const char *format, ...) +{ + /* Simplified: only print errors and fixmes */ + if (cls == __WINE_DBCL_ERR || cls == __WINE_DBCL_FIXME) + { + const char *class_name = (cls == __WINE_DBCL_ERR) ? "err" : "fixme"; + fprintf(stderr, "%s:%s:%s ", class_name, channel->name, func); + + va_list args; + va_start(args, format); + vfprintf(stderr, format, args); + va_end(args); + } + return 0; +} + +/* Debug macros */ +#ifndef WINE_NO_TRACE_MSGS +#define __WINE_GET_DEBUGGING_TRACE(dbch) 0 +#else +#define __WINE_GET_DEBUGGING_TRACE(dbch) 0 +#endif + +#ifndef WINE_NO_DEBUG_MSGS +#define __WINE_GET_DEBUGGING_WARN(dbch) 0 +#define __WINE_GET_DEBUGGING_FIXME(dbch) 1 +#else +#define __WINE_GET_DEBUGGING_WARN(dbch) 0 +#define __WINE_GET_DEBUGGING_FIXME(dbch) 0 +#endif + +#define __WINE_GET_DEBUGGING_ERR(dbch) 1 + +#define __WINE_GET_DEBUGGING(dbcl,dbch) __WINE_GET_DEBUGGING##dbcl(dbch) + +#define __WINE_IS_DEBUG_ON(dbcl,dbch) \ + (__WINE_GET_DEBUGGING##dbcl(dbch)) + +#define __WINE_DPRINTF(dbcl,dbch) \ + do { if(__WINE_GET_DEBUGGING(dbcl,(dbch))) { \ + struct __wine_debug_channel * const __dbch = (dbch); \ + const enum __wine_debug_class __dbcl = __WINE_DBCL##dbcl; \ + __WINE_DBG_LOG + +#define __WINE_DBG_LOG(...) \ + wine_dbg_log( __dbcl, __dbch, __func__, __VA_ARGS__); } } while(0) + +#define __WINE_PRINTF_ATTR(fmt,args) + +#ifdef WINE_NO_TRACE_MSGS +#define WINE_TRACE(...) do { } while(0) +#define WINE_TRACE_(ch) WINE_TRACE +#endif + +#ifdef WINE_NO_DEBUG_MSGS +#define WINE_WARN(...) do { } while(0) +#define WINE_WARN_(ch) WINE_WARN +#define WINE_FIXME(...) do { } while(0) +#define WINE_FIXME_(ch) WINE_FIXME +#endif + +#ifndef WINE_TRACE +#define WINE_TRACE __WINE_DPRINTF(_TRACE,__wine_dbch___default) +#define WINE_TRACE_(ch) __WINE_DPRINTF(_TRACE,&__wine_dbch_##ch) +#endif + +#ifndef WINE_WARN +#define WINE_WARN __WINE_DPRINTF(_WARN,__wine_dbch___default) +#define WINE_WARN_(ch) __WINE_DPRINTF(_WARN,&__wine_dbch_##ch) +#endif + +#ifndef WINE_FIXME +#define WINE_FIXME __WINE_DPRINTF(_FIXME,__wine_dbch___default) +#define WINE_FIXME_(ch) __WINE_DPRINTF(_FIXME,&__wine_dbch_##ch) +#endif + +#define WINE_ERR __WINE_DPRINTF(_ERR,__wine_dbch___default) +#define WINE_ERR_(ch) __WINE_DPRINTF(_ERR,&__wine_dbch_##ch) + +/* Shorthand macros */ +#define TRACE WINE_TRACE +#define TRACE_(ch) WINE_TRACE_(ch) +#define WARN WINE_WARN +#define WARN_(ch) WINE_WARN_(ch) +#define FIXME WINE_FIXME +#define FIXME_(ch) WINE_FIXME_(ch) +#define ERR WINE_ERR +#define ERR_(ch) WINE_ERR_(ch) + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_WINE_DEBUG_H */ diff --git a/WineFix/lib/d2d1/include/wine/debug.h.orig b/WineFix/lib/d2d1/include/wine/debug.h.orig new file mode 100644 index 0000000..8328524 --- /dev/null +++ b/WineFix/lib/d2d1/include/wine/debug.h.orig @@ -0,0 +1,559 @@ +/* + * Wine debugging interface + * + * Copyright 1999 Patrik Stridvall + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#if 0 +#pragma makedep install +#endif + +#ifndef __WINE_WINE_DEBUG_H +#define __WINE_WINE_DEBUG_H + +#include +#include +#include +#include +#ifndef GUID_DEFINED +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct _GUID; + +/* + * Internal definitions (do not use these directly) + */ + +enum __wine_debug_class +{ + __WINE_DBCL_FIXME, + __WINE_DBCL_ERR, + __WINE_DBCL_WARN, + __WINE_DBCL_TRACE, + + __WINE_DBCL_INIT = 7 /* lazy init flag */ +}; + +struct __wine_debug_channel +{ + unsigned char flags; + char name[15]; +}; + +#ifndef WINE_NO_TRACE_MSGS +# define __WINE_GET_DEBUGGING_TRACE(dbch) ((dbch)->flags & (1 << __WINE_DBCL_TRACE)) +#else +# define __WINE_GET_DEBUGGING_TRACE(dbch) 0 +#endif + +#ifndef WINE_NO_DEBUG_MSGS +# define __WINE_GET_DEBUGGING_WARN(dbch) ((dbch)->flags & (1 << __WINE_DBCL_WARN)) +# define __WINE_GET_DEBUGGING_FIXME(dbch) ((dbch)->flags & (1 << __WINE_DBCL_FIXME)) +#else +# define __WINE_GET_DEBUGGING_WARN(dbch) 0 +# define __WINE_GET_DEBUGGING_FIXME(dbch) 0 +#endif + +/* define error macro regardless of what is configured */ +#define __WINE_GET_DEBUGGING_ERR(dbch) ((dbch)->flags & (1 << __WINE_DBCL_ERR)) + +#define __WINE_GET_DEBUGGING(dbcl,dbch) __WINE_GET_DEBUGGING##dbcl(dbch) + +#define __WINE_IS_DEBUG_ON(dbcl,dbch) \ + (__WINE_GET_DEBUGGING##dbcl(dbch) && (__wine_dbg_get_channel_flags(dbch) & (1 << __WINE_DBCL##dbcl))) + +#define __WINE_DPRINTF(dbcl,dbch) \ + do { if(__WINE_GET_DEBUGGING(dbcl,(dbch))) { \ + struct __wine_debug_channel * const __dbch = (dbch); \ + const enum __wine_debug_class __dbcl = __WINE_DBCL##dbcl; \ + __WINE_DBG_LOG + +#define __WINE_DBG_LOG(...) \ + wine_dbg_log( __dbcl, __dbch, __func__, __VA_ARGS__); } } while(0) + +#if (defined(__GNUC__) || defined(__clang__)) && (defined(__MINGW32__) || defined (_MSC_VER) || !defined(__WINE_USE_MSVCRT)) +#define __WINE_PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args))) +#else +#define __WINE_PRINTF_ATTR(fmt,args) +#endif + +#ifdef WINE_NO_TRACE_MSGS +#define WINE_TRACE(...) do { } while(0) +#define WINE_TRACE_(ch) WINE_TRACE +#endif + +#ifdef WINE_NO_DEBUG_MSGS +#define WINE_WARN(...) do { } while(0) +#define WINE_WARN_(ch) WINE_WARN +#define WINE_FIXME(...) do { } while(0) +#define WINE_FIXME_(ch) WINE_FIXME +#endif + +NTSYSAPI int WINAPI __wine_dbg_write( const char *str, unsigned int len ); +extern DECLSPEC_EXPORT unsigned char __cdecl __wine_dbg_get_channel_flags( struct __wine_debug_channel *channel ); +extern DECLSPEC_EXPORT const char * __cdecl __wine_dbg_strdup( const char *str ); +extern DECLSPEC_EXPORT int __cdecl __wine_dbg_output( const char *str ); +extern DECLSPEC_EXPORT int __cdecl __wine_dbg_header( enum __wine_debug_class cls, struct __wine_debug_channel *channel, + const char *function ); + +/* + * Exported definitions and macros + */ + +/* These functions return a printable version of a string, including + quotes. The string will be valid for some time, but not indefinitely + as strings are re-used. */ + +#if defined(__x86_64__) && defined(__GNUC__) && defined(__WINE_USE_MSVCRT) +# define __wine_dbg_cdecl __cdecl +#else +# define __wine_dbg_cdecl +#endif + +static const char * __wine_dbg_cdecl wine_dbg_vsprintf( const char *format, va_list args ) __WINE_PRINTF_ATTR(1,0); +static inline const char * __wine_dbg_cdecl wine_dbg_vsprintf( const char *format, va_list args ) +{ + char buffer[200]; + + vsnprintf( buffer, sizeof(buffer), format, args ); + buffer[sizeof(buffer) - 1] = 0; + return __wine_dbg_strdup( buffer ); +} + +static const char * __wine_dbg_cdecl wine_dbg_sprintf( const char *format, ... ) __WINE_PRINTF_ATTR(1,2); +static inline const char * __wine_dbg_cdecl wine_dbg_sprintf( const char *format, ... ) +{ + const char *ret; + va_list args; + + va_start( args, format ); + ret = wine_dbg_vsprintf( format, args ); + va_end( args ); + return ret; +} + +static int __wine_dbg_cdecl wine_dbg_vprintf( const char *format, va_list args ) __WINE_PRINTF_ATTR(1,0); +static inline int __wine_dbg_cdecl wine_dbg_vprintf( const char *format, va_list args ) +{ + char buffer[1024]; + + vsnprintf( buffer, sizeof(buffer), format, args ); + buffer[sizeof(buffer) - 1] = 0; + return __wine_dbg_output( buffer ); +} + +static int __wine_dbg_cdecl wine_dbg_printf( const char *format, ... ) __WINE_PRINTF_ATTR(1,2); +static inline int __wine_dbg_cdecl wine_dbg_printf( const char *format, ... ) +{ + int ret; + va_list args; + + va_start( args, format ); + ret = wine_dbg_vprintf( format, args ); + va_end( args ); + return ret; +} + +static int __wine_dbg_cdecl wine_dbg_vlog( enum __wine_debug_class cls, + struct __wine_debug_channel *channel, const char *func, + const char *format, va_list args ) __WINE_PRINTF_ATTR(4,0); +static inline int __wine_dbg_cdecl wine_dbg_vlog( enum __wine_debug_class cls, + struct __wine_debug_channel *channel, + const char *function, const char *format, va_list args ) +{ + int ret; + + if (*format == '\1') /* special magic to avoid standard prefix */ + { + format++; + function = NULL; + } + if ((ret = __wine_dbg_header( cls, channel, function )) != -1) ret += wine_dbg_vprintf( format, args ); + return ret; +} + +static int __wine_dbg_cdecl wine_dbg_log( enum __wine_debug_class cls, + struct __wine_debug_channel *channel, const char *func, + const char *format, ... ) __WINE_PRINTF_ATTR(4,5); +static inline int __wine_dbg_cdecl wine_dbg_log( enum __wine_debug_class cls, + struct __wine_debug_channel *channel, + const char *function, const char *format, ... ) +{ + va_list args; + int ret; + + va_start( args, format ); + ret = wine_dbg_vlog( cls, channel, function, format, args ); + va_end( args ); + return ret; +} + +static inline const char *wine_dbgstr_an( const char *str, int n ) +{ + static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; + char buffer[300], *dst = buffer; + + if (!str) return "(null)"; + if (!((ULONG_PTR)str >> 16)) return wine_dbg_sprintf( "#%04x", LOWORD(str) ); +#ifndef WINE_UNIX_LIB + if (IsBadStringPtrA( str, n )) return "(invalid)"; +#endif + if (n == -1) for (n = 0; str[n]; n++) ; + *dst++ = '"'; + while (n-- > 0 && dst <= buffer + sizeof(buffer) - 9) + { + unsigned char c = *str++; + switch (c) + { + case '\n': *dst++ = '\\'; *dst++ = 'n'; break; + case '\r': *dst++ = '\\'; *dst++ = 'r'; break; + case '\t': *dst++ = '\\'; *dst++ = 't'; break; + case '"': *dst++ = '\\'; *dst++ = '"'; break; + case '\\': *dst++ = '\\'; *dst++ = '\\'; break; + default: + if (c < ' ' || c >= 127) + { + *dst++ = '\\'; + *dst++ = 'x'; + *dst++ = hex[(c >> 4) & 0x0f]; + *dst++ = hex[c & 0x0f]; + } + else *dst++ = c; + } + } + *dst++ = '"'; + if (n > 0) + { + *dst++ = '.'; + *dst++ = '.'; + *dst++ = '.'; + } + *dst = 0; + return __wine_dbg_strdup( buffer ); +} + +static inline const char *wine_dbgstr_wn( const WCHAR *str, int n ) +{ + static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; + char buffer[300], *dst = buffer; + + if (!str) return "(null)"; + if (!((ULONG_PTR)str >> 16)) return wine_dbg_sprintf( "#%04x", LOWORD(str) ); +#ifndef WINE_UNIX_LIB + if (IsBadStringPtrW( str, n )) return "(invalid)"; +#endif + if (n == -1) for (n = 0; str[n]; n++) ; + *dst++ = 'L'; + *dst++ = '"'; + while (n-- > 0 && dst <= buffer + sizeof(buffer) - 10) + { + WCHAR c = *str++; + switch (c) + { + case '\n': *dst++ = '\\'; *dst++ = 'n'; break; + case '\r': *dst++ = '\\'; *dst++ = 'r'; break; + case '\t': *dst++ = '\\'; *dst++ = 't'; break; + case '"': *dst++ = '\\'; *dst++ = '"'; break; + case '\\': *dst++ = '\\'; *dst++ = '\\'; break; + default: + if (c < ' ' || c >= 127) + { + *dst++ = '\\'; + *dst++ = hex[(c >> 12) & 0x0f]; + *dst++ = hex[(c >> 8) & 0x0f]; + *dst++ = hex[(c >> 4) & 0x0f]; + *dst++ = hex[c & 0x0f]; + } + else *dst++ = (char)c; + } + } + *dst++ = '"'; + if (n > 0) + { + *dst++ = '.'; + *dst++ = '.'; + *dst++ = '.'; + } + *dst = 0; + return __wine_dbg_strdup( buffer ); +} + +static inline const char *wine_dbgstr_a( const char *s ) +{ + return wine_dbgstr_an( s, -1 ); +} + +static inline const char *wine_dbgstr_w( const WCHAR *s ) +{ + return wine_dbgstr_wn( s, -1 ); +} + +#if defined(__hstring_h__) && defined(__WINSTRING_H_) +static inline const char *wine_dbgstr_hstring( HSTRING hstr ) +{ + UINT32 len; + const WCHAR *str = WindowsGetStringRawBuffer( hstr, &len ); + return wine_dbgstr_wn( str, len ); +} +#endif + +static inline const char *wine_dbgstr_guid( const GUID *id ) +{ + if (!id) return "(null)"; + if (!((ULONG_PTR)id >> 16)) return wine_dbg_sprintf( "", (WORD)(ULONG_PTR)id ); + return wine_dbg_sprintf( "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", + (unsigned int)id->Data1, id->Data2, id->Data3, + id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3], + id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] ); +} + +static inline const char *wine_dbgstr_fourcc( unsigned int fourcc ) +{ + char str[4] = { (char)fourcc, (char)(fourcc >> 8), (char)(fourcc >> 16), (char)(fourcc >> 24) }; + if (!fourcc) + return "''"; + if (isprint( str[0] ) && isprint( str[1] ) && isprint( str[2] ) && isprint( str[3] )) + return wine_dbg_sprintf( "'%.4s'", str ); + return wine_dbg_sprintf( "0x%08x", fourcc ); +} + +static inline const char *wine_dbgstr_point( const POINT *pt ) +{ + if (!pt) return "(null)"; + return wine_dbg_sprintf( "(%d,%d)", (int)pt->x, (int)pt->y ); +} + +static inline const char *wine_dbgstr_rect( const RECT *rect ) +{ + if (!rect) return "(null)"; + return wine_dbg_sprintf( "(%d,%d)-(%d,%d)", (int)rect->left, (int)rect->top, + (int)rect->right, (int)rect->bottom ); +} + +static inline const char *wine_dbgstr_longlong( ULONGLONG ll ) +{ + if (sizeof(ll) > sizeof(unsigned long) && ll >> 32) + return wine_dbg_sprintf( "%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll ); + else return wine_dbg_sprintf( "%lx", (unsigned long)ll ); +} + +#if defined(__oaidl_h__) && defined(V_VT) + +static inline const char *wine_dbgstr_vt( VARTYPE vt ) +{ + static const char *const variant_types[] = + { + "VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE", + "VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN", + "VT_DECIMAL","15","VT_I1","VT_UI1","VT_UI2","VT_UI4","VT_I8","VT_UI8", + "VT_INT","VT_UINT","VT_VOID","VT_HRESULT","VT_PTR","VT_SAFEARRAY", + "VT_CARRAY","VT_USERDEFINED","VT_LPSTR","VT_LPWSTR","32","33","34","35", + "VT_RECORD","VT_INT_PTR","VT_UINT_PTR","39","40","41","42","43","44","45", + "46","47","48","49","50","51","52","53","54","55","56","57","58","59","60", + "61","62","63","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE", + "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID", + "VT_VERSIONED_STREAM" + }; + + static const char *const variant_flags[16] = + { + "", + "|VT_VECTOR", + "|VT_ARRAY", + "|VT_VECTOR|VT_ARRAY", + "|VT_BYREF", + "|VT_VECTOR|VT_BYREF", + "|VT_ARRAY|VT_BYREF", + "|VT_VECTOR|VT_ARRAY|VT_BYREF", + "|VT_RESERVED", + "|VT_VECTOR|VT_RESERVED", + "|VT_ARRAY|VT_RESERVED", + "|VT_VECTOR|VT_ARRAY|VT_RESERVED", + "|VT_BYREF|VT_RESERVED", + "|VT_VECTOR|VT_BYREF|VT_RESERVED", + "|VT_ARRAY|VT_BYREF|VT_RESERVED", + "|VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED", + }; + + if (vt & ~VT_TYPEMASK) + return wine_dbg_sprintf( "%s%s", wine_dbgstr_vt(vt&VT_TYPEMASK), variant_flags[vt>>12] ); + + if (vt < sizeof(variant_types)/sizeof(*variant_types)) + return variant_types[vt]; + + if (vt == VT_BSTR_BLOB) + return "VT_BSTR_BLOB"; + + return wine_dbg_sprintf( "vt(invalid %x)", vt ); +} + +static inline const char *wine_dbgstr_variant( const VARIANT *v ) +{ + if (!v) + return "(null)"; + + if (V_VT(v) & VT_BYREF) { + if (V_VT(v) == (VT_VARIANT|VT_BYREF)) + return wine_dbg_sprintf( "%p {VT_VARIANT|VT_BYREF: %s}", v, wine_dbgstr_variant(V_VARIANTREF(v)) ); + if (V_VT(v) == (VT_BSTR|VT_BYREF)) + return wine_dbg_sprintf( "%p {VT_BSTR|VT_BYREF: %s}", v, V_BSTRREF(v) ? wine_dbgstr_w(*V_BSTRREF(v)) : "(none)" ); + return wine_dbg_sprintf( "%p {%s %p}", v, wine_dbgstr_vt(V_VT(v)), V_BYREF(v) ); + } + + if (V_ISARRAY(v) || V_ISVECTOR(v)) + return wine_dbg_sprintf( "%p {%s %p}", v, wine_dbgstr_vt(V_VT(v)), V_ARRAY(v) ); + + switch(V_VT(v)) { + case VT_EMPTY: + return wine_dbg_sprintf( "%p {VT_EMPTY}", v ); + case VT_NULL: + return wine_dbg_sprintf( "%p {VT_NULL}", v ); + case VT_I2: + return wine_dbg_sprintf( "%p {VT_I2: %d}", v, V_I2(v) ); + case VT_I4: + return wine_dbg_sprintf( "%p {VT_I4: %d}", v, (int)V_I4(v) ); + case VT_R4: + return wine_dbg_sprintf( "%p {VT_R4: %f}", v, V_R4(v) ); + case VT_R8: + return wine_dbg_sprintf( "%p {VT_R8: %lf}", v, V_R8(v) ); + case VT_CY: + return wine_dbg_sprintf( "%p {VT_CY: %s}", v, wine_dbgstr_longlong(V_CY(v).int64) ); + case VT_DATE: + return wine_dbg_sprintf( "%p {VT_DATE: %lf}", v, V_DATE(v) ); + case VT_LPSTR: + return wine_dbg_sprintf( "%p {VT_LPSTR: %s}", v, wine_dbgstr_a((const char *)V_BSTR(v)) ); + case VT_LPWSTR: + return wine_dbg_sprintf( "%p {VT_LPWSTR: %s}", v, wine_dbgstr_w(V_BSTR(v)) ); + case VT_BSTR: + return wine_dbg_sprintf( "%p {VT_BSTR: %s}", v, wine_dbgstr_w(V_BSTR(v)) ); + case VT_DISPATCH: + return wine_dbg_sprintf( "%p {VT_DISPATCH: %p}", v, V_DISPATCH(v) ); + case VT_ERROR: + return wine_dbg_sprintf( "%p {VT_ERROR: %08x}", v, (int)V_ERROR(v) ); + case VT_BOOL: + return wine_dbg_sprintf( "%p {VT_BOOL: %x}", v, V_BOOL(v) ); + case VT_UNKNOWN: + return wine_dbg_sprintf( "%p {VT_UNKNOWN: %p}", v, V_UNKNOWN(v) ); + case VT_I1: + return wine_dbg_sprintf( "%p {VT_I1: %d}", v, V_I1(v) ); + case VT_UI1: + return wine_dbg_sprintf( "%p {VT_UI1: %u}", v, V_UI1(v) ); + case VT_UI2: + return wine_dbg_sprintf( "%p {VT_UI2: %u}", v, V_UI2(v) ); + case VT_UI4: + return wine_dbg_sprintf( "%p {VT_UI4: %u}", v, (unsigned int)V_UI4(v) ); + case VT_I8: + return wine_dbg_sprintf( "%p {VT_I8: %s}", v, wine_dbgstr_longlong(V_I8(v)) ); + case VT_UI8: + return wine_dbg_sprintf( "%p {VT_UI8: %s}", v, wine_dbgstr_longlong(V_UI8(v)) ); + case VT_INT: + return wine_dbg_sprintf( "%p {VT_INT: %d}", v, V_INT(v) ); + case VT_UINT: + return wine_dbg_sprintf( "%p {VT_UINT: %u}", v, V_UINT(v) ); + case VT_VOID: + return wine_dbg_sprintf( "%p {VT_VOID}", v ); + case VT_RECORD: + return wine_dbg_sprintf( "%p {VT_RECORD: %p %p}", v, V_RECORD(v), V_RECORDINFO(v) ); + default: + return wine_dbg_sprintf( "%p {vt %s}", v, wine_dbgstr_vt(V_VT(v)) ); + } +} + +#endif /* defined(__oaidl_h__) && defined(V_VT) */ + +#ifndef WINE_TRACE +#define WINE_TRACE __WINE_DPRINTF(_TRACE,__wine_dbch___default) +#define WINE_TRACE_(ch) __WINE_DPRINTF(_TRACE,&__wine_dbch_##ch) +#endif +#define WINE_TRACE_ON(ch) __WINE_IS_DEBUG_ON(_TRACE,&__wine_dbch_##ch) + +#ifndef WINE_WARN +#define WINE_WARN __WINE_DPRINTF(_WARN,__wine_dbch___default) +#define WINE_WARN_(ch) __WINE_DPRINTF(_WARN,&__wine_dbch_##ch) +#endif +#define WINE_WARN_ON(ch) __WINE_IS_DEBUG_ON(_WARN,&__wine_dbch_##ch) + +#ifndef WINE_FIXME +#define WINE_FIXME __WINE_DPRINTF(_FIXME,__wine_dbch___default) +#define WINE_FIXME_(ch) __WINE_DPRINTF(_FIXME,&__wine_dbch_##ch) +#endif +#define WINE_FIXME_ON(ch) __WINE_IS_DEBUG_ON(_FIXME,&__wine_dbch_##ch) + +#define WINE_ERR __WINE_DPRINTF(_ERR,__wine_dbch___default) +#define WINE_ERR_(ch) __WINE_DPRINTF(_ERR,&__wine_dbch_##ch) +#define WINE_ERR_ON(ch) __WINE_IS_DEBUG_ON(_ERR,&__wine_dbch_##ch) + +#define WINE_DECLARE_DEBUG_CHANNEL(ch) \ + static struct __wine_debug_channel __wine_dbch_##ch = { 0xff, #ch }; \ + C_ASSERT(sizeof(#ch) <= sizeof(__wine_dbch_##ch.name)) +#define WINE_DEFAULT_DEBUG_CHANNEL(ch) \ + static struct __wine_debug_channel __wine_dbch_##ch = { 0xff, #ch }; \ + C_ASSERT(sizeof(#ch) <= sizeof(__wine_dbch_##ch.name)); \ + static struct __wine_debug_channel * const __wine_dbch___default = &__wine_dbch_##ch + +#define WINE_MESSAGE wine_dbg_printf + +#ifdef __WINESRC__ +/* Wine uses shorter names that are very likely to conflict with other software */ + +static inline const char *debugstr_an( const char * s, int n ) { return wine_dbgstr_an( s, n ); } +static inline const char *debugstr_wn( const WCHAR *s, int n ) { return wine_dbgstr_wn( s, n ); } +static inline const char *debugstr_guid( const struct _GUID *id ) { return wine_dbgstr_guid(id); } +static inline const char *debugstr_fourcc( unsigned int cc ) { return wine_dbgstr_fourcc( cc ); } +static inline const char *debugstr_a( const char *s ) { return wine_dbgstr_an( s, -1 ); } +static inline const char *debugstr_w( const WCHAR *s ) { return wine_dbgstr_wn( s, -1 ); } + +#if defined(__hstring_h__) && defined(__WINSTRING_H_) +static inline const char *debugstr_hstring( struct HSTRING__ *s ) { return wine_dbgstr_hstring( s ); } +#endif + +#if defined(__oaidl_h__) && defined(V_VT) +static inline const char *debugstr_vt( VARTYPE vt ) { return wine_dbgstr_vt( vt ); } +static inline const char *debugstr_variant( const VARIANT *v ) { return wine_dbgstr_variant( v ); } +#endif + +#define TRACE WINE_TRACE +#define TRACE_(ch) WINE_TRACE_(ch) +#define TRACE_ON(ch) WINE_TRACE_ON(ch) + +#define WARN WINE_WARN +#define WARN_(ch) WINE_WARN_(ch) +#define WARN_ON(ch) WINE_WARN_ON(ch) + +#define FIXME WINE_FIXME +#define FIXME_(ch) WINE_FIXME_(ch) +#define FIXME_ON(ch) WINE_FIXME_ON(ch) + +#undef ERR /* Solaris got an 'ERR' define in */ +#define ERR WINE_ERR +#define ERR_(ch) WINE_ERR_(ch) +#define ERR_ON(ch) WINE_ERR_ON(ch) + +#define MESSAGE WINE_MESSAGE + +#endif /* __WINESRC__ */ + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_WINE_DEBUG_H */ diff --git a/WineFix/lib/d2d1/include/wine/heap.h b/WineFix/lib/d2d1/include/wine/heap.h new file mode 100644 index 0000000..6110ec8 --- /dev/null +++ b/WineFix/lib/d2d1/include/wine/heap.h @@ -0,0 +1,121 @@ +/* + * Wine heap memory allocation wrappers + * + * Copyright 2006 Jacek Caban for CodeWeavers + * Copyright 2013, 2018 Michael Stefaniuc + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_WINE_HEAP_H +#define __WINE_WINE_HEAP_H + +#include +#include +#include + +/* Compatibility: wcsdup vs _wcsdup handling */ +#ifdef __unix__ +/* On Unix/Linux, use standard wcsdup, map _wcsdup to it */ +#ifndef _wcsdup +#define _wcsdup wcsdup +#endif +#else +/* On Windows, wcsdup might not be available, use _wcsdup */ +#ifndef wcsdup +#define wcsdup _wcsdup +#endif +#endif + +/* Common Wine utility macros */ +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) +#endif + +#ifndef CONTAINING_RECORD +#define CONTAINING_RECORD(address, type, field) \ + ((type *)((char *)(address) - (unsigned long)(&((type *)0)->field))) +#endif + +/* COM helper macros - simplified versions */ +#ifndef IUnknown_QueryInterface +#define IUnknown_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#endif + +#ifndef IUnknown_AddRef +#define IUnknown_AddRef(p) (p)->lpVtbl->AddRef(p) +#endif + +#ifndef IUnknown_Release +#define IUnknown_Release(p) (p)->lpVtbl->Release(p) +#endif + +#ifndef IStream_Write +#define IStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c) +#endif + +#ifndef IStream_Read +#define IStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c) +#endif + +#ifndef IStream_Seek +#define IStream_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c) +#endif + +#ifndef IStream_Release +#define IStream_Release(p) (p)->lpVtbl->Release(p) +#endif + +/* GCC attribute macros */ +#if defined(__GNUC__) || defined(__clang__) +#define __WINE_ALLOC_SIZE(...) __attribute__((alloc_size(__VA_ARGS__))) +#define __WINE_MALLOC __attribute__((malloc)) +#else +#define __WINE_ALLOC_SIZE(...) +#define __WINE_MALLOC +#endif + +static inline void * __WINE_ALLOC_SIZE(1) __WINE_MALLOC heap_alloc(SIZE_T len) +{ + return HeapAlloc(GetProcessHeap(), 0, len); +} + +static inline void * __WINE_ALLOC_SIZE(1) __WINE_MALLOC heap_alloc_zero(SIZE_T len) +{ + return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); +} + +static inline void * __WINE_ALLOC_SIZE(2) heap_realloc(void *mem, SIZE_T len) +{ + if (!mem) + return HeapAlloc(GetProcessHeap(), 0, len); + return HeapReAlloc(GetProcessHeap(), 0, mem, len); +} + +static inline void heap_free(void *mem) +{ + HeapFree(GetProcessHeap(), 0, mem); +} + +static inline void * __WINE_ALLOC_SIZE(1,2) __WINE_MALLOC heap_calloc(SIZE_T count, SIZE_T size) +{ + SIZE_T len = count * size; + + if (size && len / size != count) + return NULL; + return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); +} + +#endif /* __WINE_WINE_HEAP_H */ diff --git a/WineFix/lib/d2d1/include/wine/list.h b/WineFix/lib/d2d1/include/wine/list.h new file mode 100644 index 0000000..2e1d95f --- /dev/null +++ b/WineFix/lib/d2d1/include/wine/list.h @@ -0,0 +1,270 @@ +/* + * Linked lists support + * + * Copyright (C) 2002 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_SERVER_LIST_H +#define __WINE_SERVER_LIST_H + +#include + +struct list +{ + struct list *next; + struct list *prev; +}; + +/* Define a list like so: + * + * struct gadget + * { + * struct list entry; <-- doesn't have to be the first item in the struct + * int a, b; + * }; + * + * static struct list global_gadgets = LIST_INIT( global_gadgets ); + * + * or + * + * struct some_global_thing + * { + * struct list gadgets; + * }; + * + * list_init( &some_global_thing->gadgets ); + * + * Manipulate it like this: + * + * list_add_head( &global_gadgets, &new_gadget->entry ); + * list_remove( &new_gadget->entry ); + * list_add_after( &some_random_gadget->entry, &new_gadget->entry ); + * + * And to iterate over it: + * + * struct gadget *gadget; + * LIST_FOR_EACH_ENTRY( gadget, &global_gadgets, struct gadget, entry ) + * { + * ... + * } + * + */ + +/* add an element after the specified one */ +static inline void list_add_after( struct list *elem, struct list *to_add ) +{ + to_add->next = elem->next; + to_add->prev = elem; + elem->next->prev = to_add; + elem->next = to_add; +} + +/* add an element before the specified one */ +static inline void list_add_before( struct list *elem, struct list *to_add ) +{ + to_add->next = elem; + to_add->prev = elem->prev; + elem->prev->next = to_add; + elem->prev = to_add; +} + +/* add element at the head of the list */ +static inline void list_add_head( struct list *list, struct list *elem ) +{ + list_add_after( list, elem ); +} + +/* add element at the tail of the list */ +static inline void list_add_tail( struct list *list, struct list *elem ) +{ + list_add_before( list, elem ); +} + +/* remove an element from its list */ +static inline void list_remove( struct list *elem ) +{ + elem->next->prev = elem->prev; + elem->prev->next = elem->next; +} + +/* get the next element */ +static inline struct list *list_next( const struct list *list, const struct list *elem ) +{ + struct list *ret = elem->next; + if (elem->next == list) ret = NULL; + return ret; +} + +/* get the previous element */ +static inline struct list *list_prev( const struct list *list, const struct list *elem ) +{ + struct list *ret = elem->prev; + if (elem->prev == list) ret = NULL; + return ret; +} + +/* get the first element */ +static inline struct list *list_head( const struct list *list ) +{ + return list_next( list, list ); +} + +/* get the last element */ +static inline struct list *list_tail( const struct list *list ) +{ + return list_prev( list, list ); +} + +/* check if a list is empty */ +static inline int list_empty( const struct list *list ) +{ + return list->next == list; +} + +/* initialize a list */ +static inline void list_init( struct list *list ) +{ + list->next = list->prev = list; +} + +/* count the elements of a list */ +static inline unsigned int list_count( const struct list *list ) +{ + unsigned count = 0; + const struct list *ptr; + for (ptr = list->next; ptr != list; ptr = ptr->next) count++; + return count; +} + +/* move all elements from src to before the specified element */ +static inline void list_move_before( struct list *dst, struct list *src ) +{ + if (list_empty(src)) return; + + dst->prev->next = src->next; + src->next->prev = dst->prev; + dst->prev = src->prev; + src->prev->next = dst; + list_init(src); +} + +/* move all elements from src to after the specified element */ +static inline void list_move_after( struct list *dst, struct list *src ) +{ + if (list_empty(src)) return; + + dst->next->prev = src->prev; + src->prev->next = dst->next; + dst->next = src->next; + src->next->prev = dst; + list_init(src); +} + +/* move all elements from src to the head of dst */ +static inline void list_move_head( struct list *dst, struct list *src ) +{ + list_move_after( dst, src ); +} + +/* move all elements from src to the tail of dst */ +static inline void list_move_tail( struct list *dst, struct list *src ) +{ + list_move_before( dst, src ); +} + +/* move the slice of elements from begin to end inclusive to the head of dst */ +static inline void list_move_slice_head( struct list *dst, struct list *begin, struct list *end ) +{ + struct list *dst_next = dst->next; + begin->prev->next = end->next; + end->next->prev = begin->prev; + dst->next = begin; + dst_next->prev = end; + begin->prev = dst; + end->next = dst_next; +} + +/* move the slice of elements from begin to end inclusive to the tail of dst */ +static inline void list_move_slice_tail( struct list *dst, struct list *begin, struct list *end ) +{ + struct list *dst_prev = dst->prev; + begin->prev->next = end->next; + end->next->prev = begin->prev; + dst_prev->next = begin; + dst->prev = end; + begin->prev = dst_prev; + end->next = dst; +} + +/* iterate through the list */ +#define LIST_FOR_EACH(cursor,list) \ + for ((cursor) = (list)->next; (cursor) != (list); (cursor) = (cursor)->next) + +/* iterate through the list, with safety against removal */ +#define LIST_FOR_EACH_SAFE(cursor, cursor2, list) \ + for ((cursor) = (list)->next, (cursor2) = (cursor)->next; \ + (cursor) != (list); \ + (cursor) = (cursor2), (cursor2) = (cursor)->next) + +/* iterate through the list using a list entry */ +#define LIST_FOR_EACH_ENTRY(elem, list, type, field) \ + for ((elem) = LIST_ENTRY((list)->next, type, field); \ + &(elem)->field != (list); \ + (elem) = LIST_ENTRY((elem)->field.next, type, field)) + +/* iterate through the list using a list entry, with safety against removal */ +#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field) \ + for ((cursor) = LIST_ENTRY((list)->next, type, field), \ + (cursor2) = LIST_ENTRY((cursor)->field.next, type, field); \ + &(cursor)->field != (list); \ + (cursor) = (cursor2), \ + (cursor2) = LIST_ENTRY((cursor)->field.next, type, field)) + +/* iterate through the list in reverse order */ +#define LIST_FOR_EACH_REV(cursor,list) \ + for ((cursor) = (list)->prev; (cursor) != (list); (cursor) = (cursor)->prev) + +/* iterate through the list in reverse order, with safety against removal */ +#define LIST_FOR_EACH_SAFE_REV(cursor, cursor2, list) \ + for ((cursor) = (list)->prev, (cursor2) = (cursor)->prev; \ + (cursor) != (list); \ + (cursor) = (cursor2), (cursor2) = (cursor)->prev) + +/* iterate through the list in reverse order using a list entry */ +#define LIST_FOR_EACH_ENTRY_REV(elem, list, type, field) \ + for ((elem) = LIST_ENTRY((list)->prev, type, field); \ + &(elem)->field != (list); \ + (elem) = LIST_ENTRY((elem)->field.prev, type, field)) + +/* iterate through the list in reverse order using a list entry, with safety against removal */ +#define LIST_FOR_EACH_ENTRY_SAFE_REV(cursor, cursor2, list, type, field) \ + for ((cursor) = LIST_ENTRY((list)->prev, type, field), \ + (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field); \ + &(cursor)->field != (list); \ + (cursor) = (cursor2), \ + (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field)) + +/* macros for statically initialized lists */ +#undef LIST_INIT +#define LIST_INIT(list) { &(list), &(list) } + +/* get pointer to object containing list element */ +#undef LIST_ENTRY +#define LIST_ENTRY(elem, type, field) \ + ((type *)((char *)(elem) - offsetof(type, field))) + +#endif /* __WINE_SERVER_LIST_H */ diff --git a/WineFix/lib/d2d1/src/bitmap.c b/WineFix/lib/d2d1/src/bitmap.c new file mode 100644 index 0000000..c6ab60c --- /dev/null +++ b/WineFix/lib/d2d1/src/bitmap.c @@ -0,0 +1,804 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" +#include "wincodec.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_bitmap *impl_from_ID2D1Bitmap1(ID2D1Bitmap1 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface); +} + +static HRESULT d2d_bitmap_unmap(struct d2d_bitmap *bitmap) +{ + ID3D11DeviceContext *context; + ID3D11Device *device; + + if (!bitmap->mapped_resource.pData) + return D2DERR_WRONG_STATE; + + ID3D11Resource_GetDevice(bitmap->resource, &device); + ID3D11Device_GetImmediateContext(device, &context); + ID3D11DeviceContext_Unmap(context, bitmap->resource, 0); + ID3D11DeviceContext_Release(context); + ID3D11Device_Release(device); + + memset(&bitmap->mapped_resource, 0, sizeof(bitmap->mapped_resource)); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_QueryInterface(ID2D1Bitmap1 *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1Bitmap1) + || IsEqualGUID(iid, &IID_ID2D1Bitmap) + || IsEqualGUID(iid, &IID_ID2D1Image) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Bitmap1_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_bitmap_AddRef(ID2D1Bitmap1 *iface) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + ULONG refcount = InterlockedIncrement(&bitmap->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_bitmap_Release(ID2D1Bitmap1 *iface) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + ULONG refcount = InterlockedDecrement(&bitmap->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + if (bitmap->srv) + ID3D11ShaderResourceView_Release(bitmap->srv); + if (bitmap->rtv) + ID3D11RenderTargetView_Release(bitmap->rtv); + if (bitmap->surface) + IDXGISurface_Release(bitmap->surface); + ID3D11Resource_Release(bitmap->resource); + ID2D1Factory_Release(bitmap->factory); + free(bitmap); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_bitmap_GetFactory(ID2D1Bitmap1 *iface, ID2D1Factory **factory) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = bitmap->factory); +} + +static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_bitmap_GetSize(ID2D1Bitmap1 *iface, D2D1_SIZE_F *size) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p, size %p.\n", iface, size); + + size->width = bitmap->pixel_size.width / (bitmap->dpi_x / 96.0f); + size->height = bitmap->pixel_size.height / (bitmap->dpi_y / 96.0f); + return size; +} + +static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_bitmap_GetPixelSize(ID2D1Bitmap1 *iface, D2D1_SIZE_U *pixel_size) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p, pixel_size %p.\n", iface, pixel_size); + + *pixel_size = bitmap->pixel_size; + return pixel_size; +} + +static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_bitmap_GetPixelFormat(ID2D1Bitmap1 *iface, D2D1_PIXEL_FORMAT *format) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p, format %p.\n", iface, format); + + *format = bitmap->format; + return format; +} + +static void STDMETHODCALLTYPE d2d_bitmap_GetDpi(ID2D1Bitmap1 *iface, float *dpi_x, float *dpi_y) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + *dpi_x = bitmap->dpi_x; + *dpi_y = bitmap->dpi_y; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromBitmap(ID2D1Bitmap1 *iface, + const D2D1_POINT_2U *dst_point, ID2D1Bitmap *bitmap, const D2D1_RECT_U *src_rect) +{ + struct d2d_bitmap *src_bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap); + struct d2d_bitmap *dst_bitmap = impl_from_ID2D1Bitmap1(iface); + ID3D11DeviceContext *context; + ID3D11Device *device; + D3D11_BOX box; + + TRACE("iface %p, dst_point %s, bitmap %p, src_rect %s.\n", iface, + debug_d2d_point_2u(dst_point), bitmap, debug_d2d_rect_u(src_rect)); + + if (src_rect) + { + box.left = src_rect->left; + box.top = src_rect->top; + box.front = 0; + box.right = src_rect->right; + box.bottom = src_rect->bottom; + box.back = 1; + } + + ID3D11Resource_GetDevice(dst_bitmap->resource, &device); + ID3D11Device_GetImmediateContext(device, &context); + ID3D11DeviceContext_CopySubresourceRegion(context, dst_bitmap->resource, 0, + dst_point ? dst_point->x : 0, dst_point ? dst_point->y : 0, 0, + src_bitmap->resource, 0, src_rect ? &box : NULL); + ID3D11DeviceContext_Release(context); + ID3D11Device_Release(device); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromRenderTarget(ID2D1Bitmap1 *iface, + const D2D1_POINT_2U *dst_point, ID2D1RenderTarget *render_target, const D2D1_RECT_U *src_rect) +{ + ID2D1DeviceContext *device_context; + ID2D1Bitmap *target_bitmap = NULL; + ID2D1Image *target = NULL; + HRESULT hr; + + TRACE("iface %p, dst_point %s, render_target %p, src_rect %s.\n", iface, + debug_d2d_point_2u(dst_point), render_target, debug_d2d_rect_u(src_rect)); + + if (FAILED(hr = ID2D1RenderTarget_QueryInterface(render_target, &IID_ID2D1DeviceContext, + (void **)&device_context))) + { + return hr; + } + + ID2D1DeviceContext_GetTarget(device_context, &target); + ID2D1DeviceContext_Release(device_context); + + if (target) + { + ID2D1Image_QueryInterface(target, &IID_ID2D1Bitmap, (void **)&target_bitmap); + ID2D1Image_Release(target); + } + + if (!target_bitmap) + return D2DERR_RECREATE_TARGET; + + hr = ID2D1Bitmap1_CopyFromBitmap(iface, dst_point, target_bitmap, src_rect); + ID2D1Bitmap_Release(target_bitmap); + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromMemory(ID2D1Bitmap1 *iface, + const D2D1_RECT_U *dst_rect, const void *src_data, UINT32 pitch) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + ID3D11DeviceContext *context; + ID3D11Device *device; + D3D11_BOX box; + + TRACE("iface %p, dst_rect %s, src_data %p, pitch %u.\n", iface, debug_d2d_rect_u(dst_rect), + src_data, pitch); + + if (dst_rect) + { + box.left = dst_rect->left; + box.top = dst_rect->top; + box.front = 0; + box.right = dst_rect->right; + box.bottom = dst_rect->bottom; + box.back = 1; + } + + ID3D11Resource_GetDevice(bitmap->resource, &device); + ID3D11Device_GetImmediateContext(device, &context); + ID3D11DeviceContext_UpdateSubresource(context, bitmap->resource, 0, dst_rect ? &box : NULL, src_data, pitch, 0); + ID3D11DeviceContext_Release(context); + ID3D11Device_Release(device); + + return S_OK; +} + +static void STDMETHODCALLTYPE d2d_bitmap_GetColorContext(ID2D1Bitmap1 *iface, ID2D1ColorContext **context) +{ + FIXME("iface %p, context %p stub!\n", iface, context); +} + +static D2D1_BITMAP_OPTIONS STDMETHODCALLTYPE d2d_bitmap_GetOptions(ID2D1Bitmap1 *iface) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p.\n", iface); + + return bitmap->options; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_GetSurface(ID2D1Bitmap1 *iface, IDXGISurface **surface) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p, surface %p.\n", iface, surface); + + *surface = bitmap->surface; + if (*surface) + IDXGISurface_AddRef(*surface); + + return *surface ? S_OK : D2DERR_INVALID_CALL; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_Map(ID2D1Bitmap1 *iface, D2D1_MAP_OPTIONS options, + D2D1_MAPPED_RECT *mapped_rect) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + D3D11_MAPPED_SUBRESOURCE mapped_resource; + ID3D11DeviceContext *context; + ID3D11Device *device; + D3D11_MAP map_type; + HRESULT hr; + + TRACE("iface %p, options %#x, mapped_rect %p.\n", iface, options, mapped_rect); + + if (!(bitmap->options & D2D1_BITMAP_OPTIONS_CPU_READ)) + return E_INVALIDARG; + + if (bitmap->mapped_resource.pData) + return D2DERR_WRONG_STATE; + + if (options == D2D1_MAP_OPTIONS_READ) + map_type = D3D11_MAP_READ; + else if (options == D2D1_MAP_OPTIONS_WRITE) + map_type = D3D11_MAP_WRITE; + else if (options == (D2D1_MAP_OPTIONS_READ | D2D1_MAP_OPTIONS_WRITE)) + map_type = D3D11_MAP_READ_WRITE; + else if (options == (D2D1_MAP_OPTIONS_WRITE | D2D1_MAP_OPTIONS_DISCARD)) + map_type = D3D11_MAP_WRITE_DISCARD; + else + { + WARN("Invalid mapping options %#x.\n", options); + return E_INVALIDARG; + } + + ID3D11Resource_GetDevice(bitmap->resource, &device); + ID3D11Device_GetImmediateContext(device, &context); + if (SUCCEEDED(hr = ID3D11DeviceContext_Map(context, bitmap->resource, 0, map_type, + 0, &mapped_resource))) + { + bitmap->mapped_resource = mapped_resource; + } + ID3D11DeviceContext_Release(context); + ID3D11Device_Release(device); + + if (FAILED(hr)) + { + WARN("Failed to map resource, hr %#lx.\n", hr); + return E_INVALIDARG; + } + + mapped_rect->pitch = bitmap->mapped_resource.RowPitch; + mapped_rect->bits = bitmap->mapped_resource.pData; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_Unmap(ID2D1Bitmap1 *iface) +{ + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); + + TRACE("iface %p.\n", iface); + + return d2d_bitmap_unmap(bitmap); +} + +static const struct ID2D1Bitmap1Vtbl d2d_bitmap_vtbl = +{ + d2d_bitmap_QueryInterface, + d2d_bitmap_AddRef, + d2d_bitmap_Release, + d2d_bitmap_GetFactory, + d2d_bitmap_GetSize, + d2d_bitmap_GetPixelSize, + d2d_bitmap_GetPixelFormat, + d2d_bitmap_GetDpi, + d2d_bitmap_CopyFromBitmap, + d2d_bitmap_CopyFromRenderTarget, + d2d_bitmap_CopyFromMemory, + d2d_bitmap_GetColorContext, + d2d_bitmap_GetOptions, + d2d_bitmap_GetSurface, + d2d_bitmap_Map, + d2d_bitmap_Unmap, +}; + +static BOOL format_supported(const D2D1_PIXEL_FORMAT *format) +{ + unsigned int i; + + static const D2D1_PIXEL_FORMAT supported_formats[] = + { + {DXGI_FORMAT_R32G32B32A32_FLOAT, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_R32G32B32A32_FLOAT, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_R16G16B16A16_FLOAT, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_R16G16B16A16_FLOAT, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_R16G16B16A16_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_R16G16B16A16_UNORM, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_A8_UNORM, D2D1_ALPHA_MODE_STRAIGHT }, + {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_B8G8R8X8_UNORM, D2D1_ALPHA_MODE_IGNORE }, + {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, D2D1_ALPHA_MODE_PREMULTIPLIED}, + {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, D2D1_ALPHA_MODE_IGNORE }, + }; + + for (i = 0; i < ARRAY_SIZE(supported_formats); ++i) + { + if (supported_formats[i].format == format->format + && supported_formats[i].alphaMode == format->alphaMode) + return TRUE; + } + + return FALSE; +} + +static void d2d_bitmap_init(struct d2d_bitmap *bitmap, struct d2d_device_context *context, + ID3D11Resource *resource, D2D1_SIZE_U size, const D2D1_BITMAP_PROPERTIES1 *desc) +{ + ID3D11Device *d3d_device; + HRESULT hr; + + bitmap->ID2D1Bitmap1_iface.lpVtbl = &d2d_bitmap_vtbl; + bitmap->refcount = 1; + ID2D1Factory_AddRef(bitmap->factory = context->factory); + ID3D11Resource_AddRef(bitmap->resource = resource); + bitmap->pixel_size = size; + bitmap->format = desc->pixelFormat; + bitmap->dpi_x = desc->dpiX; + bitmap->dpi_y = desc->dpiY; + bitmap->options = desc->bitmapOptions; + + if (d2d_device_context_is_dxgi_target(context)) + ID3D11Resource_QueryInterface(resource, &IID_IDXGISurface, (void **)&bitmap->surface); + + ID3D11Resource_GetDevice(resource, &d3d_device); + if (bitmap->options & D2D1_BITMAP_OPTIONS_TARGET) + { + if (FAILED(hr = ID3D11Device_CreateRenderTargetView(d3d_device, resource, NULL, &bitmap->rtv))) + WARN("Failed to create RTV, hr %#lx.\n", hr); + } + + if (!(bitmap->options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW)) + { + if (FAILED(hr = ID3D11Device_CreateShaderResourceView(d3d_device, resource, NULL, &bitmap->srv))) + WARN("Failed to create SRV, hr %#lx.\n", hr); + } + ID3D11Device_Release(d3d_device); + + if (bitmap->dpi_x == 0.0f && bitmap->dpi_y == 0.0f) + { + bitmap->dpi_x = 96.0f; + bitmap->dpi_y = 96.0f; + } +} + +static BOOL check_bitmap_options(unsigned int options) +{ + switch (options) + { + case D2D1_BITMAP_OPTIONS_NONE: + case D2D1_BITMAP_OPTIONS_TARGET: + case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW: + case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE: + case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE: + case D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_CPU_READ: + return TRUE; + default: + WARN("Invalid bitmap options %#x.\n", options); + return FALSE; + } +} + +HRESULT d2d_bitmap_create(struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data, + UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) +{ + D3D11_SUBRESOURCE_DATA resource_data; + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + D3D11_TEXTURE2D_DESC texture_desc; + ID3D11Texture2D *texture; + HRESULT hr; + + if (!format_supported(&desc->pixelFormat)) + { + WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n", + desc->pixelFormat.format, desc->pixelFormat.alphaMode); + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; + } + + if (desc->dpiX == 0.0f && desc->dpiY == 0.0f) + { + bitmap_desc = *desc; + bitmap_desc.dpiX = context->desc.dpiX; + bitmap_desc.dpiY = context->desc.dpiY; + desc = &bitmap_desc; + } + else if (desc->dpiX <= 0.0f || desc->dpiY <= 0.0f) + { + return E_INVALIDARG; + } + + if (!check_bitmap_options(desc->bitmapOptions)) + return E_INVALIDARG; + + texture_desc.Width = size.width; + texture_desc.Height = size.height; + if (!texture_desc.Width || !texture_desc.Height) + texture_desc.Width = texture_desc.Height = 1; + texture_desc.MipLevels = 1; + texture_desc.ArraySize = 1; + texture_desc.Format = desc->pixelFormat.format; + texture_desc.SampleDesc.Count = 1; + texture_desc.SampleDesc.Quality = 0; + texture_desc.Usage = D3D11_USAGE_DEFAULT; + if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CPU_READ) + texture_desc.Usage = D3D11_USAGE_STAGING; + texture_desc.BindFlags = 0; + if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_TARGET) + texture_desc.BindFlags |= D3D11_BIND_RENDER_TARGET; + if (!(desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CANNOT_DRAW)) + texture_desc.BindFlags |= D3D11_BIND_SHADER_RESOURCE; + texture_desc.CPUAccessFlags = 0; + if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CPU_READ) + texture_desc.CPUAccessFlags |= D3D11_CPU_ACCESS_READ; + texture_desc.MiscFlags = 0; + if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE) + texture_desc.MiscFlags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE; + + resource_data.pSysMem = src_data; + resource_data.SysMemPitch = pitch; + + if (FAILED(hr = ID3D11Device1_CreateTexture2D(context->d3d_device, &texture_desc, + src_data ? &resource_data : NULL, &texture))) + { + ERR("Failed to create texture, hr %#lx.\n", hr); + return hr; + } + + if ((*bitmap = calloc(1, sizeof(**bitmap)))) + { + d2d_bitmap_init(*bitmap, context, (ID3D11Resource *)texture, size, desc); + TRACE("Created bitmap %p.\n", *bitmap); + } + ID3D11Texture2D_Release(texture); + + return *bitmap ? S_OK : E_OUTOFMEMORY; +} + +unsigned int d2d_get_bitmap_options_for_surface(IDXGISurface *surface) +{ + D3D11_TEXTURE2D_DESC desc; + unsigned int options = 0; + ID3D11Texture2D *texture; + + if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Texture2D, (void **)&texture))) + return 0; + + ID3D11Texture2D_GetDesc(texture, &desc); + ID3D11Texture2D_Release(texture); + + if (desc.BindFlags & D3D11_BIND_RENDER_TARGET) + options |= D2D1_BITMAP_OPTIONS_TARGET; + if (!(desc.BindFlags & D3D11_BIND_SHADER_RESOURCE)) + options |= D2D1_BITMAP_OPTIONS_CANNOT_DRAW; + if (desc.MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE) + options |= D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE; + if (desc.Usage == D3D11_USAGE_STAGING && desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) + options |= D2D1_BITMAP_OPTIONS_CPU_READ; + + return options; +} + +HRESULT d2d_bitmap_create_shared(struct d2d_device_context *context, REFIID iid, void *data, + const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) +{ + D2D1_BITMAP_PROPERTIES1 d; + + if (IsEqualGUID(iid, &IID_ID2D1Bitmap)) + { + struct d2d_bitmap *src_impl = unsafe_impl_from_ID2D1Bitmap(data); + ID3D11Device *device; + HRESULT hr = S_OK; + + if (src_impl->factory != context->factory) + { + hr = D2DERR_WRONG_FACTORY; + goto failed; + } + + ID3D11Resource_GetDevice(src_impl->resource, &device); + ID3D11Device_Release(device); + if (device != (ID3D11Device *)context->d3d_device) + { + hr = D2DERR_UNSUPPORTED_OPERATION; + goto failed; + } + + if (desc) + { + d = *desc; + if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN) + d.pixelFormat.format = src_impl->format.format; + if (d.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN) + d.pixelFormat.alphaMode = src_impl->format.alphaMode; + } + else + { + d.pixelFormat = src_impl->format; + d.dpiX = src_impl->dpi_x; + d.dpiY = src_impl->dpi_y; + d.bitmapOptions = src_impl->options; + d.colorContext = NULL; + } + desc = &d; + + if (!format_supported(&desc->pixelFormat)) + { + WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n", + desc->pixelFormat.format, desc->pixelFormat.alphaMode); + hr = D2DERR_UNSUPPORTED_PIXEL_FORMAT; + goto failed; + } + + if (!(*bitmap = calloc(1, sizeof(**bitmap)))) + { + hr = E_OUTOFMEMORY; + goto failed; + } + + d2d_bitmap_init(*bitmap, context, src_impl->resource, src_impl->pixel_size, desc); + TRACE("Created bitmap %p.\n", *bitmap); + + failed: + return hr; + } + + if (IsEqualGUID(iid, &IID_IDXGISurface) || IsEqualGUID(iid, &IID_IDXGISurface1)) + { + DXGI_SURFACE_DESC surface_desc; + IDXGISurface *surface = data; + ID3D11Resource *resource; + D2D1_SIZE_U pixel_size; + ID3D11Device *device; + HRESULT hr; + + if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Resource, (void **)&resource))) + { + WARN("Failed to get d3d resource from dxgi surface.\n"); + return E_FAIL; + } + + ID3D11Resource_GetDevice(resource, &device); + ID3D11Device_Release(device); + if (device != (ID3D11Device *)context->d3d_device) + { + ID3D11Resource_Release(resource); + return D2DERR_UNSUPPORTED_OPERATION; + } + + if (!(*bitmap = calloc(1, sizeof(**bitmap)))) + { + ID3D11Resource_Release(resource); + return E_OUTOFMEMORY; + } + + + if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc))) + { + WARN("Failed to get surface desc, hr %#lx.\n", hr); + ID3D11Resource_Release(resource); + return hr; + } + + if (!desc) + { + memset(&d, 0, sizeof(d)); + d.pixelFormat.format = surface_desc.Format; + d.bitmapOptions = d2d_get_bitmap_options_for_surface(surface); + } + else + { + d = *desc; + if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN) + d.pixelFormat.format = surface_desc.Format; + } + + if (d.dpiX == 0.0f || d.dpiY == 0.0f) + { + if (d.dpiX == 0.0f) + d.dpiX = context->desc.dpiX; + if (d.dpiY == 0.0f) + d.dpiY = context->desc.dpiY; + } + + pixel_size.width = surface_desc.Width; + pixel_size.height = surface_desc.Height; + + d2d_bitmap_init(*bitmap, context, resource, pixel_size, &d); + ID3D11Resource_Release(resource); + TRACE("Created bitmap %p.\n", *bitmap); + + return S_OK; + } + + WARN("Unhandled interface %s.\n", debugstr_guid(iid)); + + return E_INVALIDARG; +} + +HRESULT d2d_bitmap_create_from_wic_bitmap(struct d2d_device_context *context, IWICBitmapSource *bitmap_source, + const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) +{ + const D2D1_PIXEL_FORMAT *d2d_format; + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + WICPixelFormatGUID wic_format; + unsigned int bpp, data_size; + D2D1_SIZE_U size; + unsigned int i; + WICRect rect; + UINT32 pitch; + HRESULT hr; + void *data; + + static const struct + { + const WICPixelFormatGUID *wic; + D2D1_PIXEL_FORMAT d2d; + } + format_lookup[] = + { + {&GUID_WICPixelFormat32bppPBGRA, {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}}, + {&GUID_WICPixelFormat32bppPRGBA, {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}}, + {&GUID_WICPixelFormat32bppBGR, {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}}, + {&GUID_WICPixelFormat32bppRGB, {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}}, + }; + + if (FAILED(hr = IWICBitmapSource_GetSize(bitmap_source, &size.width, &size.height))) + { + WARN("Failed to get bitmap size, hr %#lx.\n", hr); + return hr; + } + + if (!desc) + { + bitmap_desc.pixelFormat.format = DXGI_FORMAT_UNKNOWN; + bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN; + bitmap_desc.dpiX = 0.0f; + bitmap_desc.dpiY = 0.0f; + bitmap_desc.bitmapOptions = 0; + bitmap_desc.colorContext = NULL; + } + else + { + bitmap_desc = *desc; + } + + if (FAILED(hr = IWICBitmapSource_GetPixelFormat(bitmap_source, &wic_format))) + { + WARN("Failed to get bitmap format, hr %#lx.\n", hr); + return hr; + } + + for (i = 0, d2d_format = NULL; i < ARRAY_SIZE(format_lookup); ++i) + { + if (IsEqualGUID(&wic_format, format_lookup[i].wic)) + { + d2d_format = &format_lookup[i].d2d; + break; + } + } + + if (!d2d_format) + { + WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&wic_format)); + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; + } + + if (bitmap_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN) + bitmap_desc.pixelFormat.format = d2d_format->format; + if (bitmap_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN) + bitmap_desc.pixelFormat.alphaMode = d2d_format->alphaMode; + + switch (bitmap_desc.pixelFormat.format) + { + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM: + bpp = 4; + break; + + default: + FIXME("Unhandled format %#x.\n", bitmap_desc.pixelFormat.format); + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; + } + + pitch = ((bpp * size.width) + 15) & ~15; + if (pitch / bpp < size.width) + return E_OUTOFMEMORY; + if (!(data = calloc(size.height, pitch))) + return E_OUTOFMEMORY; + data_size = size.height * pitch; + + rect.X = 0; + rect.Y = 0; + rect.Width = size.width; + rect.Height = size.height; + if (FAILED(hr = IWICBitmapSource_CopyPixels(bitmap_source, &rect, pitch, data_size, data))) + { + WARN("Failed to copy bitmap pixels, hr %#lx.\n", hr); + free(data); + return hr; + } + + hr = d2d_bitmap_create(context, size, data, pitch, &bitmap_desc, bitmap); + + free(data); + + return hr; +} + +struct d2d_bitmap *unsafe_impl_from_ID2D1Bitmap(ID2D1Bitmap *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (ID2D1BitmapVtbl *)&d2d_bitmap_vtbl); + return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface); +} diff --git a/WineFix/lib/d2d1/src/bitmap_render_target.c b/WineFix/lib/d2d1/src/bitmap_render_target.c new file mode 100644 index 0000000..ce8b896 --- /dev/null +++ b/WineFix/lib/d2d1/src/bitmap_render_target.c @@ -0,0 +1,825 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * Copyright 2016 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_bitmap_render_target *impl_from_ID2D1BitmapRenderTarget(ID2D1BitmapRenderTarget *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_bitmap_render_target, ID2D1BitmapRenderTarget_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_QueryInterface(ID2D1BitmapRenderTarget *iface, + REFIID iid, void **out) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1BitmapRenderTarget) + || IsEqualGUID(iid, &IID_ID2D1RenderTarget) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1BitmapRenderTarget_AddRef(iface); + *out = iface; + return S_OK; + } + + return IUnknown_QueryInterface(render_target->dxgi_inner, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_bitmap_render_target_AddRef(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + ULONG refcount = InterlockedIncrement(&render_target->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_bitmap_render_target_Release(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + ULONG refcount = InterlockedDecrement(&render_target->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + IUnknown_Release(render_target->dxgi_inner); + if (render_target->bitmap) + ID2D1Bitmap_Release(render_target->bitmap); + free(render_target); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_GetFactory(ID2D1BitmapRenderTarget *iface, + ID2D1Factory **factory) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1RenderTarget_GetFactory(render_target->dxgi_target, factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateBitmap(ID2D1BitmapRenderTarget *iface, + D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n", + iface, size.width, size.height, src_data, pitch, desc, bitmap); + + return ID2D1RenderTarget_CreateBitmap(render_target->dxgi_target, size, src_data, pitch, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateBitmapFromWicBitmap(ID2D1BitmapRenderTarget *iface, + IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n", + iface, bitmap_source, desc, bitmap); + + return ID2D1RenderTarget_CreateBitmapFromWicBitmap(render_target->dxgi_target, bitmap_source, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateSharedBitmap(ID2D1BitmapRenderTarget *iface, + REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n", + iface, debugstr_guid(iid), data, desc, bitmap); + + return ID2D1RenderTarget_CreateSharedBitmap(render_target->dxgi_target, iid, data, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateBitmapBrush(ID2D1BitmapRenderTarget *iface, + ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, + const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n", + iface, bitmap, bitmap_brush_desc, brush_desc, brush); + + return ID2D1RenderTarget_CreateBitmapBrush(render_target->dxgi_target, + bitmap, bitmap_brush_desc, brush_desc, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateSolidColorBrush(ID2D1BitmapRenderTarget *iface, + const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush); + + return ID2D1RenderTarget_CreateSolidColorBrush(render_target->dxgi_target, color, desc, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateGradientStopCollection(ID2D1BitmapRenderTarget *iface, + const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, + ID2D1GradientStopCollection **gradient) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n", + iface, stops, stop_count, gamma, extend_mode, gradient); + + return ID2D1RenderTarget_CreateGradientStopCollection(render_target->dxgi_target, + stops, stop_count, gamma, extend_mode, gradient); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateLinearGradientBrush(ID2D1BitmapRenderTarget *iface, + const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + return ID2D1RenderTarget_CreateLinearGradientBrush(render_target->dxgi_target, + gradient_brush_desc, brush_desc, gradient, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateRadialGradientBrush(ID2D1BitmapRenderTarget *iface, + const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + return ID2D1RenderTarget_CreateRadialGradientBrush(render_target->dxgi_target, + gradient_brush_desc, brush_desc, gradient, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateCompatibleRenderTarget(ID2D1BitmapRenderTarget *iface, + const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **render_target) +{ + struct d2d_bitmap_render_target *rt = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p,\n", + iface, size, pixel_size, format, options, render_target); + + return ID2D1RenderTarget_CreateCompatibleRenderTarget(rt->dxgi_target, + size, pixel_size, format, options, render_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateLayer(ID2D1BitmapRenderTarget *iface, + const D2D1_SIZE_F *size, ID2D1Layer **layer) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, size %p, layer %p.\n", iface, size, layer); + + return ID2D1RenderTarget_CreateLayer(render_target->dxgi_target, size, layer); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_CreateMesh(ID2D1BitmapRenderTarget *iface, ID2D1Mesh **mesh) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, mesh %p.\n", iface, mesh); + + return ID2D1RenderTarget_CreateMesh(render_target->dxgi_target, mesh); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawLine(ID2D1BitmapRenderTarget *iface, + D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawRectangle(ID2D1BitmapRenderTarget *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, rect %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_rect_f(rect), brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_FillRectangle(ID2D1BitmapRenderTarget *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, rect %s, brush %p.\n", iface, debug_d2d_rect_f(rect), brush); + + ID2D1RenderTarget_FillRectangle(render_target->dxgi_target, rect, brush); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawRoundedRectangle(ID2D1BitmapRenderTarget *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, rect, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawRoundedRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_FillRoundedRectangle(ID2D1BitmapRenderTarget *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush); + + ID2D1RenderTarget_FillRoundedRectangle(render_target->dxgi_target, rect, brush); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawEllipse(ID2D1BitmapRenderTarget *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, ellipse, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawEllipse(render_target->dxgi_target, ellipse, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_FillEllipse(ID2D1BitmapRenderTarget *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush); + + ID2D1RenderTarget_FillEllipse(render_target->dxgi_target, ellipse, brush); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawGeometry(ID2D1BitmapRenderTarget *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, geometry, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawGeometry(render_target->dxgi_target, geometry, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_FillGeometry(ID2D1BitmapRenderTarget *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush); + + ID2D1RenderTarget_FillGeometry(render_target->dxgi_target, geometry, brush, opacity_brush); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_FillMesh(ID2D1BitmapRenderTarget *iface, + ID2D1Mesh *mesh, ID2D1Brush *brush) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, mesh %p, brush %p.\n", iface, mesh, brush); + + ID2D1RenderTarget_FillMesh(render_target->dxgi_target, mesh, brush); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_FillOpacityMask(ID2D1BitmapRenderTarget *iface, + ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content, + const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, mask %p, brush %p, content %#x, dst_rect %s, src_rect %s.\n", + iface, mask, brush, content, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect)); + + ID2D1RenderTarget_FillOpacityMask(render_target->dxgi_target, + mask, brush, content, dst_rect, src_rect); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawBitmap(ID2D1BitmapRenderTarget *iface, + ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, + D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, src_rect %s.\n", + iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, debug_d2d_rect_f(src_rect)); + + ID2D1RenderTarget_DrawBitmap(render_target->dxgi_target, + bitmap, dst_rect, opacity, interpolation_mode, src_rect); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawText(ID2D1BitmapRenderTarget *iface, + const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect, + ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, " + "brush %p, options %#x, measuring_mode %#x.\n", + iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect), + brush, options, measuring_mode); + + ID2D1RenderTarget_DrawText(render_target->dxgi_target, string, string_len, + text_format, layout_rect, brush, options, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawTextLayout(ID2D1BitmapRenderTarget *iface, + D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); + + ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawGlyphRun(ID2D1BitmapRenderTarget *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, + DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); + + ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target, + baseline_origin, glyph_run, brush, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SetTransform(ID2D1BitmapRenderTarget *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + ID2D1RenderTarget_SetTransform(render_target->dxgi_target, transform); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_GetTransform(ID2D1BitmapRenderTarget *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + ID2D1RenderTarget_GetTransform(render_target->dxgi_target, transform); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SetAntialiasMode(ID2D1BitmapRenderTarget *iface, + D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + ID2D1RenderTarget_SetAntialiasMode(render_target->dxgi_target, antialias_mode); +} + +static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_bitmap_render_target_GetAntialiasMode(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetAntialiasMode(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SetTextAntialiasMode(ID2D1BitmapRenderTarget *iface, + D2D1_TEXT_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + ID2D1RenderTarget_SetTextAntialiasMode(render_target->dxgi_target, antialias_mode); +} + +static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_bitmap_render_target_GetTextAntialiasMode( + ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetTextAntialiasMode(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SetTextRenderingParams(ID2D1BitmapRenderTarget *iface, + IDWriteRenderingParams *text_rendering_params) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + ID2D1RenderTarget_SetTextRenderingParams(render_target->dxgi_target, text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_GetTextRenderingParams(ID2D1BitmapRenderTarget *iface, + IDWriteRenderingParams **text_rendering_params) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + ID2D1RenderTarget_GetTextRenderingParams(render_target->dxgi_target, text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SetTags(ID2D1BitmapRenderTarget *iface, D2D1_TAG tag1, + D2D1_TAG tag2) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2)); + + ID2D1RenderTarget_SetTags(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_GetTags(ID2D1BitmapRenderTarget *iface, D2D1_TAG *tag1, + D2D1_TAG *tag2) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + ID2D1RenderTarget_GetTags(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_PushLayer(ID2D1BitmapRenderTarget *iface, + const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, layer_parameters %p, layer %p.\n", iface, layer_parameters, layer); + + ID2D1RenderTarget_PushLayer(render_target->dxgi_target, layer_parameters, layer); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_PopLayer(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_PopLayer(render_target->dxgi_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_Flush(ID2D1BitmapRenderTarget *iface, D2D1_TAG *tag1, + D2D1_TAG *tag2) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + return ID2D1RenderTarget_Flush(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SaveDrawingState(ID2D1BitmapRenderTarget *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + ID2D1RenderTarget_SaveDrawingState(render_target->dxgi_target, state_block); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_RestoreDrawingState(ID2D1BitmapRenderTarget *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + ID2D1RenderTarget_RestoreDrawingState(render_target->dxgi_target, state_block); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_PushAxisAlignedClip(ID2D1BitmapRenderTarget *iface, + const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, clip_rect %s, antialias_mode %#x.\n", iface, debug_d2d_rect_f(clip_rect), antialias_mode); + + ID2D1RenderTarget_PushAxisAlignedClip(render_target->dxgi_target, clip_rect, antialias_mode); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_PopAxisAlignedClip(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_PopAxisAlignedClip(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_Clear(ID2D1BitmapRenderTarget *iface, const D2D1_COLOR_F *color) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, color %p.\n", iface, color); + + ID2D1RenderTarget_Clear(render_target->dxgi_target, color); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_BeginDraw(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_BeginDraw(render_target->dxgi_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_EndDraw(ID2D1BitmapRenderTarget *iface, + D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + return ID2D1RenderTarget_EndDraw(render_target->dxgi_target, tag1, tag2); +} + +static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_bitmap_render_target_GetPixelFormat(ID2D1BitmapRenderTarget *iface, + D2D1_PIXEL_FORMAT *format) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, format %p.\n", iface, format); + + *format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target); + return format; +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_SetDpi(ID2D1BitmapRenderTarget *iface, float dpi_x, float dpi_y) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y); + + ID2D1RenderTarget_SetDpi(render_target->dxgi_target, dpi_x, dpi_y); +} + +static void STDMETHODCALLTYPE d2d_bitmap_render_target_GetDpi(ID2D1BitmapRenderTarget *iface, + float *dpi_x, float *dpi_y) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + ID2D1RenderTarget_GetDpi(render_target->dxgi_target, dpi_x, dpi_y); +} + +static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_bitmap_render_target_GetSize(ID2D1BitmapRenderTarget *iface, + D2D1_SIZE_F *size) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, size %p.\n", iface, size); + + *size = ID2D1RenderTarget_GetSize(render_target->dxgi_target); + return size; +} + +static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_bitmap_render_target_GetPixelSize(ID2D1BitmapRenderTarget *iface, + D2D1_SIZE_U *pixel_size) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, pixel_size %p.\n", iface, pixel_size); + + *pixel_size = ID2D1RenderTarget_GetPixelSize(render_target->dxgi_target); + return pixel_size; +} + +static UINT32 STDMETHODCALLTYPE d2d_bitmap_render_target_GetMaximumBitmapSize(ID2D1BitmapRenderTarget *iface) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetMaximumBitmapSize(render_target->dxgi_target); +} + +static BOOL STDMETHODCALLTYPE d2d_bitmap_render_target_IsSupported(ID2D1BitmapRenderTarget *iface, + const D2D1_RENDER_TARGET_PROPERTIES *desc) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, desc %p.\n", iface, desc); + + return ID2D1RenderTarget_IsSupported(render_target->dxgi_target, desc); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_render_target_GetBitmap(ID2D1BitmapRenderTarget *iface, + ID2D1Bitmap **bitmap) +{ + struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); + + TRACE("iface %p, bitmap %p.\n", iface, bitmap); + + ID2D1Bitmap_AddRef(*bitmap = render_target->bitmap); + return S_OK; +} + +static const struct ID2D1BitmapRenderTargetVtbl d2d_bitmap_render_target_vtbl = +{ + d2d_bitmap_render_target_QueryInterface, + d2d_bitmap_render_target_AddRef, + d2d_bitmap_render_target_Release, + d2d_bitmap_render_target_GetFactory, + d2d_bitmap_render_target_CreateBitmap, + d2d_bitmap_render_target_CreateBitmapFromWicBitmap, + d2d_bitmap_render_target_CreateSharedBitmap, + d2d_bitmap_render_target_CreateBitmapBrush, + d2d_bitmap_render_target_CreateSolidColorBrush, + d2d_bitmap_render_target_CreateGradientStopCollection, + d2d_bitmap_render_target_CreateLinearGradientBrush, + d2d_bitmap_render_target_CreateRadialGradientBrush, + d2d_bitmap_render_target_CreateCompatibleRenderTarget, + d2d_bitmap_render_target_CreateLayer, + d2d_bitmap_render_target_CreateMesh, + d2d_bitmap_render_target_DrawLine, + d2d_bitmap_render_target_DrawRectangle, + d2d_bitmap_render_target_FillRectangle, + d2d_bitmap_render_target_DrawRoundedRectangle, + d2d_bitmap_render_target_FillRoundedRectangle, + d2d_bitmap_render_target_DrawEllipse, + d2d_bitmap_render_target_FillEllipse, + d2d_bitmap_render_target_DrawGeometry, + d2d_bitmap_render_target_FillGeometry, + d2d_bitmap_render_target_FillMesh, + d2d_bitmap_render_target_FillOpacityMask, + d2d_bitmap_render_target_DrawBitmap, + d2d_bitmap_render_target_DrawText, + d2d_bitmap_render_target_DrawTextLayout, + d2d_bitmap_render_target_DrawGlyphRun, + d2d_bitmap_render_target_SetTransform, + d2d_bitmap_render_target_GetTransform, + d2d_bitmap_render_target_SetAntialiasMode, + d2d_bitmap_render_target_GetAntialiasMode, + d2d_bitmap_render_target_SetTextAntialiasMode, + d2d_bitmap_render_target_GetTextAntialiasMode, + d2d_bitmap_render_target_SetTextRenderingParams, + d2d_bitmap_render_target_GetTextRenderingParams, + d2d_bitmap_render_target_SetTags, + d2d_bitmap_render_target_GetTags, + d2d_bitmap_render_target_PushLayer, + d2d_bitmap_render_target_PopLayer, + d2d_bitmap_render_target_Flush, + d2d_bitmap_render_target_SaveDrawingState, + d2d_bitmap_render_target_RestoreDrawingState, + d2d_bitmap_render_target_PushAxisAlignedClip, + d2d_bitmap_render_target_PopAxisAlignedClip, + d2d_bitmap_render_target_Clear, + d2d_bitmap_render_target_BeginDraw, + d2d_bitmap_render_target_EndDraw, + d2d_bitmap_render_target_GetPixelFormat, + d2d_bitmap_render_target_SetDpi, + d2d_bitmap_render_target_GetDpi, + d2d_bitmap_render_target_GetSize, + d2d_bitmap_render_target_GetPixelSize, + d2d_bitmap_render_target_GetMaximumBitmapSize, + d2d_bitmap_render_target_IsSupported, + d2d_bitmap_render_target_GetBitmap +}; + +static const struct d2d_device_context_ops d2d_bitmap_render_target_ops = +{ + NULL, +}; + +HRESULT d2d_bitmap_render_target_init(struct d2d_bitmap_render_target *render_target, + const struct d2d_device_context *parent_target, const D2D1_SIZE_F *size, + const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *pixel_format, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options) +{ + D2D1_RENDER_TARGET_PROPERTIES dxgi_rt_desc; + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + ID2D1DeviceContext *context; + D2D1_SIZE_U bitmap_size; + HRESULT hr; + + if (options) + FIXME("Compatible target options are ignored, %#x.\n", options); + + render_target->ID2D1BitmapRenderTarget_iface.lpVtbl = &d2d_bitmap_render_target_vtbl; + + dxgi_rt_desc.type = parent_target->desc.type; + dxgi_rt_desc.usage = parent_target->desc.usage; + dxgi_rt_desc.minLevel = parent_target->desc.minLevel; + + if (pixel_size) + { + bitmap_size.width = pixel_size->width; + bitmap_size.height = pixel_size->height; + } + else if (size) + { + bitmap_size.width = ceilf((size->width * parent_target->desc.dpiX) / 96.0f); + bitmap_size.height = ceilf((size->height * parent_target->desc.dpiY) / 96.0f); + } + else + { + bitmap_size.width = parent_target->pixel_size.width; + bitmap_size.height = parent_target->pixel_size.height; + } + + if (size && size->width != 0.0f && size->height != 0.0f) + { + dxgi_rt_desc.dpiX = (bitmap_size.width * 96.0f) / size->width; + dxgi_rt_desc.dpiY = (bitmap_size.height * 96.0f) / size->height; + } + else + { + dxgi_rt_desc.dpiX = parent_target->desc.dpiX; + dxgi_rt_desc.dpiY = parent_target->desc.dpiY; + } + + if (!pixel_format || pixel_format->format == DXGI_FORMAT_UNKNOWN) + dxgi_rt_desc.pixelFormat.format = parent_target->desc.pixelFormat.format; + else + dxgi_rt_desc.pixelFormat.format = pixel_format->format; + + if (!pixel_format || pixel_format->alphaMode == D2D1_ALPHA_MODE_UNKNOWN) + dxgi_rt_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED; + else + dxgi_rt_desc.pixelFormat.alphaMode = pixel_format->alphaMode; + + if (FAILED(hr = d2d_d3d_create_render_target(parent_target->device, NULL, + (IUnknown *)&render_target->ID2D1BitmapRenderTarget_iface, + parent_target->ops ? &d2d_bitmap_render_target_ops : NULL, + &dxgi_rt_desc, (void **)&render_target->dxgi_inner))) + { + WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr); + return hr; + } + + /* Note that we should be a little careful with the "dxgi_target" + * reference we get here. Because the object is aggregated, releasing the + * interface in any error paths below would end up calling + * d2d_bitmap_render_target_Release(). */ + if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner, + &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target))) + { + WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr); + IUnknown_Release(render_target->dxgi_inner); + return hr; + } + + bitmap_desc.pixelFormat = dxgi_rt_desc.pixelFormat; + bitmap_desc.dpiX = dxgi_rt_desc.dpiX; + bitmap_desc.dpiY = dxgi_rt_desc.dpiY; + bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET; + bitmap_desc.colorContext = NULL; + + ID2D1RenderTarget_QueryInterface(render_target->dxgi_target, &IID_ID2D1DeviceContext, (void **)&context); + hr = ID2D1DeviceContext_CreateBitmap(context, bitmap_size, NULL, 0, &bitmap_desc, + (ID2D1Bitmap1 **)&render_target->bitmap); + ID2D1DeviceContext_SetTarget(context, (ID2D1Image *)render_target->bitmap); + ID2D1DeviceContext_Release(context); + if (FAILED(hr)) + { + WARN("Failed to create target bitmap, hr %#lx.\n", hr); + IUnknown_Release(render_target->dxgi_inner); + return hr; + } + + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/brush.c b/WineFix/lib/d2d1/src/brush.c new file mode 100644 index 0000000..75cd72b --- /dev/null +++ b/WineFix/lib/d2d1/src/brush.c @@ -0,0 +1,1601 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_gradient *impl_from_ID2D1GradientStopCollection(ID2D1GradientStopCollection *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_gradient, ID2D1GradientStopCollection_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_gradient_QueryInterface(ID2D1GradientStopCollection *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1GradientStopCollection) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1GradientStopCollection_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_gradient_AddRef(ID2D1GradientStopCollection *iface) +{ + struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface); + ULONG refcount = InterlockedIncrement(&gradient->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_gradient_Release(ID2D1GradientStopCollection *iface) +{ + struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface); + ULONG refcount = InterlockedDecrement(&gradient->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + free(gradient->stops); + ID3D11ShaderResourceView_Release(gradient->view); + ID2D1Factory_Release(gradient->factory); + free(gradient); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_gradient_GetFactory(ID2D1GradientStopCollection *iface, ID2D1Factory **factory) +{ + struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = gradient->factory); +} + +static UINT32 STDMETHODCALLTYPE d2d_gradient_GetGradientStopCount(ID2D1GradientStopCollection *iface) +{ + struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface); + + TRACE("iface %p.\n", iface); + + return gradient->stop_count; +} + +static void STDMETHODCALLTYPE d2d_gradient_GetGradientStops(ID2D1GradientStopCollection *iface, + D2D1_GRADIENT_STOP *stops, UINT32 stop_count) +{ + struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface); + + TRACE("iface %p, stops %p, stop_count %u.\n", iface, stops, stop_count); + + memcpy(stops, gradient->stops, min(gradient->stop_count, stop_count) * sizeof(*stops)); +} + +static D2D1_GAMMA STDMETHODCALLTYPE d2d_gradient_GetColorInterpolationGamma(ID2D1GradientStopCollection *iface) +{ + FIXME("iface %p stub!\n", iface); + + return D2D1_GAMMA_1_0; +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_gradient_GetExtendMode(ID2D1GradientStopCollection *iface) +{ + FIXME("iface %p stub!\n", iface); + + return D2D1_EXTEND_MODE_CLAMP; +} + +static const struct ID2D1GradientStopCollectionVtbl d2d_gradient_vtbl = +{ + d2d_gradient_QueryInterface, + d2d_gradient_AddRef, + d2d_gradient_Release, + d2d_gradient_GetFactory, + d2d_gradient_GetGradientStopCount, + d2d_gradient_GetGradientStops, + d2d_gradient_GetColorInterpolationGamma, + d2d_gradient_GetExtendMode, +}; + +HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D11Device1 *device, const D2D1_GRADIENT_STOP *stops, + UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, struct d2d_gradient **out) +{ + D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc; + D3D11_SUBRESOURCE_DATA buffer_data; + ID3D11ShaderResourceView *view; + struct d2d_gradient *gradient; + D3D11_BUFFER_DESC buffer_desc; + struct d2d_vec4 *data; + ID3D11Buffer *buffer; + unsigned int i; + HRESULT hr; + + *out = NULL; + if (!(data = calloc(stop_count, 2 * sizeof(*data)))) + { + ERR("Failed to allocate data.\n"); + return E_OUTOFMEMORY; + } + + for (i = 0; i < stop_count; ++i) + { + data[i * 2].x = stops[i].position; + data[i * 2 + 1].x = stops[i].color.r; + data[i * 2 + 1].y = stops[i].color.g; + data[i * 2 + 1].z = stops[i].color.b; + data[i * 2 + 1].w = stops[i].color.a; + } + + buffer_desc.ByteWidth = 2 * stop_count * sizeof(*data); + buffer_desc.Usage = D3D11_USAGE_DEFAULT; + buffer_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + buffer_desc.CPUAccessFlags = 0; + buffer_desc.MiscFlags = 0; + + buffer_data.pSysMem = data; + buffer_data.SysMemPitch = 0; + buffer_data.SysMemSlicePitch = 0; + + hr = ID3D11Device1_CreateBuffer(device, &buffer_desc, &buffer_data, &buffer); + free(data); + if (FAILED(hr)) + { + ERR("Failed to create buffer, hr %#lx.\n", hr); + return hr; + } + + srv_desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + srv_desc.Buffer.ElementOffset = 0; + srv_desc.Buffer.ElementWidth = 2 * stop_count; + + hr = ID3D11Device1_CreateShaderResourceView(device, (ID3D11Resource *)buffer, &srv_desc, &view); + ID3D11Buffer_Release(buffer); + if (FAILED(hr)) + { + ERR("Failed to create view, hr %#lx.\n", hr); + return hr; + } + + if (!(gradient = calloc(1, sizeof(*gradient)))) + { + ID3D11ShaderResourceView_Release(view); + return E_OUTOFMEMORY; + } + + if (gamma != D2D1_GAMMA_2_2) + FIXME("Ignoring gamma %#x.\n", gamma); + if (extend_mode != D2D1_EXTEND_MODE_CLAMP) + FIXME("Ignoring extend mode %#x.\n", extend_mode); + + gradient->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl; + gradient->refcount = 1; + ID2D1Factory_AddRef(gradient->factory = factory); + gradient->view = view; + + gradient->stop_count = stop_count; + if (!(gradient->stops = calloc(stop_count, sizeof(*stops)))) + { + ID3D11ShaderResourceView_Release(view); + free(gradient); + return E_OUTOFMEMORY; + } + memcpy(gradient->stops, stops, stop_count * sizeof(*stops)); + + TRACE("Created gradient %p.\n", gradient); + *out = gradient; + return S_OK; +} + +static struct d2d_gradient *unsafe_impl_from_ID2D1GradientStopCollection(ID2D1GradientStopCollection *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d2d_gradient_vtbl); + return CONTAINING_RECORD(iface, struct d2d_gradient, ID2D1GradientStopCollection_iface); +} + +static void d2d_gradient_bind(struct d2d_gradient *gradient, ID3D11Device1 *device, unsigned int brush_idx) +{ + ID3D11DeviceContext *context; + ID3D11Device1_GetImmediateContext(device, &context); + ID3D11DeviceContext_PSSetShaderResources(context, 2 + brush_idx, 1, &gradient->view); + ID3D11DeviceContext_Release(context); +} + +static void d2d_brush_destroy(struct d2d_brush *brush) +{ + ID2D1Factory_Release(brush->factory); + free(brush); +} + +static void d2d_brush_init(struct d2d_brush *brush, ID2D1Factory *factory, + enum d2d_brush_type type, const D2D1_BRUSH_PROPERTIES *desc, const struct ID2D1BrushVtbl *vtbl) +{ + static const D2D1_MATRIX_3X2_F identity = + {{{ + 1.0f, 0.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, + }}}; + + brush->ID2D1Brush_iface.lpVtbl = vtbl; + brush->refcount = 1; + ID2D1Factory_AddRef(brush->factory = factory); + brush->opacity = desc ? desc->opacity : 1.0f; + brush->transform = desc ? desc->transform : identity; + brush->type = type; +} + +static inline struct d2d_brush *impl_from_ID2D1SolidColorBrush(ID2D1SolidColorBrush *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_solid_color_brush_QueryInterface(ID2D1SolidColorBrush *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1SolidColorBrush) + || IsEqualGUID(iid, &IID_ID2D1Brush) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1SolidColorBrush_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_AddRef(ID2D1SolidColorBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + ULONG refcount = InterlockedIncrement(&brush->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_Release(ID2D1SolidColorBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + ULONG refcount = InterlockedDecrement(&brush->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + d2d_brush_destroy(brush); + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_solid_color_brush_GetFactory(ID2D1SolidColorBrush *iface, ID2D1Factory **factory) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = brush->factory); +} + +static void STDMETHODCALLTYPE d2d_solid_color_brush_SetOpacity(ID2D1SolidColorBrush *iface, float opacity) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p, opacity %.8e.\n", iface, opacity); + + brush->opacity = opacity; +} + +static void STDMETHODCALLTYPE d2d_solid_color_brush_SetTransform(ID2D1SolidColorBrush *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + brush->transform = *transform; +} + +static float STDMETHODCALLTYPE d2d_solid_color_brush_GetOpacity(ID2D1SolidColorBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->opacity; +} + +static void STDMETHODCALLTYPE d2d_solid_color_brush_GetTransform(ID2D1SolidColorBrush *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = brush->transform; +} + +static void STDMETHODCALLTYPE d2d_solid_color_brush_SetColor(ID2D1SolidColorBrush *iface, const D2D1_COLOR_F *color) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p, color %p.\n", iface, color); + + brush->u.solid.color = *color; +} + +static D2D1_COLOR_F * STDMETHODCALLTYPE d2d_solid_color_brush_GetColor(ID2D1SolidColorBrush *iface, D2D1_COLOR_F *color) +{ + struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface); + + TRACE("iface %p, color %p.\n", iface, color); + + *color = brush->u.solid.color; + return color; +} + +static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl = +{ + d2d_solid_color_brush_QueryInterface, + d2d_solid_color_brush_AddRef, + d2d_solid_color_brush_Release, + d2d_solid_color_brush_GetFactory, + d2d_solid_color_brush_SetOpacity, + d2d_solid_color_brush_SetTransform, + d2d_solid_color_brush_GetOpacity, + d2d_solid_color_brush_GetTransform, + d2d_solid_color_brush_SetColor, + d2d_solid_color_brush_GetColor, +}; + +HRESULT d2d_solid_color_brush_create(ID2D1Factory *factory, const D2D1_COLOR_F *color, + const D2D1_BRUSH_PROPERTIES *desc, struct d2d_brush **brush) +{ + if (!(*brush = calloc(1, sizeof(**brush)))) + return E_OUTOFMEMORY; + + d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_SOLID, desc, + (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl); + (*brush)->u.solid.color = *color; + + TRACE("Created brush %p.\n", *brush); + return S_OK; +} + +static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush) + || IsEqualGUID(iid, &IID_ID2D1Brush) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1LinearGradientBrush_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + ULONG refcount = InterlockedIncrement(&brush->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + ULONG refcount = InterlockedDecrement(&brush->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1GradientStopCollection_Release(&brush->u.linear.gradient->ID2D1GradientStopCollection_iface); + d2d_brush_destroy(brush); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface, + ID2D1Factory **factory) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = brush->factory); +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, opacity %.8e.\n", iface, opacity); + + brush->opacity = opacity; +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + brush->transform = *transform; +} + +static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->opacity; +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = brush->transform; +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface, + D2D1_POINT_2F start_point) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, start_point %s.\n", iface, debug_d2d_point_2f(&start_point)); + + brush->u.linear.start = start_point; +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface, + D2D1_POINT_2F end_point) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, end_point %s.\n", iface, debug_d2d_point_2f(&end_point)); + + brush->u.linear.end = end_point; +} + +static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface, + D2D1_POINT_2F *point) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, point %p.\n", iface, point); + + *point = brush->u.linear.start; + return point; +} + +static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface, + D2D1_POINT_2F *point) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, point %p.\n", iface, point); + + *point = brush->u.linear.end; + return point; +} + +static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface, + ID2D1GradientStopCollection **gradient) +{ + struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); + + TRACE("iface %p, gradient %p.\n", iface, gradient); + + ID2D1GradientStopCollection_AddRef(*gradient = &brush->u.linear.gradient->ID2D1GradientStopCollection_iface); +} + +static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl = +{ + d2d_linear_gradient_brush_QueryInterface, + d2d_linear_gradient_brush_AddRef, + d2d_linear_gradient_brush_Release, + d2d_linear_gradient_brush_GetFactory, + d2d_linear_gradient_brush_SetOpacity, + d2d_linear_gradient_brush_SetTransform, + d2d_linear_gradient_brush_GetOpacity, + d2d_linear_gradient_brush_GetTransform, + d2d_linear_gradient_brush_SetStartPoint, + d2d_linear_gradient_brush_SetEndPoint, + d2d_linear_gradient_brush_GetStartPoint, + d2d_linear_gradient_brush_GetEndPoint, + d2d_linear_gradient_brush_GetGradientStopCollection, +}; + +HRESULT d2d_linear_gradient_brush_create(ID2D1Factory *factory, + const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, struct d2d_brush **brush) +{ + if (!(*brush = calloc(1, sizeof(**brush)))) + return E_OUTOFMEMORY; + + d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_LINEAR, brush_desc, + (ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl); + (*brush)->u.linear.gradient = unsafe_impl_from_ID2D1GradientStopCollection(gradient); + ID2D1GradientStopCollection_AddRef(&(*brush)->u.linear.gradient->ID2D1GradientStopCollection_iface); + (*brush)->u.linear.start = gradient_brush_desc->startPoint; + (*brush)->u.linear.end = gradient_brush_desc->endPoint; + + TRACE("Created brush %p.\n", *brush); + return S_OK; +} + +static inline struct d2d_brush *impl_from_ID2D1RadialGradientBrush(ID2D1RadialGradientBrush *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_radial_gradient_brush_QueryInterface(ID2D1RadialGradientBrush *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1RadialGradientBrush) + || IsEqualGUID(iid, &IID_ID2D1Brush) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1RadialGradientBrush_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_radial_gradient_brush_AddRef(ID2D1RadialGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + ULONG refcount = InterlockedIncrement(&brush->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_radial_gradient_brush_Release(ID2D1RadialGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + ULONG refcount = InterlockedDecrement(&brush->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1GradientStopCollection_Release(&brush->u.radial.gradient->ID2D1GradientStopCollection_iface); + d2d_brush_destroy(brush); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_GetFactory(ID2D1RadialGradientBrush *iface, + ID2D1Factory **factory) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = brush->factory); +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetOpacity(ID2D1RadialGradientBrush *iface, float opacity) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, opacity %.8e.\n", iface, opacity); + + brush->opacity = opacity; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetTransform(ID2D1RadialGradientBrush *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + brush->transform = *transform; +} + +static float STDMETHODCALLTYPE d2d_radial_gradient_brush_GetOpacity(ID2D1RadialGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->opacity; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_GetTransform(ID2D1RadialGradientBrush *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = brush->transform; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetCenter(ID2D1RadialGradientBrush *iface, + D2D1_POINT_2F centre) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, centre %s.\n", iface, debug_d2d_point_2f(¢re)); + + brush->u.radial.centre = centre; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetGradientOriginOffset(ID2D1RadialGradientBrush *iface, + D2D1_POINT_2F offset) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, offset %s.\n", iface, debug_d2d_point_2f(&offset)); + + brush->u.radial.offset = offset; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetRadiusX(ID2D1RadialGradientBrush *iface, float radius) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, radius %.8e.\n", iface, radius); + + brush->u.radial.radius.x = radius; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetRadiusY(ID2D1RadialGradientBrush *iface, float radius) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, radius %.8e.\n", iface, radius); + + brush->u.radial.radius.y = radius; +} + +static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_radial_gradient_brush_GetCenter(ID2D1RadialGradientBrush *iface, + D2D1_POINT_2F *centre) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, centre %p.\n", iface, centre); + + *centre = brush->u.radial.centre; + return centre; +} + +static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_radial_gradient_brush_GetGradientOriginOffset( + ID2D1RadialGradientBrush *iface, D2D1_POINT_2F *offset) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, offset %p.\n", iface, offset); + + *offset = brush->u.radial.offset; + return offset; +} + +static float STDMETHODCALLTYPE d2d_radial_gradient_brush_GetRadiusX(ID2D1RadialGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.radial.radius.x; +} + +static float STDMETHODCALLTYPE d2d_radial_gradient_brush_GetRadiusY(ID2D1RadialGradientBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.radial.radius.y; +} + +static void STDMETHODCALLTYPE d2d_radial_gradient_brush_GetGradientStopCollection(ID2D1RadialGradientBrush *iface, + ID2D1GradientStopCollection **gradient) +{ + struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); + + TRACE("iface %p, gradient %p.\n", iface, gradient); + + ID2D1GradientStopCollection_AddRef(*gradient = &brush->u.radial.gradient->ID2D1GradientStopCollection_iface); +} + +static const struct ID2D1RadialGradientBrushVtbl d2d_radial_gradient_brush_vtbl = +{ + d2d_radial_gradient_brush_QueryInterface, + d2d_radial_gradient_brush_AddRef, + d2d_radial_gradient_brush_Release, + d2d_radial_gradient_brush_GetFactory, + d2d_radial_gradient_brush_SetOpacity, + d2d_radial_gradient_brush_SetTransform, + d2d_radial_gradient_brush_GetOpacity, + d2d_radial_gradient_brush_GetTransform, + d2d_radial_gradient_brush_SetCenter, + d2d_radial_gradient_brush_SetGradientOriginOffset, + d2d_radial_gradient_brush_SetRadiusX, + d2d_radial_gradient_brush_SetRadiusY, + d2d_radial_gradient_brush_GetCenter, + d2d_radial_gradient_brush_GetGradientOriginOffset, + d2d_radial_gradient_brush_GetRadiusX, + d2d_radial_gradient_brush_GetRadiusY, + d2d_radial_gradient_brush_GetGradientStopCollection, +}; + +HRESULT d2d_radial_gradient_brush_create(ID2D1Factory *factory, + const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, struct d2d_brush **brush) +{ + struct d2d_brush *b; + + if (!(b = calloc(1, sizeof(*b)))) + return E_OUTOFMEMORY; + + d2d_brush_init(b, factory, D2D_BRUSH_TYPE_RADIAL, brush_desc, (ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl); + b->u.radial.gradient = unsafe_impl_from_ID2D1GradientStopCollection(gradient); + ID2D1GradientStopCollection_AddRef(&b->u.radial.gradient->ID2D1GradientStopCollection_iface); + b->u.radial.centre = gradient_desc->center; + b->u.radial.offset = gradient_desc->gradientOriginOffset; + b->u.radial.radius.x = gradient_desc->radiusX; + b->u.radial.radius.y = gradient_desc->radiusY; + + TRACE("Created brush %p.\n", b); + *brush = b; + + return S_OK; +} + +static inline struct d2d_brush *impl_from_ID2D1BitmapBrush1(ID2D1BitmapBrush1 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush1 *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush1) + || IsEqualGUID(iid, &IID_ID2D1BitmapBrush) + || IsEqualGUID(iid, &IID_ID2D1Brush) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1BitmapBrush1_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + ULONG refcount = InterlockedIncrement(&brush->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + ULONG refcount = InterlockedDecrement(&brush->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + if (brush->u.bitmap.bitmap) + ID2D1Bitmap1_Release(&brush->u.bitmap.bitmap->ID2D1Bitmap1_iface); + d2d_brush_destroy(brush); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush1 *iface, + ID2D1Factory **factory) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = brush->factory); +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush1 *iface, float opacity) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, opacity %.8e.\n", iface, opacity); + + brush->opacity = opacity; +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush1 *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + brush->transform = *transform; +} + +static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p.\n", iface); + + return brush->opacity; +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush1 *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = brush->transform; +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush1 *iface, D2D1_EXTEND_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + brush->u.bitmap.extend_mode_x = mode; +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush1 *iface, D2D1_EXTEND_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + brush->u.bitmap.extend_mode_y = mode; +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush1 *iface, + D2D1_BITMAP_INTERPOLATION_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + switch (mode) + { + case D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR: + case D2D1_BITMAP_INTERPOLATION_MODE_LINEAR: + break; + default: + WARN("Unknown interpolation mode %#x.\n", mode); + return; + } + + brush->u.bitmap.interpolation_mode = d2d1_1_interp_mode_from_d2d1(mode); +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush1 *iface, ID2D1Bitmap *bitmap) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, bitmap %p.\n", iface, bitmap); + + if (bitmap) + ID2D1Bitmap_AddRef(bitmap); + if (brush->u.bitmap.bitmap) + ID2D1Bitmap1_Release(&brush->u.bitmap.bitmap->ID2D1Bitmap1_iface); + brush->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap); +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.bitmap.extend_mode_x; +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.bitmap.extend_mode_y; +} + +static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p.\n", iface); + + switch (brush->u.bitmap.interpolation_mode) + { + case D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR: + return D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR; + case D2D1_INTERPOLATION_MODE_LINEAR: + default: + return D2D1_BITMAP_INTERPOLATION_MODE_LINEAR; + } +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush1 *iface, ID2D1Bitmap **bitmap) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, bitmap %p.\n", iface, bitmap); + + if ((*bitmap = (ID2D1Bitmap *)&brush->u.bitmap.bitmap->ID2D1Bitmap1_iface)) + ID2D1Bitmap_AddRef(*bitmap); +} + +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode1(ID2D1BitmapBrush1 *iface, + D2D1_INTERPOLATION_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + switch (mode) + { + case D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR: + case D2D1_INTERPOLATION_MODE_LINEAR: + break; + case D2D1_INTERPOLATION_MODE_CUBIC: + case D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR: + case D2D1_INTERPOLATION_MODE_ANISOTROPIC: + case D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC: + FIXME("Unhandled interpolation mode %#x.\n", mode); + break; + default: + WARN("Unknown interpolation mode %#x.\n", mode); + return; + } + + brush->u.bitmap.interpolation_mode = mode; +} + +static D2D1_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode1(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.bitmap.interpolation_mode; +} + +static const struct ID2D1BitmapBrush1Vtbl d2d_bitmap_brush_vtbl = +{ + d2d_bitmap_brush_QueryInterface, + d2d_bitmap_brush_AddRef, + d2d_bitmap_brush_Release, + d2d_bitmap_brush_GetFactory, + d2d_bitmap_brush_SetOpacity, + d2d_bitmap_brush_SetTransform, + d2d_bitmap_brush_GetOpacity, + d2d_bitmap_brush_GetTransform, + d2d_bitmap_brush_SetExtendModeX, + d2d_bitmap_brush_SetExtendModeY, + d2d_bitmap_brush_SetInterpolationMode, + d2d_bitmap_brush_SetBitmap, + d2d_bitmap_brush_GetExtendModeX, + d2d_bitmap_brush_GetExtendModeY, + d2d_bitmap_brush_GetInterpolationMode, + d2d_bitmap_brush_GetBitmap, + d2d_bitmap_brush_SetInterpolationMode1, + d2d_bitmap_brush_GetInterpolationMode1, +}; + +HRESULT d2d_bitmap_brush_create(ID2D1Factory *factory, ID2D1Bitmap *bitmap, + const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + struct d2d_brush **brush) +{ + if (!(*brush = calloc(1, sizeof(**brush)))) + return E_OUTOFMEMORY; + + d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_BITMAP, + brush_desc, (ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl); + if (((*brush)->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap))) + ID2D1Bitmap1_AddRef(&(*brush)->u.bitmap.bitmap->ID2D1Bitmap1_iface); + if (bitmap_brush_desc) + { + (*brush)->u.bitmap.extend_mode_x = bitmap_brush_desc->extendModeX; + (*brush)->u.bitmap.extend_mode_y = bitmap_brush_desc->extendModeY; + (*brush)->u.bitmap.interpolation_mode = bitmap_brush_desc->interpolationMode; + } + else + { + (*brush)->u.bitmap.extend_mode_x = D2D1_EXTEND_MODE_CLAMP; + (*brush)->u.bitmap.extend_mode_y = D2D1_EXTEND_MODE_CLAMP; + (*brush)->u.bitmap.interpolation_mode = D2D1_INTERPOLATION_MODE_LINEAR; + } + + TRACE("Created brush %p.\n", *brush); + return S_OK; +} + +static inline struct d2d_brush *impl_from_ID2D1ImageBrush(ID2D1ImageBrush *iface) +{ + return CONTAINING_RECORD((ID2D1Brush *)iface, struct d2d_brush, ID2D1Brush_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_image_brush_QueryInterface(ID2D1ImageBrush *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1ImageBrush) + || IsEqualGUID(iid, &IID_ID2D1Brush) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1ImageBrush_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_image_brush_AddRef(ID2D1ImageBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + ULONG refcount = InterlockedIncrement(&brush->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_image_brush_Release(ID2D1ImageBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + ULONG refcount = InterlockedDecrement(&brush->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + if (brush->u.image.image) + ID2D1Image_Release(brush->u.image.image); + d2d_brush_destroy(brush); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_image_brush_GetFactory(ID2D1ImageBrush *iface, + ID2D1Factory **factory) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = brush->factory); +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetOpacity(ID2D1ImageBrush *iface, float opacity) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, opacity %.8e.\n", iface, opacity); + + brush->opacity = opacity; +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetTransform(ID2D1ImageBrush *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + brush->transform = *transform; +} + +static float STDMETHODCALLTYPE d2d_image_brush_GetOpacity(ID2D1ImageBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->opacity; +} + +static void STDMETHODCALLTYPE d2d_image_brush_GetTransform(ID2D1ImageBrush *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = brush->transform; +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetImage(ID2D1ImageBrush *iface, ID2D1Image *image) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, image %p.\n", iface, image); + + if (image) + ID2D1Image_AddRef(image); + if (brush->u.image.image) + ID2D1Image_Release(brush->u.image.image); + brush->u.image.image = image; +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetExtendModeX(ID2D1ImageBrush *iface, D2D1_EXTEND_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + brush->u.image.extend_mode_x = mode; +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetExtendModeY(ID2D1ImageBrush *iface, D2D1_EXTEND_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + brush->u.image.extend_mode_y = mode; +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetInterpolationMode(ID2D1ImageBrush *iface, + D2D1_INTERPOLATION_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + brush->u.image.interpolation_mode = mode; +} + +static void STDMETHODCALLTYPE d2d_image_brush_SetSourceRectangle(ID2D1ImageBrush *iface, const D2D1_RECT_F *rect) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, rect %s.\n", iface, debug_d2d_rect_f(rect)); + + brush->u.image.source_rect = *rect; +} + +static void STDMETHODCALLTYPE d2d_image_brush_GetImage(ID2D1ImageBrush *iface, ID2D1Image **image) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, image %p.\n", iface, image); + + if ((*image = brush->u.image.image)) + ID2D1Image_AddRef(*image); +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_image_brush_GetExtendModeX(ID2D1ImageBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.image.extend_mode_x; +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_image_brush_GetExtendModeY(ID2D1ImageBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.image.extend_mode_y; +} + +static D2D1_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_image_brush_GetInterpolationMode(ID2D1ImageBrush *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.image.interpolation_mode; +} + +static void STDMETHODCALLTYPE d2d_image_brush_GetSourceRectangle(ID2D1ImageBrush *iface, D2D1_RECT_F *rect) +{ + struct d2d_brush *brush = impl_from_ID2D1ImageBrush(iface); + + TRACE("iface %p, rect %p.\n", iface, rect); + + *rect = brush->u.image.source_rect; +} + +static const struct ID2D1ImageBrushVtbl d2d_image_brush_vtbl = +{ + d2d_image_brush_QueryInterface, + d2d_image_brush_AddRef, + d2d_image_brush_Release, + d2d_image_brush_GetFactory, + d2d_image_brush_SetOpacity, + d2d_image_brush_SetTransform, + d2d_image_brush_GetOpacity, + d2d_image_brush_GetTransform, + d2d_image_brush_SetImage, + d2d_image_brush_SetExtendModeX, + d2d_image_brush_SetExtendModeY, + d2d_image_brush_SetInterpolationMode, + d2d_image_brush_SetSourceRectangle, + d2d_image_brush_GetImage, + d2d_image_brush_GetExtendModeX, + d2d_image_brush_GetExtendModeY, + d2d_image_brush_GetInterpolationMode, + d2d_image_brush_GetSourceRectangle +}; + +HRESULT d2d_image_brush_create(ID2D1Factory *factory, ID2D1Image *image, + const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + struct d2d_brush **brush) +{ + if (!(*brush = calloc(1, sizeof(**brush)))) + return E_OUTOFMEMORY; + + d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_IMAGE, + brush_desc, (ID2D1BrushVtbl *)&d2d_image_brush_vtbl); + if (((*brush)->u.image.image = image)) + ID2D1Image_AddRef((*brush)->u.image.image); + + (*brush)->u.image.source_rect = image_brush_desc->sourceRectangle; + (*brush)->u.image.extend_mode_x = image_brush_desc->extendModeX; + (*brush)->u.image.extend_mode_y = image_brush_desc->extendModeY; + (*brush)->u.image.interpolation_mode = image_brush_desc->interpolationMode; + + TRACE("Created brush %p.\n", *brush); + return S_OK; +} + +struct d2d_brush *unsafe_impl_from_ID2D1Brush(ID2D1Brush *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl + || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl + || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl + || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl + || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_image_brush_vtbl); + return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface); +} + +static D3D11_TEXTURE_ADDRESS_MODE texture_address_mode_from_extend_mode(D2D1_EXTEND_MODE mode) +{ + switch (mode) + { + case D2D1_EXTEND_MODE_CLAMP: + return D3D11_TEXTURE_ADDRESS_CLAMP; + case D2D1_EXTEND_MODE_WRAP: + return D3D11_TEXTURE_ADDRESS_WRAP; + case D2D1_EXTEND_MODE_MIRROR: + return D3D11_TEXTURE_ADDRESS_MIRROR; + default: + FIXME("Unhandled extend mode %#x.\n", mode); + return D3D11_TEXTURE_ADDRESS_CLAMP; + } +} + +BOOL d2d_brush_fill_cb(const struct d2d_brush *brush, struct d2d_brush_cb *cb) +{ + float theta, sin_theta, cos_theta; + float dpi_scale, d, s1, s2, t, u; + struct d2d_bitmap *bitmap; + D2D1_POINT_2F v_p, v_q; + D2D1_COLOR_F *colour; + D2D_MATRIX_3X2_F b; + + if (!brush) + { + cb->type = D2D_BRUSH_TYPE_COUNT; + return TRUE; + } + + cb->type = brush->type; + cb->opacity = brush->opacity; + + switch (brush->type) + { + case D2D_BRUSH_TYPE_SOLID: + colour = &cb->u.solid.colour; + + *colour = brush->u.solid.color; + colour->r *= colour->a; + colour->g *= colour->a; + colour->b *= colour->a; + + return TRUE; + + case D2D_BRUSH_TYPE_LINEAR: + b = brush->transform; + d2d_point_transform(&cb->u.linear.start, &b, brush->u.linear.start.x, brush->u.linear.start.y); + d2d_point_transform(&cb->u.linear.end, &b, brush->u.linear.end.x, brush->u.linear.end.y); + cb->u.linear.stop_count = brush->u.linear.gradient->stop_count; + + return TRUE; + + case D2D_BRUSH_TYPE_RADIAL: + b = brush->transform; + d2d_point_transform(&cb->u.radial.centre, &b, brush->u.radial.centre.x, brush->u.radial.centre.y); + b._31 = b._32 = 0.0f; + d2d_point_transform(&cb->u.radial.offset, &b, brush->u.radial.offset.x, brush->u.radial.offset.y); + + /* After a transformation, the axes of the ellipse are no longer + * necessarily orthogonal, but they are conjugate diameters. + * + * A = ⎡a.x b.x⎤ + * ⎣a.y b.y⎦ + * + * = ⎡cos(θ) -sin(θ)⎤⎡σ₁ 0 ⎤⎡cos(φ) -sin(φ)⎤ + * ⎣sin(θ) cos(θ)⎦⎣0 σ₂⎦⎣sin(φ) cos(φ)⎦ + * + * a' = [σ₁· cos(θ) σ₁·sin(θ)] + * b' = [σ₂·-sin(θ) σ₂·cos(θ)] */ + + d2d_point_set(&v_p, brush->u.radial.radius.x * b._11, brush->u.radial.radius.y * b._21); + d2d_point_set(&v_q, brush->u.radial.radius.x * b._12, brush->u.radial.radius.y * b._22); + + t = 0.5f * d2d_point_dot(&v_p, &v_p); + u = 0.5f * d2d_point_dot(&v_q, &v_q); + s1 = t + u; + + t = t - u; + u = d2d_point_dot(&v_p, &v_q); + s2 = sqrtf(t * t + u * u); + + theta = 0.5f * atan2(u, t); + sin_theta = sinf(theta); + cos_theta = cosf(theta); + + t = sqrtf(s1 + s2); + d2d_point_set(&cb->u.radial.ra, t * cos_theta, t * sin_theta); + t = sqrtf(s1 - s2); + d2d_point_set(&cb->u.radial.rb, t * -sin_theta, t * cos_theta); + + cb->u.radial.stop_count = brush->u.linear.gradient->stop_count; + + return TRUE; + + case D2D_BRUSH_TYPE_BITMAP: + case D2D_BRUSH_TYPE_IMAGE: + { + ID2D1Bitmap *image_bitmap = NULL; + + if (brush->type == D2D_BRUSH_TYPE_BITMAP) + bitmap = brush->u.bitmap.bitmap; + else + { + if (FAILED(ID2D1Image_QueryInterface(brush->u.image.image, &IID_ID2D1Bitmap, (void **)&image_bitmap))) + { + FIXME("Only image brushes with bitmaps are supported.\n"); + return FALSE; + } + + bitmap = unsafe_impl_from_ID2D1Bitmap(image_bitmap); + cb->type = D2D_BRUSH_TYPE_BITMAP; + } + + /* Scale for bitmap size and dpi. */ + b = brush->transform; + dpi_scale = bitmap->pixel_size.width * (96.0f / bitmap->dpi_x); + b._11 *= dpi_scale; + b._21 *= dpi_scale; + dpi_scale = bitmap->pixel_size.height * (96.0f / bitmap->dpi_y); + b._12 *= dpi_scale; + b._22 *= dpi_scale; + + /* Invert the matrix. (Because the matrix is applied to the + * sampling coordinates. I.e., to scale the bitmap by 2 we need to + * divide the coordinates by 2.) */ + d = b._11 * b._22 - b._21 * b._12; + if (d != 0.0f) + { + cb->u.bitmap._11 = b._22 / d; + cb->u.bitmap._21 = -b._21 / d; + cb->u.bitmap._31 = (b._21 * b._32 - b._31 * b._22) / d; + cb->u.bitmap._12 = -b._12 / d; + cb->u.bitmap._22 = b._11 / d; + cb->u.bitmap._32 = -(b._11 * b._32 - b._31 * b._12) / d; + } + + cb->u.bitmap.ignore_alpha = bitmap->format.alphaMode == D2D1_ALPHA_MODE_IGNORE; + + if (image_bitmap) + ID2D1Bitmap_Release(image_bitmap); + + return TRUE; + } + + default: + FIXME("Unhandled brush type %#x.\n", brush->type); + return FALSE; + } +} + +static void d2d_brush_bind_bitmap(struct d2d_bitmap *bitmap, struct d2d_device_context *context, + D2D1_EXTEND_MODE extend_mode_x, D2D1_EXTEND_MODE extend_mode_y, + D2D1_INTERPOLATION_MODE interpolation_mode, unsigned int brush_idx) +{ + ID3D11SamplerState **sampler_state; + ID3D11DeviceContext *d3d_context; + HRESULT hr; + + ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context); + ID3D11DeviceContext_PSSetShaderResources(d3d_context, brush_idx, 1, &bitmap->srv); + + sampler_state = &context->sampler_states + [interpolation_mode % D2D_SAMPLER_INTERPOLATION_MODE_COUNT] + [extend_mode_x % D2D_SAMPLER_EXTEND_MODE_COUNT] + [extend_mode_y % D2D_SAMPLER_EXTEND_MODE_COUNT]; + + if (!*sampler_state) + { + D3D11_SAMPLER_DESC sampler_desc; + + if (interpolation_mode == D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR) + sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; + else + sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + sampler_desc.AddressU = texture_address_mode_from_extend_mode(extend_mode_x); + sampler_desc.AddressV = texture_address_mode_from_extend_mode(extend_mode_y); + sampler_desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + sampler_desc.MipLODBias = 0.0f; + sampler_desc.MaxAnisotropy = 0; + sampler_desc.ComparisonFunc = D3D11_COMPARISON_NEVER; + sampler_desc.BorderColor[0] = 0.0f; + sampler_desc.BorderColor[1] = 0.0f; + sampler_desc.BorderColor[2] = 0.0f; + sampler_desc.BorderColor[3] = 0.0f; + sampler_desc.MinLOD = 0.0f; + sampler_desc.MaxLOD = 0.0f; + + if (FAILED(hr = ID3D11Device1_CreateSamplerState(context->d3d_device, &sampler_desc, sampler_state))) + ERR("Failed to create sampler state, hr %#lx.\n", hr); + } + + ID3D11DeviceContext_PSSetSamplers(d3d_context, brush_idx, 1, sampler_state); + ID3D11DeviceContext_Release(d3d_context); +} + +static void d2d_brush_bind_image(struct d2d_brush *brush, struct d2d_device_context *context, + unsigned int brush_idx) +{ + ID2D1Bitmap *image_bitmap; + struct d2d_bitmap *bitmap; + + if (FAILED(ID2D1Image_QueryInterface(brush->u.image.image, &IID_ID2D1Bitmap, (void **)&image_bitmap))) + { + FIXME("Only image brushes with bitmaps are supported.\n"); + return; + } + + bitmap = unsafe_impl_from_ID2D1Bitmap(image_bitmap); + + d2d_brush_bind_bitmap(bitmap, context, brush->u.image.extend_mode_x, brush->u.image.extend_mode_y, + brush->u.image.interpolation_mode, brush_idx); + + ID2D1Bitmap_Release(image_bitmap); +} + +void d2d_brush_bind_resources(struct d2d_brush *brush, struct d2d_device_context *context, unsigned int brush_idx) +{ + switch (brush->type) + { + case D2D_BRUSH_TYPE_SOLID: + break; + + case D2D_BRUSH_TYPE_LINEAR: + d2d_gradient_bind(brush->u.linear.gradient, context->d3d_device, brush_idx); + break; + + case D2D_BRUSH_TYPE_RADIAL: + d2d_gradient_bind(brush->u.radial.gradient, context->d3d_device, brush_idx); + break; + + case D2D_BRUSH_TYPE_BITMAP: + d2d_brush_bind_bitmap(brush->u.bitmap.bitmap, context, brush->u.bitmap.extend_mode_x, + brush->u.bitmap.extend_mode_y, brush->u.bitmap.interpolation_mode, brush_idx); + break; + + case D2D_BRUSH_TYPE_IMAGE: + d2d_brush_bind_image(brush, context, brush_idx); + break; + + default: + FIXME("Unhandled brush type %#x.\n", brush->type); + break; + } +} diff --git a/WineFix/lib/d2d1/src/command_list.c b/WineFix/lib/d2d1/src/command_list.c new file mode 100644 index 0000000..27c2bf3 --- /dev/null +++ b/WineFix/lib/d2d1/src/command_list.c @@ -0,0 +1,1102 @@ +/* + * Copyright 2022 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +enum d2d_command_list_flags +{ + D2D_COMMAND_LIST_HAS_NULL_TEXT_RENDERING_PARAMS = 0x1, +}; + +enum d2d_command_type +{ + D2D_COMMAND_SET_ANTIALIAS_MODE, + D2D_COMMAND_SET_TAGS, + D2D_COMMAND_SET_TEXT_ANTIALIAS_MODE, + D2D_COMMAND_SET_TEXT_RENDERING_PARAMS, + D2D_COMMAND_SET_TRANSFORM, + D2D_COMMAND_SET_PRIMITIVE_BLEND, + D2D_COMMAND_SET_UNIT_MODE, + D2D_COMMAND_CLEAR, + D2D_COMMAND_DRAW_GLYPH_RUN, + D2D_COMMAND_DRAW_LINE, + D2D_COMMAND_DRAW_GEOMETRY, + D2D_COMMAND_DRAW_RECTANGLE, + D2D_COMMAND_DRAW_BITMAP, + D2D_COMMAND_DRAW_IMAGE, + D2D_COMMAND_FILL_MESH, + D2D_COMMAND_FILL_OPACITY_MASK, + D2D_COMMAND_FILL_GEOMETRY, + D2D_COMMAND_FILL_RECTANGLE, + D2D_COMMAND_PUSH_CLIP, + D2D_COMMAND_PUSH_LAYER, + D2D_COMMAND_POP_CLIP, + D2D_COMMAND_POP_LAYER, +}; + +struct d2d_command +{ + enum d2d_command_type op; + size_t size; +}; + +struct d2d_command_set_antialias_mode +{ + struct d2d_command c; + D2D1_ANTIALIAS_MODE mode; +}; + +struct d2d_command_set_tags +{ + struct d2d_command c; + D2D1_TAG tag1, tag2; +}; + +struct d2d_command_set_text_antialias_mode +{ + struct d2d_command c; + D2D1_TEXT_ANTIALIAS_MODE mode; +}; + +struct d2d_command_set_text_rendering_params +{ + struct d2d_command c; + IDWriteRenderingParams *params; +}; + +struct d2d_command_set_transform +{ + struct d2d_command c; + D2D1_MATRIX_3X2_F transform; +}; + +struct d2d_command_set_primitive_blend +{ + struct d2d_command c; + D2D1_PRIMITIVE_BLEND primitive_blend; +}; + +struct d2d_command_set_unit_mode +{ + struct d2d_command c; + D2D1_UNIT_MODE mode; +}; + +struct d2d_command_clear +{ + struct d2d_command c; + D2D1_COLOR_F color; +}; + +struct d2d_command_push_clip +{ + struct d2d_command c; + D2D1_RECT_F rect; + D2D1_ANTIALIAS_MODE mode; +}; + +struct d2d_command_push_layer +{ + struct d2d_command c; + D2D1_LAYER_PARAMETERS1 params; + ID2D1Layer *layer; +}; + +struct d2d_command_draw_line +{ + struct d2d_command c; + D2D1_POINT_2F p0, p1; + ID2D1Brush *brush; + float stroke_width; + ID2D1StrokeStyle *stroke_style; +}; + +struct d2d_command_draw_geometry +{ + struct d2d_command c; + ID2D1Geometry *geometry; + ID2D1Brush *brush; + float stroke_width; + ID2D1StrokeStyle *stroke_style; +}; + +struct d2d_command_draw_rectangle +{ + struct d2d_command c; + D2D1_RECT_F rect; + ID2D1Brush *brush; + float stroke_width; + ID2D1StrokeStyle *stroke_style; +}; + +struct d2d_command_fill_mesh +{ + struct d2d_command c; + ID2D1Mesh *mesh; + ID2D1Brush *brush; +}; + +struct d2d_command_fill_opacity_mask +{ + struct d2d_command c; + ID2D1Bitmap *bitmap; + ID2D1Brush *brush; + D2D1_RECT_F *dst_rect; + D2D1_RECT_F *src_rect; +}; + +struct d2d_command_fill_geometry +{ + struct d2d_command c; + ID2D1Geometry *geometry; + ID2D1Brush *brush; + ID2D1Brush *opacity_brush; +}; + +struct d2d_command_fill_rectangle +{ + struct d2d_command c; + D2D1_RECT_F rect; + ID2D1Brush *brush; +}; + +struct d2d_command_draw_glyph_run +{ + struct d2d_command c; + D2D1_POINT_2F origin; + DWRITE_MEASURING_MODE measuring_mode; + ID2D1Brush *brush; + DWRITE_GLYPH_RUN run; + DWRITE_GLYPH_RUN_DESCRIPTION *run_desc; +}; + +struct d2d_command_draw_bitmap +{ + struct d2d_command c; + float opacity; + D2D1_INTERPOLATION_MODE interpolation_mode; + ID2D1Bitmap *bitmap; + D2D1_RECT_F *dst_rect; + D2D1_RECT_F *src_rect; + D2D1_MATRIX_4X4_F *perspective_transform; +}; + +struct d2d_command_draw_image +{ + struct d2d_command c; + ID2D1Image *image; + D2D1_INTERPOLATION_MODE interpolation_mode; + D2D1_COMPOSITE_MODE composite_mode; + D2D1_POINT_2F *target_offset; + D2D1_RECT_F *image_rect; +}; + +static inline struct d2d_command_list *impl_from_ID2D1CommandList(ID2D1CommandList *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_command_list, ID2D1CommandList_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_command_list_QueryInterface(ID2D1CommandList *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1CommandList) + || IsEqualGUID(iid, &IID_ID2D1Image) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1CommandList_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_command_list_AddRef(ID2D1CommandList *iface) +{ + struct d2d_command_list *command_list = impl_from_ID2D1CommandList(iface); + ULONG refcount = InterlockedIncrement(&command_list->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_command_list_Release(ID2D1CommandList *iface) +{ + struct d2d_command_list *command_list = impl_from_ID2D1CommandList(iface); + ULONG refcount = InterlockedDecrement(&command_list->refcount); + size_t i; + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1Factory_Release(command_list->factory); + for (i = 0; i < command_list->objects_count; ++i) + IUnknown_Release(command_list->objects[i]); + free(command_list->objects); + free(command_list->data); + free(command_list); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_command_list_GetFactory(ID2D1CommandList *iface, ID2D1Factory **factory) +{ + struct d2d_command_list *command_list = impl_from_ID2D1CommandList(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = command_list->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_command_list_Stream(ID2D1CommandList *iface, ID2D1CommandSink *sink) +{ + struct d2d_command_list *command_list = impl_from_ID2D1CommandList(iface); + const void *data, *end; + HRESULT hr; + + TRACE("iface %p, sink %p.\n", iface, sink); + + if (command_list->state != D2D_COMMAND_LIST_STATE_CLOSED) return S_OK; + + if (FAILED(hr = ID2D1CommandSink_BeginDraw(sink))) + return hr; + + data = command_list->data; + end = (char *)command_list->data + command_list->size; + while (data < end) + { + const struct d2d_command *command = data; + + switch (command->op) + { + case D2D_COMMAND_SET_ANTIALIAS_MODE: + { + const struct d2d_command_set_antialias_mode *c = data; + hr = ID2D1CommandSink_SetAntialiasMode(sink, c->mode); + break; + } + case D2D_COMMAND_SET_TAGS: + { + const struct d2d_command_set_tags *c = data; + hr = ID2D1CommandSink_SetTags(sink, c->tag1, c->tag2); + break; + } + case D2D_COMMAND_SET_TEXT_ANTIALIAS_MODE: + { + const struct d2d_command_set_text_antialias_mode *c = data; + hr = ID2D1CommandSink_SetTextAntialiasMode(sink, c->mode); + break; + } + case D2D_COMMAND_SET_TEXT_RENDERING_PARAMS: + { + const struct d2d_command_set_text_rendering_params *c = data; + hr = ID2D1CommandSink_SetTextRenderingParams(sink, c->params); + break; + } + case D2D_COMMAND_SET_TRANSFORM: + { + const struct d2d_command_set_transform *c = data; + hr = ID2D1CommandSink_SetTransform(sink, &c->transform); + break; + } + case D2D_COMMAND_SET_PRIMITIVE_BLEND: + { + const struct d2d_command_set_primitive_blend *c = data; + ID2D1CommandSink1 *sink1; + ID2D1CommandSink4 *sink4; + + switch (c->primitive_blend) + { + case D2D1_PRIMITIVE_BLEND_SOURCE_OVER: + case D2D1_PRIMITIVE_BLEND_COPY: + hr = ID2D1CommandSink_SetPrimitiveBlend(sink, c->primitive_blend); + break; + case D2D1_PRIMITIVE_BLEND_MIN: + case D2D1_PRIMITIVE_BLEND_ADD: + if (SUCCEEDED(ID2D1CommandSink_QueryInterface(sink, &IID_ID2D1CommandSink1, (void **)&sink1))) + { + hr = ID2D1CommandSink1_SetPrimitiveBlend1(sink1, c->primitive_blend); + ID2D1CommandSink1_Release(sink1); + } + else + hr = ID2D1CommandSink_SetPrimitiveBlend(sink, D2D1_PRIMITIVE_BLEND_SOURCE_OVER); + break; + case D2D1_PRIMITIVE_BLEND_MAX: + if (SUCCEEDED(ID2D1CommandSink_QueryInterface(sink, &IID_ID2D1CommandSink4, (void **)&sink4))) + { + hr = ID2D1CommandSink4_SetPrimitiveBlend2(sink4, c->primitive_blend); + ID2D1CommandSink4_Release(sink4); + } + else + hr = ID2D1CommandSink_SetPrimitiveBlend(sink, D2D1_PRIMITIVE_BLEND_SOURCE_OVER); + break; + default: + FIXME("Unexpected blend mode %u.\n", c->primitive_blend); + hr = E_UNEXPECTED; + } + break; + } + case D2D_COMMAND_SET_UNIT_MODE: + { + const struct d2d_command_set_unit_mode *c = data; + hr = ID2D1CommandSink_SetUnitMode(sink, c->mode); + break; + } + case D2D_COMMAND_CLEAR: + { + const struct d2d_command_clear *c = data; + hr = ID2D1CommandSink_Clear(sink, &c->color); + break; + } + case D2D_COMMAND_DRAW_GLYPH_RUN: + { + const struct d2d_command_draw_glyph_run *c = data; + hr = ID2D1CommandSink_DrawGlyphRun(sink, c->origin, &c->run, c->run_desc, c->brush, c->measuring_mode); + break; + } + case D2D_COMMAND_DRAW_LINE: + { + const struct d2d_command_draw_line *c = data; + hr = ID2D1CommandSink_DrawLine(sink, c->p0, c->p1, c->brush, c->stroke_width, + c->stroke_style); + break; + } + case D2D_COMMAND_DRAW_GEOMETRY: + { + const struct d2d_command_draw_geometry *c = data; + hr = ID2D1CommandSink_DrawGeometry(sink, c->geometry, c->brush, c->stroke_width, + c->stroke_style); + break; + } + case D2D_COMMAND_DRAW_RECTANGLE: + { + const struct d2d_command_draw_rectangle *c = data; + hr = ID2D1CommandSink_DrawRectangle(sink, &c->rect, c->brush, c->stroke_width, + c->stroke_style); + break; + } + case D2D_COMMAND_DRAW_BITMAP: + { + const struct d2d_command_draw_bitmap *c = data; + hr = ID2D1CommandSink_DrawBitmap(sink, c->bitmap, c->dst_rect, c->opacity, + c->interpolation_mode, c->src_rect, c->perspective_transform); + break; + } + case D2D_COMMAND_DRAW_IMAGE: + { + const struct d2d_command_draw_image *c = data; + hr = ID2D1CommandSink_DrawImage(sink, c->image, c->target_offset, c->image_rect, + c->interpolation_mode, c->composite_mode); + break; + } + case D2D_COMMAND_FILL_MESH: + { + const struct d2d_command_fill_mesh *c = data; + hr = ID2D1CommandSink_FillMesh(sink, c->mesh, c->brush); + break; + } + case D2D_COMMAND_FILL_OPACITY_MASK: + { + const struct d2d_command_fill_opacity_mask *c = data; + hr = ID2D1CommandSink_FillOpacityMask(sink, c->bitmap, c->brush, c->dst_rect, c->src_rect); + break; + } + case D2D_COMMAND_FILL_GEOMETRY: + { + const struct d2d_command_fill_geometry *c = data; + hr = ID2D1CommandSink_FillGeometry(sink, c->geometry, c->brush, c->opacity_brush); + break; + } + case D2D_COMMAND_FILL_RECTANGLE: + { + const struct d2d_command_fill_rectangle *c = data; + hr = ID2D1CommandSink_FillRectangle(sink, &c->rect, c->brush); + break; + } + case D2D_COMMAND_PUSH_CLIP: + { + const struct d2d_command_push_clip *c = data; + hr = ID2D1CommandSink_PushAxisAlignedClip(sink, &c->rect, c->mode); + break; + } + case D2D_COMMAND_PUSH_LAYER: + { + const struct d2d_command_push_layer *c = data; + hr = ID2D1CommandSink_PushLayer(sink, &c->params, c->layer); + break; + } + case D2D_COMMAND_POP_CLIP: + hr = ID2D1CommandSink_PopAxisAlignedClip(sink); + break; + case D2D_COMMAND_POP_LAYER: + hr = ID2D1CommandSink_PopLayer(sink); + break; + default: + FIXME("Unhandled command %u.\n", command->op); + hr = E_UNEXPECTED; + } + + if (FAILED(hr)) return hr; + + data = (char *)data + command->size; + } + + return ID2D1CommandSink_EndDraw(sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_command_list_Close(ID2D1CommandList *iface) +{ + struct d2d_command_list *command_list = impl_from_ID2D1CommandList(iface); + + FIXME("iface %p stub.\n", iface); + + if (command_list->state != D2D_COMMAND_LIST_STATE_OPEN) + return D2DERR_WRONG_STATE; + + command_list->state = D2D_COMMAND_LIST_STATE_CLOSED; + + /* FIXME: reset as a target */ + + return S_OK; +} + +static const ID2D1CommandListVtbl d2d_command_list_vtbl = +{ + d2d_command_list_QueryInterface, + d2d_command_list_AddRef, + d2d_command_list_Release, + d2d_command_list_GetFactory, + d2d_command_list_Stream, + d2d_command_list_Close, +}; + +HRESULT d2d_command_list_create(ID2D1Factory *factory, struct d2d_command_list **command_list) +{ + if (!(*command_list = calloc(1, sizeof(**command_list)))) + return E_OUTOFMEMORY; + + (*command_list)->ID2D1CommandList_iface.lpVtbl = &d2d_command_list_vtbl; + (*command_list)->refcount = 1; + ID2D1Factory_AddRef((*command_list)->factory = factory); + + TRACE("Created command list %p.\n", *command_list); + + return S_OK; +} + +struct d2d_command_list *unsafe_impl_from_ID2D1CommandList(ID2D1CommandList *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (ID2D1CommandListVtbl *)&d2d_command_list_vtbl); + return CONTAINING_RECORD(iface, struct d2d_command_list, ID2D1CommandList_iface); +} + +static void * d2d_command_list_require_space(struct d2d_command_list *command_list, size_t size) +{ + struct d2d_command *command; + + if (!d2d_array_reserve(&command_list->data, &command_list->capacity, command_list->size + size, 1)) + return NULL; + + command = (struct d2d_command *)((char *)command_list->data + command_list->size); + command->size = size; + + command_list->size += size; + + return command; +} + +static void d2d_command_list_reference_object(struct d2d_command_list *command_list, void *object) +{ + IUnknown *obj = object; + + if (!obj) return; + + if (!d2d_array_reserve((void **)&command_list->objects, &command_list->objects_capacity, + command_list->objects_count + 1, sizeof(*command_list->objects))) + { + return; + } + + command_list->objects[command_list->objects_count++] = obj; + IUnknown_AddRef(obj); +} + +static HRESULT d2d_command_list_create_brush(struct d2d_command_list *command_list, + const struct d2d_device_context *ctx, ID2D1Brush *orig_brush, ID2D1Brush **ret) +{ + ID2D1DeviceContext *context = (ID2D1DeviceContext *)&ctx->ID2D1DeviceContext6_iface; + struct d2d_brush *brush = unsafe_impl_from_ID2D1Brush(orig_brush); + D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES linear_properties; + D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES radial_properties; + D2D1_BITMAP_BRUSH_PROPERTIES1 bitmap_properties; + D2D1_IMAGE_BRUSH_PROPERTIES image_properties; + D2D1_BRUSH_PROPERTIES properties; + HRESULT hr; + + properties.opacity = brush->opacity; + properties.transform = brush->transform; + + switch (brush->type) + { + case D2D_BRUSH_TYPE_SOLID: + hr = ID2D1DeviceContext_CreateSolidColorBrush(context, &brush->u.solid.color, + &properties, (ID2D1SolidColorBrush **)ret); + break; + case D2D_BRUSH_TYPE_LINEAR: + linear_properties.startPoint = brush->u.linear.start; + linear_properties.endPoint = brush->u.linear.end; + hr = ID2D1DeviceContext_CreateLinearGradientBrush(context, &linear_properties, + &properties, &brush->u.linear.gradient->ID2D1GradientStopCollection_iface, + (ID2D1LinearGradientBrush **)ret); + break; + case D2D_BRUSH_TYPE_RADIAL: + radial_properties.center = brush->u.radial.centre; + radial_properties.gradientOriginOffset = brush->u.radial.offset; + radial_properties.radiusX = brush->u.radial.radius.x; + radial_properties.radiusY = brush->u.radial.radius.y; + hr = ID2D1DeviceContext_CreateRadialGradientBrush(context, &radial_properties, + &properties, &brush->u.radial.gradient->ID2D1GradientStopCollection_iface, + (ID2D1RadialGradientBrush **)ret); + break; + case D2D_BRUSH_TYPE_BITMAP: + bitmap_properties.extendModeX = brush->u.bitmap.extend_mode_x; + bitmap_properties.extendModeY = brush->u.bitmap.extend_mode_y; + bitmap_properties.interpolationMode = brush->u.bitmap.interpolation_mode; + hr = ID2D1DeviceContext_CreateBitmapBrush(context, (ID2D1Bitmap *)&brush->u.bitmap.bitmap->ID2D1Bitmap1_iface, + &bitmap_properties, &properties, (ID2D1BitmapBrush1 **)ret); + break; + case D2D_BRUSH_TYPE_IMAGE: + image_properties.sourceRectangle = brush->u.image.source_rect; + image_properties.extendModeX = brush->u.image.extend_mode_x; + image_properties.extendModeY = brush->u.image.extend_mode_y; + image_properties.interpolationMode = brush->u.image.interpolation_mode; + hr = ID2D1DeviceContext_CreateImageBrush(context, brush->u.image.image, + &image_properties, &properties, (ID2D1ImageBrush **)ret); + break; + default: + FIXME("Unsupported brush type %u.\n", brush->type); + return E_UNEXPECTED; + } + + if (SUCCEEDED(hr)) + { + d2d_command_list_reference_object(command_list, *ret); + ID2D1Brush_Release(*ret); + } + + return hr; +} + +void d2d_command_list_set_antialias_mode(struct d2d_command_list *command_list, + D2D1_ANTIALIAS_MODE mode) +{ + struct d2d_command_set_antialias_mode *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_ANTIALIAS_MODE; + command->mode = mode; +} + +void d2d_command_list_set_primitive_blend(struct d2d_command_list *command_list, + D2D1_PRIMITIVE_BLEND primitive_blend) +{ + struct d2d_command_set_primitive_blend *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_PRIMITIVE_BLEND; + command->primitive_blend = primitive_blend; +} + +void d2d_command_list_set_unit_mode(struct d2d_command_list *command_list, D2D1_UNIT_MODE mode) +{ + struct d2d_command_set_unit_mode *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_UNIT_MODE; + command->mode = mode; +} + +void d2d_command_list_set_text_antialias_mode(struct d2d_command_list *command_list, + D2D1_TEXT_ANTIALIAS_MODE mode) +{ + struct d2d_command_set_text_antialias_mode *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_TEXT_ANTIALIAS_MODE; + command->mode = mode; +} + +void d2d_command_list_set_tags(struct d2d_command_list *command_list, D2D1_TAG tag1, D2D1_TAG tag2) +{ + struct d2d_command_set_tags *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_TAGS; + command->tag1 = tag1; + command->tag2 = tag2; +} + +void d2d_command_list_set_transform(struct d2d_command_list *command_list, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_command_set_transform *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_TRANSFORM; + command->transform = *transform; +} + +void d2d_command_list_begin_draw(struct d2d_command_list *command_list, + const struct d2d_device_context *context) +{ + if (command_list->state != D2D_COMMAND_LIST_STATE_INITIAL) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + d2d_command_list_set_antialias_mode(command_list, context->drawing_state.antialiasMode); + d2d_command_list_set_primitive_blend(command_list, context->drawing_state.primitiveBlend); + d2d_command_list_set_unit_mode(command_list, context->drawing_state.unitMode); + d2d_command_list_set_text_antialias_mode(command_list, context->drawing_state.textAntialiasMode); + d2d_command_list_set_tags(command_list, context->drawing_state.tag1, context->drawing_state.tag2); + d2d_command_list_set_transform(command_list, &context->drawing_state.transform); + d2d_command_list_set_text_rendering_params(command_list, context->text_rendering_params); + + command_list->state = D2D_COMMAND_LIST_STATE_OPEN; +} + +void d2d_command_list_push_clip(struct d2d_command_list *command_list, const D2D1_RECT_F *rect, + D2D1_ANTIALIAS_MODE mode) +{ + struct d2d_command_push_clip *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_PUSH_CLIP; + command->rect = *rect; + command->mode = mode; +} + +void d2d_command_list_pop_clip(struct d2d_command_list *command_list) +{ + struct d2d_command *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->op = D2D_COMMAND_POP_CLIP; +} + +void d2d_command_list_push_layer(struct d2d_command_list *command_list, const struct d2d_device_context *context, + const D2D1_LAYER_PARAMETERS1 *params, ID2D1Layer *layer) +{ + struct d2d_command_push_layer *command; + ID2D1Brush *opacity_brush = NULL; + + if (params->opacityBrush && FAILED(d2d_command_list_create_brush(command_list, context, + params->opacityBrush, &opacity_brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + d2d_command_list_reference_object(command_list, layer); + d2d_command_list_reference_object(command_list, params->geometricMask); + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_PUSH_LAYER; + command->params = *params; + command->params.opacityBrush = opacity_brush; + command->layer = layer; +} + +void d2d_command_list_pop_layer(struct d2d_command_list *command_list) +{ + struct d2d_command *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->op = D2D_COMMAND_POP_LAYER; +} + +void d2d_command_list_clear(struct d2d_command_list *command_list, const D2D1_COLOR_F *color) +{ + struct d2d_command_clear *command; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_CLEAR; + if (color) command->color = *color; + else memset(&command->color, 0, sizeof(command->color)); +} + +void d2d_command_list_draw_line(struct d2d_command_list *command_list, + const struct d2d_device_context *context, D2D1_POINT_2F p0, D2D1_POINT_2F p1, + ID2D1Brush *orig_brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_command_draw_line *command; + ID2D1Brush *brush; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + d2d_command_list_reference_object(command_list, stroke_style); + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_DRAW_LINE; + command->p0 = p0; + command->p1 = p1; + command->brush = brush; + command->stroke_width = stroke_width; + command->stroke_style = stroke_style; +} + +void d2d_command_list_draw_geometry(struct d2d_command_list *command_list, + const struct d2d_device_context *context, ID2D1Geometry *geometry, ID2D1Brush *orig_brush, + float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_command_draw_geometry *command; + ID2D1Brush *brush; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + d2d_command_list_reference_object(command_list, geometry); + d2d_command_list_reference_object(command_list, stroke_style); + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_DRAW_GEOMETRY; + command->brush = brush; + command->stroke_width = stroke_width; + command->stroke_style = stroke_style; +} + +void d2d_command_list_draw_rectangle(struct d2d_command_list *command_list, const struct d2d_device_context *context, + const D2D1_RECT_F *rect, ID2D1Brush *orig_brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_command_draw_rectangle *command; + ID2D1Brush *brush; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + d2d_command_list_reference_object(command_list, stroke_style); + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_DRAW_RECTANGLE; + command->rect = *rect; + command->brush = brush; + command->stroke_width = stroke_width; + command->stroke_style = stroke_style; +} + +void d2d_command_list_fill_geometry(struct d2d_command_list *command_list, + const struct d2d_device_context *context, ID2D1Geometry *geometry, ID2D1Brush *orig_brush, + ID2D1Brush *orig_opacity_brush) +{ + ID2D1Brush *brush, *opacity_brush = NULL; + struct d2d_command_fill_geometry *command; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + if (orig_opacity_brush && FAILED(d2d_command_list_create_brush(command_list, context, + orig_opacity_brush, &opacity_brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + ID2D1Brush_Release(brush); + return; + } + + d2d_command_list_reference_object(command_list, geometry); + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_FILL_GEOMETRY; + command->geometry = geometry; + command->brush = brush; + command->opacity_brush = opacity_brush; +} + +void d2d_command_list_fill_rectangle(struct d2d_command_list *command_list, + const struct d2d_device_context *context, const D2D1_RECT_F *rect, ID2D1Brush *orig_brush) +{ + struct d2d_command_fill_rectangle *command; + ID2D1Brush *brush; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_FILL_RECTANGLE; + command->rect = *rect; + command->brush = brush; +} + +static void d2d_command_list_set_text_rendering_params_internal(struct d2d_command_list *command_list, + BOOL allow_null, IDWriteRenderingParams *params) +{ + struct d2d_command_set_text_rendering_params *command; + + if (!params && !allow_null) return; + + if ((command_list->flags & D2D_COMMAND_LIST_HAS_NULL_TEXT_RENDERING_PARAMS) + && !params) + { + return; + } + + d2d_command_list_reference_object(command_list, params); + + if (params) + command_list->flags &= ~D2D_COMMAND_LIST_HAS_NULL_TEXT_RENDERING_PARAMS; + else + command_list->flags |= D2D_COMMAND_LIST_HAS_NULL_TEXT_RENDERING_PARAMS; + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_SET_TEXT_RENDERING_PARAMS; + command->params = params; +} + +void d2d_command_list_set_text_rendering_params(struct d2d_command_list *command_list, + IDWriteRenderingParams *params) +{ + d2d_command_list_set_text_rendering_params_internal(command_list, FALSE, params); +} + +static inline void d2d_command_list_write_field(BYTE **data, void *dst, const void *src, size_t size) +{ + void **ptr = dst; + + if (!src) + { + *ptr = NULL; + return; + } + + *ptr = *data; + memcpy(*data, src, size); + *data = *data + size; +} + +void d2d_command_list_draw_glyph_run(struct d2d_command_list *command_list, + const struct d2d_device_context *context, D2D1_POINT_2F origin, const DWRITE_GLYPH_RUN *run, + const DWRITE_GLYPH_RUN_DESCRIPTION *run_desc, ID2D1Brush *orig_brush, + DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_command_draw_glyph_run *command; + DWRITE_GLYPH_RUN_DESCRIPTION *d; + DWRITE_GLYPH_RUN *r; + UINT32 glyph_count; + ID2D1Brush *brush; + size_t size; + BYTE *data; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + /* Set rendering parameters automatically. Explicitly set null parameters are not recorded, + either separately or as a part of a restored state block. Forcing parameters update on + DrawGlyphRun() ensures that state is reset correctly. */ + + d2d_command_list_set_text_rendering_params_internal(command_list, TRUE, + context->text_rendering_params); + + /* Get combined size of variable data. */ + + glyph_count = run->glyphCount; + size = sizeof(*command); + if (run->glyphIndices) size += glyph_count * sizeof(*run->glyphIndices); + if (run->glyphAdvances) size += glyph_count * sizeof(*run->glyphAdvances); + if (run->glyphOffsets) size += glyph_count * sizeof(*run->glyphOffsets); + if (run_desc) + { + size += sizeof(*run_desc); + if (run_desc->localeName) size += (wcslen(run_desc->localeName) + 1) * sizeof(*run_desc->localeName); + if (run_desc->string) size += run_desc->stringLength * sizeof(*run_desc->string); + if (run_desc->clusterMap) size += run_desc->stringLength * sizeof(*run_desc->clusterMap); + size += sizeof(run_desc->stringLength); + size += sizeof(run_desc->textPosition); + } + + d2d_command_list_reference_object(command_list, run->fontFace); + + command = d2d_command_list_require_space(command_list, size); + command->c.op = D2D_COMMAND_DRAW_GLYPH_RUN; + r = &command->run; + + r->fontFace = run->fontFace; + r->fontEmSize = run->fontEmSize; + r->glyphCount = run->glyphCount; + r->isSideways = run->isSideways; + r->bidiLevel = run->bidiLevel; + + data = (BYTE *)(command + 1); + + d2d_command_list_write_field(&data, &r->glyphIndices, run->glyphIndices, glyph_count * sizeof(*r->glyphIndices)); + d2d_command_list_write_field(&data, &r->glyphAdvances, run->glyphAdvances, glyph_count * sizeof(*r->glyphAdvances)); + d2d_command_list_write_field(&data, &r->glyphOffsets, run->glyphOffsets, glyph_count * sizeof(*r->glyphOffsets)); + + command->run_desc = NULL; + if (run_desc) + { + d = command->run_desc = (DWRITE_GLYPH_RUN_DESCRIPTION *)data; + memset(d, 0, sizeof(*d)); + data += sizeof(*d); + + d2d_command_list_write_field(&data, &d->localeName, run_desc->localeName, (wcslen(run_desc->localeName) + 1) * sizeof(*run_desc->localeName)); + d2d_command_list_write_field(&data, &d->string, run_desc->string, run_desc->stringLength * sizeof(*run_desc->string)); + d->stringLength = run_desc->stringLength; + d2d_command_list_write_field(&data, &d->clusterMap, run_desc->clusterMap, run_desc->stringLength * sizeof(*run_desc->clusterMap)); + d->textPosition = run_desc->textPosition; + } + + command->brush = brush; + command->origin = origin; + command->measuring_mode = measuring_mode; +} + +void d2d_command_list_draw_bitmap(struct d2d_command_list *command_list, ID2D1Bitmap *bitmap, + const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode, + const D2D1_RECT_F *src_rect, const D2D1_MATRIX_4X4_F *perspective_transform) +{ + struct d2d_command_draw_bitmap *command; + size_t size; + BYTE *data; + + size = sizeof(*command); + if (dst_rect) size += sizeof(*dst_rect); + if (src_rect) size += sizeof(*src_rect); + if (perspective_transform) size += sizeof(*perspective_transform); + + d2d_command_list_reference_object(command_list, bitmap); + + command = d2d_command_list_require_space(command_list, size); + command->c.op = D2D_COMMAND_DRAW_BITMAP; + command->bitmap = bitmap; + command->opacity = opacity; + command->interpolation_mode = interpolation_mode; + + data = (BYTE *)(command + 1); + + d2d_command_list_write_field(&data, &command->dst_rect, dst_rect, sizeof(*dst_rect)); + d2d_command_list_write_field(&data, &command->src_rect, src_rect, sizeof(*src_rect)); + d2d_command_list_write_field(&data, &command->perspective_transform, perspective_transform, sizeof(*perspective_transform)); +} + +void d2d_command_list_draw_image(struct d2d_command_list *command_list, ID2D1Image *image, + const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, D2D1_INTERPOLATION_MODE interpolation_mode, + D2D1_COMPOSITE_MODE composite_mode) +{ + struct d2d_command_draw_image *command; + size_t size; + BYTE *data; + + size = sizeof(*command); + if (target_offset) size += sizeof(*target_offset); + if (image_rect) size += sizeof(*image_rect); + + d2d_command_list_reference_object(command_list, image); + + command = d2d_command_list_require_space(command_list, size); + command->c.op = D2D_COMMAND_DRAW_IMAGE; + command->image = image; + command->interpolation_mode = interpolation_mode; + command->composite_mode = composite_mode; + + data = (BYTE *)(command + 1); + + d2d_command_list_write_field(&data, &command->target_offset, target_offset, sizeof(*target_offset)); + d2d_command_list_write_field(&data, &command->image_rect, image_rect, sizeof(*image_rect)); +} + +void d2d_command_list_fill_mesh(struct d2d_command_list *command_list, const struct d2d_device_context *context, + ID2D1Mesh *mesh, ID2D1Brush *orig_brush) +{ + struct d2d_command_fill_mesh *command; + ID2D1Brush *brush; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + d2d_command_list_reference_object(command_list, mesh); + + command = d2d_command_list_require_space(command_list, sizeof(*command)); + command->c.op = D2D_COMMAND_FILL_MESH; + command->mesh = mesh; + command->brush = brush; +} + +void d2d_command_list_fill_opacity_mask(struct d2d_command_list *command_list, const struct d2d_device_context *context, + ID2D1Bitmap *bitmap, ID2D1Brush *orig_brush, const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect) +{ + struct d2d_command_fill_opacity_mask *command; + ID2D1Brush *brush; + size_t size; + BYTE *data; + + if (FAILED(d2d_command_list_create_brush(command_list, context, orig_brush, &brush))) + { + command_list->state = D2D_COMMAND_LIST_STATE_ERROR; + return; + } + + size = sizeof(*command); + if (dst_rect) size += sizeof(*dst_rect); + if (src_rect) size += sizeof(*src_rect); + + d2d_command_list_reference_object(command_list, bitmap); + + command = d2d_command_list_require_space(command_list, size); + command->c.op = D2D_COMMAND_FILL_OPACITY_MASK; + command->bitmap = bitmap; + command->brush = brush; + + data = (BYTE *)(command + 1); + + d2d_command_list_write_field(&data, &command->dst_rect, dst_rect, sizeof(*dst_rect)); + d2d_command_list_write_field(&data, &command->src_rect, src_rect, sizeof(*src_rect)); +} diff --git a/WineFix/lib/d2d1/src/d2d1.spec b/WineFix/lib/d2d1/src/d2d1.spec new file mode 100644 index 0000000..693f282 --- /dev/null +++ b/WineFix/lib/d2d1/src/d2d1.spec @@ -0,0 +1,12 @@ +@ stdcall D2D1CreateFactory(long ptr ptr ptr) +@ stdcall D2D1MakeRotateMatrix(float float float ptr) +@ stdcall D2D1MakeSkewMatrix(float float float float ptr) +@ stdcall D2D1IsMatrixInvertible(ptr) +@ stdcall D2D1InvertMatrix(ptr) +@ stdcall D2D1ConvertColorSpace(long long ptr) +@ stdcall D2D1CreateDevice(ptr ptr ptr) +@ stdcall D2D1CreateDeviceContext(ptr ptr ptr) +@ stdcall D2D1SinCos(float ptr ptr) +@ stdcall D2D1Tan(float) +@ stdcall D2D1Vec3Length(float float float) +@ stdcall D2D1ComputeMaximumScaleFactor(ptr) diff --git a/WineFix/lib/d2d1/src/d2d1_private.h b/WineFix/lib/d2d1/src/d2d1_private.h new file mode 100644 index 0000000..e214921 --- /dev/null +++ b/WineFix/lib/d2d1/src/d2d1_private.h @@ -0,0 +1,1087 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D2D1_PRIVATE_H +#define __WINE_D2D1_PRIVATE_H + +#include "wine/debug.h" +#include "wine/list.h" +#include "wine/heap.h" + +#include +#include +#include +#include +#include +#define COBJMACROS +#define WIDL_C_INLINE_WRAPPERS +#include "d2d1_3.h" +#include "d2d1effectauthor.h" +#include "d3d11_1.h" +#ifdef D2D1_INIT_GUID +#include "initguid.h" +#endif +#include "dwrite_2.h" + +enum d2d_brush_type +{ + D2D_BRUSH_TYPE_SOLID, + D2D_BRUSH_TYPE_LINEAR, + D2D_BRUSH_TYPE_RADIAL, + D2D_BRUSH_TYPE_BITMAP, + D2D_BRUSH_TYPE_IMAGE, + D2D_BRUSH_TYPE_COUNT, +}; + +enum d2d_shape_type +{ + D2D_SHAPE_TYPE_OUTLINE, + D2D_SHAPE_TYPE_BEZIER_OUTLINE, + D2D_SHAPE_TYPE_ARC_OUTLINE, + D2D_SHAPE_TYPE_TRIANGLE, + D2D_SHAPE_TYPE_CURVE, + D2D_SHAPE_TYPE_COUNT, +}; + +struct d2d_settings +{ + unsigned int max_version_factory; +}; +extern struct d2d_settings d2d_settings; + +struct d2d_clip_stack +{ + D2D1_RECT_F *stack; + size_t size; + size_t count; +}; + +struct d2d_error_state +{ + HRESULT code; + D2D1_TAG tag1, tag2; +}; + +struct d2d_shape_resources +{ + ID3D11InputLayout *il; + ID3D11VertexShader *vs; +}; + +struct d2d_brush_cb +{ + enum d2d_brush_type type; + float opacity; + unsigned int pad[2]; + union + { + struct + { + D2D1_COLOR_F colour; + } solid; + struct + { + D2D1_POINT_2F start; + D2D1_POINT_2F end; + unsigned int stop_count; + } linear; + struct + { + D2D1_POINT_2F centre; + D2D1_POINT_2F offset; + D2D1_POINT_2F ra; + D2D1_POINT_2F rb; + unsigned int stop_count; + float pad[3]; + } radial; + struct + { + float _11, _21, _31, pad; + float _12, _22, _32; + BOOL ignore_alpha; + } bitmap; + } u; +}; + +struct d2d_ps_cb +{ + BOOL outline; + BOOL is_arc; + BOOL pad[2]; + struct d2d_brush_cb colour_brush; + struct d2d_brush_cb opacity_brush; +}; + +struct d2d_vec4 +{ + float x, y, z, w; +}; + +struct d2d_vs_cb +{ + struct + { + float _11, _21, _31, pad0; + float _12, _22, _32, stroke_width; + } transform_geometry; + struct d2d_vec4 transform_rtx; + struct d2d_vec4 transform_rty; +}; + +struct d2d_device_context_ops +{ + HRESULT (*device_context_present)(IUnknown *outer_unknown); +}; + +enum d2d_device_context_sampler_limits +{ + D2D_SAMPLER_INTERPOLATION_MODE_COUNT = 2, + D2D_SAMPLER_EXTEND_MODE_COUNT = 3, +}; + +enum d2d_device_context_target_type +{ + D2D_TARGET_UNKNOWN = 0, + D2D_TARGET_BITMAP, + D2D_TARGET_COMMAND_LIST, +}; + +struct d2d_indexed_objects +{ + struct + { + GUID id; + IUnknown *object; + } *elements; + size_t size; + size_t count; +}; + +struct d2d_device_context +{ + ID2D1DeviceContext6 ID2D1DeviceContext6_iface; + ID2D1GdiInteropRenderTarget ID2D1GdiInteropRenderTarget_iface; + IDWriteTextRenderer IDWriteTextRenderer_iface; + IUnknown IUnknown_iface; + LONG refcount; + + IUnknown *outer_unknown; + const struct d2d_device_context_ops *ops; + + ID2D1Factory *factory; + CRITICAL_SECTION *cs; + struct d2d_device *device; + ID3D11Device1 *d3d_device; + ID3DDeviceContextState *d3d_state; + struct + { + ID2D1Image *object; + enum d2d_device_context_target_type type; + union + { + struct d2d_bitmap *bitmap; + struct d2d_command_list *command_list; + }; + HDC hdc; + } target; + struct d2d_shape_resources shape_resources[D2D_SHAPE_TYPE_COUNT]; + ID3D11Buffer *vs_cb; + ID3D11PixelShader *ps; + ID3D11Buffer *ps_cb; + ID3D11Buffer *ib; + unsigned int vb_stride; + ID3D11Buffer *vb; + ID3D11RasterizerState *rs; + ID3D11BlendState *bs; + ID3D11SamplerState *sampler_states + [D2D_SAMPLER_INTERPOLATION_MODE_COUNT] + [D2D_SAMPLER_EXTEND_MODE_COUNT] + [D2D_SAMPLER_EXTEND_MODE_COUNT]; + + struct d2d_error_state error; + D2D1_DRAWING_STATE_DESCRIPTION1 drawing_state; + IDWriteRenderingParams *text_rendering_params; + IDWriteRenderingParams *default_text_rendering_params; + + D2D1_RENDER_TARGET_PROPERTIES desc; + D2D1_SIZE_U pixel_size; + struct d2d_clip_stack clip_stack; + + struct d2d_indexed_objects vertex_buffers; +}; + +HRESULT d2d_d3d_create_render_target(struct d2d_device *device, IDXGISurface *surface, IUnknown *outer_unknown, + const struct d2d_device_context_ops *ops, const D2D1_RENDER_TARGET_PROPERTIES *desc, + void **render_target); + +static inline BOOL d2d_device_context_is_dxgi_target(const struct d2d_device_context *context) +{ + return !context->ops; +} + +struct d2d_wic_render_target +{ + IUnknown IUnknown_iface; + LONG refcount; + + IDXGISurface *dxgi_surface; + ID2D1RenderTarget *dxgi_target; + IUnknown *dxgi_inner; + ID3D10Texture2D *readback_texture; + IWICBitmap *bitmap; + + unsigned int width; + unsigned int height; + unsigned int bpp; +}; + +HRESULT d2d_wic_render_target_init(struct d2d_wic_render_target *render_target, ID2D1Factory1 *factory, + ID3D10Device1 *d3d_device, IWICBitmap *bitmap, const D2D1_RENDER_TARGET_PROPERTIES *desc); + +struct d2d_dc_render_target +{ + ID2D1DCRenderTarget ID2D1DCRenderTarget_iface; + LONG refcount; + + IDXGISurface1 *dxgi_surface; + ID3D10Device1 *d3d_device; + ID2D1RenderTarget *dxgi_target; + IUnknown *dxgi_inner; + + RECT dst_rect; + HDC hdc; + + D2D1_RENDER_TARGET_PROPERTIES desc; +}; + +HRESULT d2d_dc_render_target_init(struct d2d_dc_render_target *render_target, ID2D1Factory1 *factory, + ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc); + +struct d2d_hwnd_render_target +{ + ID2D1HwndRenderTarget ID2D1HwndRenderTarget_iface; + LONG refcount; + + ID2D1RenderTarget *dxgi_target; + IUnknown *dxgi_inner; + IDXGISwapChain *swapchain; + UINT sync_interval; + HWND hwnd; + + D2D1_RENDER_TARGET_PROPERTIES desc; +}; + +HRESULT d2d_hwnd_render_target_init(struct d2d_hwnd_render_target *render_target, ID2D1Factory1 *factory, + ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc, + const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_desc); + +struct d2d_bitmap_render_target +{ + ID2D1BitmapRenderTarget ID2D1BitmapRenderTarget_iface; + LONG refcount; + + ID2D1RenderTarget *dxgi_target; + IUnknown *dxgi_inner; + ID2D1Bitmap *bitmap; +}; + +HRESULT d2d_bitmap_render_target_init(struct d2d_bitmap_render_target *render_target, + const struct d2d_device_context *parent_target, const D2D1_SIZE_F *size, + const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options); + +struct d2d_gradient +{ + ID2D1GradientStopCollection ID2D1GradientStopCollection_iface; + LONG refcount; + + ID2D1Factory *factory; + ID3D11ShaderResourceView *view; + D2D1_GRADIENT_STOP *stops; + UINT32 stop_count; +}; + +HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D11Device1 *device, const D2D1_GRADIENT_STOP *stops, + UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, + struct d2d_gradient **gradient); + +struct d2d_brush +{ + ID2D1Brush ID2D1Brush_iface; + LONG refcount; + + ID2D1Factory *factory; + float opacity; + D2D1_MATRIX_3X2_F transform; + + enum d2d_brush_type type; + union + { + struct + { + D2D1_COLOR_F color; + } solid; + struct + { + struct d2d_gradient *gradient; + D2D1_POINT_2F start; + D2D1_POINT_2F end; + } linear; + struct + { + struct d2d_gradient *gradient; + D2D1_POINT_2F centre; + D2D1_POINT_2F offset; + D2D1_POINT_2F radius; + } radial; + struct + { + struct d2d_bitmap *bitmap; + D2D1_EXTEND_MODE extend_mode_x; + D2D1_EXTEND_MODE extend_mode_y; + D2D1_INTERPOLATION_MODE interpolation_mode; + } bitmap; + struct + { + ID2D1Image *image; + D2D1_EXTEND_MODE extend_mode_x; + D2D1_EXTEND_MODE extend_mode_y; + D2D1_INTERPOLATION_MODE interpolation_mode; + D2D1_RECT_F source_rect; + } image; + } u; +}; + +HRESULT d2d_solid_color_brush_create(ID2D1Factory *factory, const D2D1_COLOR_F *color, + const D2D1_BRUSH_PROPERTIES *desc, struct d2d_brush **brush); +HRESULT d2d_linear_gradient_brush_create(ID2D1Factory *factory, + const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, struct d2d_brush **brush); +HRESULT d2d_radial_gradient_brush_create(ID2D1Factory *factory, + const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, struct d2d_brush **brush); +HRESULT d2d_bitmap_brush_create(ID2D1Factory *factory, ID2D1Bitmap *bitmap, + const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + struct d2d_brush **brush); +HRESULT d2d_image_brush_create(ID2D1Factory *factory, ID2D1Image *image, + const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + struct d2d_brush **brush); +void d2d_brush_bind_resources(struct d2d_brush *brush, struct d2d_device_context *context, + unsigned int brush_idx); +BOOL d2d_brush_fill_cb(const struct d2d_brush *brush, struct d2d_brush_cb *cb); +struct d2d_brush *unsafe_impl_from_ID2D1Brush(ID2D1Brush *iface); + +struct d2d_stroke_style +{ + ID2D1StrokeStyle1 ID2D1StrokeStyle1_iface; + LONG refcount; + + ID2D1Factory *factory; + D2D1_STROKE_STYLE_PROPERTIES1 desc; + float *dashes; + UINT32 dash_count; +}; + +HRESULT d2d_stroke_style_init(struct d2d_stroke_style *style, ID2D1Factory *factory, + const D2D1_STROKE_STYLE_PROPERTIES1 *desc, const float *dashes, UINT32 dash_count); +struct d2d_stroke_style *unsafe_impl_from_ID2D1StrokeStyle(ID2D1StrokeStyle *iface); + +struct d2d_layer +{ + ID2D1Layer ID2D1Layer_iface; + LONG refcount; + + ID2D1Factory *factory; + D2D1_SIZE_F size; +}; + +HRESULT d2d_layer_create(ID2D1Factory *factory, const D2D1_SIZE_F *size, struct d2d_layer **layer); + +enum d2d_mesh_state +{ + D2D_MESH_STATE_INITIAL = 0, + D2D_MESH_STATE_OPEN, + D2D_MESH_STATE_CLOSED, +}; + +struct d2d_mesh +{ + ID2D1Mesh ID2D1Mesh_iface; + ID2D1TessellationSink ID2D1TessellationSink_iface; + LONG refcount; + + ID2D1Factory *factory; + enum d2d_mesh_state state; + + D2D1_TRIANGLE *triangles; + size_t count; + size_t size; +}; + +HRESULT d2d_mesh_create(ID2D1Factory *factory, struct d2d_mesh **mesh); + +struct d2d_bitmap +{ + ID2D1Bitmap1 ID2D1Bitmap1_iface; + LONG refcount; + + ID2D1Factory *factory; + ID3D11ShaderResourceView *srv; + ID3D11RenderTargetView *rtv; + IDXGISurface *surface; + ID3D11Resource *resource; + D3D11_MAPPED_SUBRESOURCE mapped_resource; + D2D1_SIZE_U pixel_size; + D2D1_PIXEL_FORMAT format; + float dpi_x; + float dpi_y; + D2D1_BITMAP_OPTIONS options; +}; + +HRESULT d2d_bitmap_create(struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data, + UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap); +HRESULT d2d_bitmap_create_shared(struct d2d_device_context *context, REFIID iid, void *data, + const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap); +HRESULT d2d_bitmap_create_from_wic_bitmap(struct d2d_device_context *context, IWICBitmapSource *bitmap_source, + const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap); +unsigned int d2d_get_bitmap_options_for_surface(IDXGISurface *surface); +struct d2d_bitmap *unsafe_impl_from_ID2D1Bitmap(ID2D1Bitmap *iface); + +struct d2d_state_block +{ + ID2D1DrawingStateBlock1 ID2D1DrawingStateBlock1_iface; + LONG refcount; + + ID2D1Factory *factory; + D2D1_DRAWING_STATE_DESCRIPTION1 drawing_state; + IDWriteRenderingParams *text_rendering_params; +}; + +void d2d_state_block_init(struct d2d_state_block *state_block, ID2D1Factory *factory, + const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, IDWriteRenderingParams *text_rendering_params); +struct d2d_state_block *unsafe_impl_from_ID2D1DrawingStateBlock(ID2D1DrawingStateBlock *iface); + +enum d2d_geometry_state +{ + D2D_GEOMETRY_STATE_INITIAL = 0, + D2D_GEOMETRY_STATE_ERROR, + D2D_GEOMETRY_STATE_OPEN, + D2D_GEOMETRY_STATE_CLOSED, + D2D_GEOMETRY_STATE_FIGURE, +}; + +struct d2d_curve_vertex +{ + D2D1_POINT_2F position; + struct + { + float u, v, sign; + } texcoord; +}; + +struct d2d_face +{ + UINT16 v[3]; +}; + +struct d2d_outline_vertex +{ + D2D1_POINT_2F position; + D2D1_POINT_2F prev; + D2D1_POINT_2F next; +}; + +struct d2d_curve_outline_vertex +{ + D2D1_POINT_2F position; + D2D1_POINT_2F p0, p1, p2; + D2D1_POINT_2F prev, next; +}; + +struct d2d_geometry +{ + ID2D1Geometry ID2D1Geometry_iface; + LONG refcount; + + ID2D1Factory *factory; + + D2D_MATRIX_3X2_F transform; + + struct + { + D2D1_POINT_2F *vertices; + size_t vertex_count; + + struct d2d_face *faces; + size_t faces_size; + size_t face_count; + + struct d2d_curve_vertex *bezier_vertices; + size_t bezier_vertices_size; + size_t bezier_vertex_count; + + struct d2d_curve_vertex *arc_vertices; + size_t arc_vertices_size; + size_t arc_vertex_count; + } fill; + + struct + { + struct d2d_outline_vertex *vertices; + size_t vertices_size; + size_t vertex_count; + + struct d2d_face *faces; + size_t faces_size; + size_t face_count; + + struct d2d_curve_outline_vertex *beziers; + size_t beziers_size; + size_t bezier_count; + + struct d2d_face *bezier_faces; + size_t bezier_faces_size; + size_t bezier_face_count; + + struct d2d_curve_outline_vertex *arcs; + size_t arcs_size; + size_t arc_count; + + struct d2d_face *arc_faces; + size_t arc_faces_size; + size_t arc_face_count; + } outline; + + union + { + struct + { + D2D1_ELLIPSE ellipse; + } ellipse; + struct + { + ID2D1GeometrySink ID2D1GeometrySink_iface; + + struct d2d_figure *figures; + size_t figures_size; + size_t figure_count; + + enum d2d_geometry_state state; + HRESULT code; + D2D1_FILL_MODE fill_mode; + UINT32 segment_count; + + D2D1_RECT_F bounds; + } path; + struct + { + D2D1_RECT_F rect; + } rectangle; + struct + { + D2D1_ROUNDED_RECT rounded_rect; + } rounded_rectangle; + struct + { + ID2D1Geometry *src_geometry; + D2D_MATRIX_3X2_F transform; + } transformed; + struct + { + ID2D1Geometry **src_geometries; + UINT32 geometry_count; + D2D1_FILL_MODE fill_mode; + } group; + } u; +}; + +HRESULT d2d_ellipse_geometry_init(struct d2d_geometry *geometry, + ID2D1Factory *factory, const D2D1_ELLIPSE *ellipse); +void d2d_path_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory); +HRESULT d2d_rectangle_geometry_init(struct d2d_geometry *geometry, + ID2D1Factory *factory, const D2D1_RECT_F *rect); +HRESULT d2d_rounded_rectangle_geometry_init(struct d2d_geometry *geometry, + ID2D1Factory *factory, const D2D1_ROUNDED_RECT *rounded_rect); +void d2d_transformed_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory, + ID2D1Geometry *src_geometry, const D2D_MATRIX_3X2_F *transform); +HRESULT d2d_geometry_group_init(struct d2d_geometry *geometry, ID2D1Factory *factory, + D2D1_FILL_MODE fill_mode, ID2D1Geometry **src_geometries, unsigned int geometry_count); +struct d2d_geometry *unsafe_impl_from_ID2D1Geometry(ID2D1Geometry *iface); + +struct d2d_geometry_realization +{ + ID2D1GeometryRealization ID2D1GeometryRealization_iface; + LONG refcount; + + ID2D1Factory *factory; + ID2D1Geometry *geometry; + bool filled; + + ID2D1StrokeStyle *stroke_style; + float stroke_width; +}; + +HRESULT d2d_geometry_realization_init(struct d2d_geometry_realization *realization, + ID2D1Factory *factory, ID2D1Geometry *geometry); +struct d2d_geometry_realization *unsafe_impl_from_ID2D1GeometryRealization(ID2D1GeometryRealization *iface); + +struct d2d_device +{ + ID2D1Device6 ID2D1Device6_iface; + LONG refcount; + ID2D1Factory1 *factory; + IDXGIDevice *dxgi_device; + bool allow_get_dxgi_device; + + ID3D10Blob *precompiled_shape_vs[D2D_SHAPE_TYPE_COUNT]; + ID3D10Blob *precompiled_shape_ps; + + struct d2d_indexed_objects shaders; +}; + +struct d2d_device *unsafe_impl_from_ID2D1Device(ID2D1Device1 *iface); +HRESULT d2d_device_add_indexed_object(struct d2d_indexed_objects *objects, const GUID *id, + IUnknown *object); +BOOL d2d_device_get_indexed_object(struct d2d_indexed_objects *objects, const GUID *id, + IUnknown **object); +void d2d_device_indexed_objects_clear(struct d2d_indexed_objects *objects); + +struct d2d_effect_context +{ + ID2D1EffectContext ID2D1EffectContext_iface; + LONG refcount; + + struct d2d_device_context *device_context; +}; + +void d2d_effect_context_init(struct d2d_effect_context *effect_context, + struct d2d_device_context *device_context); + +struct d2d_effect_property +{ + WCHAR *name; + D2D1_PROPERTY_TYPE type; + UINT32 index; + BOOL readonly; + union + { + size_t offset; + void *ptr; + } data; + UINT32 size; + PD2D1_PROPERTY_SET_FUNCTION set_function; + PD2D1_PROPERTY_GET_FUNCTION get_function; + struct d2d_effect_properties *subproperties; +}; + +struct d2d_effect_properties +{ + ID2D1Properties ID2D1Properties_iface; + LONG refcount; + struct d2d_effect *effect; + + struct d2d_effect_property *properties; + size_t offset; + size_t size; + size_t count; + size_t custom_count; + struct + { + BYTE *ptr; + size_t size; + size_t count; + } data; +}; + +struct d2d_effect_registration +{ + struct list entry; + PD2D1_EFFECT_FACTORY factory; + UINT32 registration_count; + BOOL builtin; + CLSID id; + + struct d2d_effect_properties *properties; +}; + +struct d2d_factory +{ + ID2D1Factory7 ID2D1Factory7_iface; + ID2D1Multithread ID2D1Multithread_iface; + LONG refcount; + + ID3D10Device1 *device; + + float dpi_x; + float dpi_y; + + struct list effects; + INIT_ONCE init_builtins; + + CRITICAL_SECTION cs; + D2D1_FACTORY_TYPE factory_type; +}; + +static inline struct d2d_factory *unsafe_impl_from_ID2D1Factory(ID2D1Factory *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Factory7_iface); +} + +void d2d_effects_init_builtins(struct d2d_factory *factory); +HRESULT d2d_factory_create_device(ID2D1Factory1 *factory, IDXGIDevice *dxgi_device, + bool allow_get_dxgi_device, REFIID iid, void **device); +struct d2d_effect_registration * d2d_factory_get_registered_effect(ID2D1Factory *factory, + const GUID *effect_id); +void d2d_factory_register_effect(struct d2d_factory *factory, + struct d2d_effect_registration *effect); +HRESULT d2d_effect_property_get_uint32_value(const struct d2d_effect_properties *properties, + const struct d2d_effect_property *prop, UINT32 *value); +HRESULT d2d_device_init(struct d2d_device *device, ID2D1Factory1 *factory, IDXGIDevice *dxgi_device, + bool allow_get_dxgi_device); + +struct d2d_transform +{ + ID2D1TransformNode ID2D1TransformNode_iface; + LONG refcount; + + union + { + D2D1_POINT_2L offset; + D2D1_BLEND_DESCRIPTION blend_desc; + struct + { + D2D1_EXTEND_MODE mode_x; + D2D1_EXTEND_MODE mode_y; + } border; + D2D1_RECT_L bounds; + }; + + UINT32 input_count; +}; + +enum d2d_render_info_mask +{ + D2D_RENDER_INFO_PIXEL_SHADER = 0x1, +}; + +struct d2d_render_info +{ + ID2D1DrawInfo ID2D1DrawInfo_iface; + LONG refcount; + + unsigned int mask; + GUID pixel_shader; +}; + +struct d2d_transform_node +{ + struct list entry; + ID2D1TransformNode *object; + struct d2d_render_info *render_info; + struct d2d_transform_node **inputs; + unsigned int input_count; + struct d2d_transform_node *output; +}; + +struct d2d_transform_node_connection +{ + struct d2d_transform_node *node; + unsigned int index; +}; + +struct d2d_transform_graph +{ + ID2D1TransformGraph ID2D1TransformGraph_iface; + LONG refcount; + + struct d2d_transform_node_connection *inputs; + unsigned int input_count; + + struct d2d_transform_node *output; + + bool passthrough; + unsigned int passthrough_input; + + struct list nodes; +}; + +struct d2d_effect +{ + ID2D1Effect ID2D1Effect_iface; + ID2D1Image ID2D1Image_iface; + LONG refcount; + + ID2D1EffectImpl *impl; + struct d2d_effect_properties properties; + struct d2d_effect_context *effect_context; + struct d2d_transform_graph *graph; + ID2D1Image **inputs; + size_t inputs_size; + size_t input_count; +}; + +HRESULT d2d_effect_create(struct d2d_device_context *context, const CLSID *effect_id, + ID2D1Effect **effect); +void d2d_effect_init_properties(struct d2d_effect *effect, struct d2d_effect_properties *properties); +HRESULT d2d_effect_properties_add(struct d2d_effect_properties *props, const WCHAR *name, + UINT32 index, D2D1_PROPERTY_TYPE type, const WCHAR *value); +HRESULT d2d_effect_subproperties_add(struct d2d_effect_properties *props, const WCHAR *name, + UINT32 index, D2D1_PROPERTY_TYPE type, const WCHAR *value); +struct d2d_effect_property * d2d_effect_properties_get_property_by_name( + const struct d2d_effect_properties *properties, const WCHAR *name); +void d2d_effect_properties_cleanup(struct d2d_effect_properties *props); +HRESULT d2d_factory_register_builtin_effect(struct d2d_factory *factory, REFCLSID effect_id, + const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings, UINT32 binding_count, + PD2D1_EFFECT_FACTORY effect_factory); + +struct d2d_vertex_buffer +{ + ID2D1VertexBuffer ID2D1VertexBuffer_iface; + LONG refcount; +}; + +enum d2d_command_list_state +{ + D2D_COMMAND_LIST_STATE_INITIAL = 0, + D2D_COMMAND_LIST_STATE_ERROR, + D2D_COMMAND_LIST_STATE_OPEN, + D2D_COMMAND_LIST_STATE_CLOSED, +}; + +struct d2d_command_list +{ + ID2D1CommandList ID2D1CommandList_iface; + LONG refcount; + + ID2D1Factory *factory; + enum d2d_command_list_state state; + unsigned int flags; + + size_t size; + size_t capacity; + void *data; + + size_t objects_count; + size_t objects_capacity; + IUnknown **objects; +}; + +HRESULT d2d_command_list_create(ID2D1Factory *factory, struct d2d_command_list **command_list); +struct d2d_command_list *unsafe_impl_from_ID2D1CommandList(ID2D1CommandList *iface); +void d2d_command_list_begin_draw(struct d2d_command_list *command_list, const struct d2d_device_context *context); +void d2d_command_list_set_antialias_mode(struct d2d_command_list *command_list, D2D1_ANTIALIAS_MODE mode); +void d2d_command_list_set_primitive_blend(struct d2d_command_list *command_list, + D2D1_PRIMITIVE_BLEND primitive_blend); +void d2d_command_list_set_unit_mode(struct d2d_command_list *command_list, D2D1_UNIT_MODE mode); +void d2d_command_list_set_text_antialias_mode(struct d2d_command_list *command_list, + D2D1_TEXT_ANTIALIAS_MODE mode); +void d2d_command_list_set_tags(struct d2d_command_list *command_list, D2D1_TAG tag1, D2D1_TAG tag2); +void d2d_command_list_set_transform(struct d2d_command_list *command_list, + const D2D1_MATRIX_3X2_F *transform); +void d2d_command_list_push_clip(struct d2d_command_list *command_list, const D2D1_RECT_F *rect, + D2D1_ANTIALIAS_MODE antialias_mode); +void d2d_command_list_pop_clip(struct d2d_command_list *command_list); +void d2d_command_list_clear(struct d2d_command_list *command_list, const D2D1_COLOR_F *color); +void d2d_command_list_draw_line(struct d2d_command_list *command_list, const struct d2d_device_context *context, + D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *orig_brush, float stroke_width, + ID2D1StrokeStyle *stroke_style); +void d2d_command_list_draw_geometry(struct d2d_command_list *command_list, + const struct d2d_device_context *context, ID2D1Geometry *geometry, ID2D1Brush *orig_brush, + float stroke_width, ID2D1StrokeStyle *stroke_style); +void d2d_command_list_draw_rectangle(struct d2d_command_list *command_list, const struct d2d_device_context *context, + const D2D1_RECT_F *rect, ID2D1Brush *orig_brush, float stroke_width, ID2D1StrokeStyle *stroke_style); +void d2d_command_list_fill_geometry(struct d2d_command_list *command_list, + const struct d2d_device_context *context, ID2D1Geometry *geometry, ID2D1Brush *orig_brush, + ID2D1Brush *orig_opacity_brush); +void d2d_command_list_fill_rectangle(struct d2d_command_list *command_list, + const struct d2d_device_context *context, const D2D1_RECT_F *rect, ID2D1Brush *orig_brush); +void d2d_command_list_set_text_rendering_params(struct d2d_command_list *command_list, + IDWriteRenderingParams *params); +void d2d_command_list_draw_glyph_run(struct d2d_command_list *command_list, + const struct d2d_device_context *context, D2D1_POINT_2F origin, const DWRITE_GLYPH_RUN *run, + const DWRITE_GLYPH_RUN_DESCRIPTION *run_desc, ID2D1Brush *orig_brush, + DWRITE_MEASURING_MODE measuring_mode); +void d2d_command_list_draw_bitmap(struct d2d_command_list *command_list, ID2D1Bitmap *bitmap, + const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode, + const D2D1_RECT_F *src_rect, const D2D1_MATRIX_4X4_F *perspective_transform); +void d2d_command_list_draw_image(struct d2d_command_list *command_list, ID2D1Image *image, + const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, D2D1_INTERPOLATION_MODE interpolation_mode, + D2D1_COMPOSITE_MODE composite_mode); +void d2d_command_list_fill_mesh(struct d2d_command_list *command_list, const struct d2d_device_context *context, + ID2D1Mesh *mesh, ID2D1Brush *orig_brush); +void d2d_command_list_fill_opacity_mask(struct d2d_command_list *command_list, const struct d2d_device_context *context, + ID2D1Bitmap *bitmap, ID2D1Brush *orig_brush, const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect); +void d2d_command_list_push_layer(struct d2d_command_list *command_list, const struct d2d_device_context *context, + const D2D1_LAYER_PARAMETERS1 *params, ID2D1Layer *layer); +void d2d_command_list_pop_layer(struct d2d_command_list *command_list); + +static inline BOOL d2d_array_reserve(void **elements, size_t *capacity, size_t count, size_t size) +{ + size_t new_capacity, max_capacity; + void *new_elements; + + if (count <= *capacity) + return TRUE; + + max_capacity = ~(SIZE_T)0 / size; + if (count > max_capacity) + return FALSE; + + new_capacity = max(4, *capacity); + while (new_capacity < count && new_capacity <= max_capacity / 2) + new_capacity *= 2; + if (new_capacity < count) + new_capacity = max_capacity; + + if (!(new_elements = realloc(*elements, new_capacity * size))) + return FALSE; + + *elements = new_elements; + *capacity = new_capacity; + return TRUE; +} + +static inline void d2d_matrix_multiply(D2D_MATRIX_3X2_F *a, const D2D_MATRIX_3X2_F *b) +{ + D2D_MATRIX_3X2_F tmp = *a; + + a->_11 = tmp._11 * b->_11 + tmp._12 * b->_21; + a->_12 = tmp._11 * b->_12 + tmp._12 * b->_22; + a->_21 = tmp._21 * b->_11 + tmp._22 * b->_21; + a->_22 = tmp._21 * b->_12 + tmp._22 * b->_22; + a->_31 = tmp._31 * b->_11 + tmp._32 * b->_21 + b->_31; + a->_32 = tmp._31 * b->_12 + tmp._32 * b->_22 + b->_32; +} + +/* Dst must be different from src. */ +static inline BOOL d2d_matrix_invert(D2D_MATRIX_3X2_F *dst, const D2D_MATRIX_3X2_F *src) +{ + float d = src->_11 * src->_22 - src->_21 * src->_12; + + if (d == 0.0f) + return FALSE; + dst->_11 = src->_22 / d; + dst->_21 = -src->_21 / d; + dst->_31 = (src->_21 * src->_32 - src->_31 * src->_22) / d; + dst->_12 = -src->_12 / d; + dst->_22 = src->_11 / d; + dst->_32 = -(src->_11 * src->_32 - src->_31 * src->_12) / d; + + return TRUE; +} + +static inline void d2d_point_set(D2D1_POINT_2F *dst, float x, float y) +{ + dst->x = x; + dst->y = y; +} + +static inline float d2d_point_dot(const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1) +{ + return p0->x * p1->x + p0->y * p1->y; +} + +static inline void d2d_point_transform(D2D1_POINT_2F *dst, const D2D1_MATRIX_3X2_F *matrix, float x, float y) +{ + dst->x = x * matrix->_11 + y * matrix->_21 + matrix->_31; + dst->y = x * matrix->_12 + y * matrix->_22 + matrix->_32; +} + +static inline void d2d_rect_expand(D2D1_RECT_F *dst, const D2D1_POINT_2F *point) +{ + if (point->x < dst->left) + dst->left = point->x; + if (point->x > dst->right) + dst->right = point->x; + if (point->y < dst->top) + dst->top = point->y; + if (point->y > dst->bottom) + dst->bottom = point->y; +} + +static inline D2D1_INTERPOLATION_MODE d2d1_1_interp_mode_from_d2d1(D2D1_BITMAP_INTERPOLATION_MODE mode) +{ + return (D2D1_INTERPOLATION_MODE)mode; +} + +static inline const char *debug_d2d_color_f(const D2D1_COLOR_F *colour) +{ + if (!colour) + return "(null)"; + return wine_dbg_sprintf("{%.8e, %.8e, %.8e, %.8e}", colour->r, colour->g, colour->b, colour->a); +} + +static inline const char *debug_d2d_point_2f(const D2D1_POINT_2F *point) +{ + if (!point) + return "(null)"; + return wine_dbg_sprintf("{%.8e, %.8e}", point->x, point->y); +} + +static inline const char *debug_d2d_point_2l(const D2D1_POINT_2L *point) +{ + if (!point) + return "(null)"; + return wine_dbg_sprintf("{%ld, %ld}", point->x, point->y); +} + +static inline const char *debug_d2d_point_2u(const D2D1_POINT_2U *point) +{ + if (!point) + return "(null)"; + return wine_dbg_sprintf("{%u, %u}", point->x, point->y); +} + +static inline const char *debug_d2d_rect_f(const D2D1_RECT_F *rect) +{ + if (!rect) + return "(null)"; + return wine_dbg_sprintf("(%.8e, %.8e)-(%.8e, %.8e)", rect->left, rect->top, rect->right, rect->bottom); +} + +static inline const char *debug_d2d_rect_l(const D2D1_RECT_L *rect) +{ + if (!rect) + return "(null)"; + return wine_dbg_sprintf("(%ld, %ld)-(%ld, %ld)", rect->left, rect->top, rect->right, rect->bottom); +} + +static inline const char *debug_d2d_rect_u(const D2D1_RECT_U *rect) +{ + if (!rect) + return "(null)"; + return wine_dbg_sprintf("(%u, %u)-(%u, %u)", rect->left, rect->top, rect->right, rect->bottom); +} + +static inline const char *debug_d2d_rounded_rect(const D2D1_ROUNDED_RECT *rounded_rect) +{ + if (!rounded_rect) + return "(null)"; + return wine_dbg_sprintf("(%.8e, %.8e)-(%.8e, %.8e)[%.8e, %.8e]", rounded_rect->rect.left, rounded_rect->rect.top, + rounded_rect->rect.right, rounded_rect->rect.bottom, rounded_rect->radiusX, rounded_rect->radiusY); +} + +static inline const char *debug_d2d_ellipse(const D2D1_ELLIPSE *ellipse) +{ + if (!ellipse) + return "(null)"; + return wine_dbg_sprintf("(%.8e, %.8e)[%.8e, %.8e]", + ellipse->point.x, ellipse->point.y, ellipse->radiusX, ellipse->radiusY); +} + +#endif /* __WINE_D2D1_PRIVATE_H */ diff --git a/WineFix/lib/d2d1/src/dc_render_target.c b/WineFix/lib/d2d1/src/dc_render_target.c new file mode 100644 index 0000000..b09b77f --- /dev/null +++ b/WineFix/lib/d2d1/src/dc_render_target.c @@ -0,0 +1,901 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * Copyright 2016 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_dc_render_target *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_dc_render_target, ID2D1DCRenderTarget_iface); +} + +static HRESULT d2d_dc_render_target_present(IUnknown *outer_unknown) +{ + struct d2d_dc_render_target *render_target = impl_from_IUnknown(outer_unknown); + const RECT *dst_rect = &render_target->dst_rect; + RECT empty_rect; + HDC src_hdc; + HRESULT hr; + + if (!render_target->hdc) + return D2DERR_WRONG_STATE; + + if (FAILED(hr = IDXGISurface1_GetDC(render_target->dxgi_surface, FALSE, &src_hdc))) + { + WARN("GetDC() failed, %#lx.\n", hr); + return S_OK; + } + + BitBlt(render_target->hdc, dst_rect->left, dst_rect->top, dst_rect->right - dst_rect->left, + dst_rect->bottom - dst_rect->top, src_hdc, 0, 0, SRCCOPY); + + SetRectEmpty(&empty_rect); + IDXGISurface1_ReleaseDC(render_target->dxgi_surface, &empty_rect); + + return S_OK; +} + +static inline struct d2d_dc_render_target *impl_from_ID2D1DCRenderTarget(ID2D1DCRenderTarget *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_dc_render_target, ID2D1DCRenderTarget_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_QueryInterface(ID2D1DCRenderTarget *iface, REFIID iid, void **out) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1DCRenderTarget) + || IsEqualGUID(iid, &IID_ID2D1RenderTarget) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1DCRenderTarget_AddRef(iface); + *out = iface; + return S_OK; + } + + return IUnknown_QueryInterface(render_target->dxgi_inner, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_dc_render_target_AddRef(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + ULONG refcount = InterlockedIncrement(&render_target->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_dc_render_target_Release(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + ULONG refcount = InterlockedDecrement(&render_target->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + IUnknown_Release(render_target->dxgi_inner); + if (render_target->dxgi_surface) + IDXGISurface1_Release(render_target->dxgi_surface); + ID3D10Device1_Release(render_target->d3d_device); + free(render_target); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_GetFactory(ID2D1DCRenderTarget *iface, ID2D1Factory **factory) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1RenderTarget_GetFactory(render_target->dxgi_target, factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateBitmap(ID2D1DCRenderTarget *iface, + D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n", + iface, size.width, size.height, src_data, pitch, desc, bitmap); + + return ID2D1RenderTarget_CreateBitmap(render_target->dxgi_target, size, src_data, pitch, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateBitmapFromWicBitmap(ID2D1DCRenderTarget *iface, + IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n", + iface, bitmap_source, desc, bitmap); + + return ID2D1RenderTarget_CreateBitmapFromWicBitmap(render_target->dxgi_target, bitmap_source, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateSharedBitmap(ID2D1DCRenderTarget *iface, + REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n", + iface, debugstr_guid(iid), data, desc, bitmap); + + return ID2D1RenderTarget_CreateSharedBitmap(render_target->dxgi_target, iid, data, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateBitmapBrush(ID2D1DCRenderTarget *iface, + ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, + const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n", + iface, bitmap, bitmap_brush_desc, brush_desc, brush); + + return ID2D1RenderTarget_CreateBitmapBrush(render_target->dxgi_target, + bitmap, bitmap_brush_desc, brush_desc, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateSolidColorBrush(ID2D1DCRenderTarget *iface, + const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush); + + return ID2D1RenderTarget_CreateSolidColorBrush(render_target->dxgi_target, color, desc, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateGradientStopCollection(ID2D1DCRenderTarget *iface, + const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, + ID2D1GradientStopCollection **gradient) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n", + iface, stops, stop_count, gamma, extend_mode, gradient); + + return ID2D1RenderTarget_CreateGradientStopCollection(render_target->dxgi_target, + stops, stop_count, gamma, extend_mode, gradient); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateLinearGradientBrush(ID2D1DCRenderTarget *iface, + const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + return ID2D1RenderTarget_CreateLinearGradientBrush(render_target->dxgi_target, + gradient_brush_desc, brush_desc, gradient, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateRadialGradientBrush(ID2D1DCRenderTarget *iface, + const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + return ID2D1RenderTarget_CreateRadialGradientBrush(render_target->dxgi_target, + gradient_brush_desc, brush_desc, gradient, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateCompatibleRenderTarget(ID2D1DCRenderTarget *iface, + const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **render_target) +{ + struct d2d_dc_render_target *rt = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p,\n", + iface, size, pixel_size, format, options, render_target); + + return ID2D1RenderTarget_CreateCompatibleRenderTarget(rt->dxgi_target, + size, pixel_size, format, options, render_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateLayer(ID2D1DCRenderTarget *iface, + const D2D1_SIZE_F *size, ID2D1Layer **layer) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, size %p, layer %p.\n", iface, size, layer); + + return ID2D1RenderTarget_CreateLayer(render_target->dxgi_target, size, layer); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_CreateMesh(ID2D1DCRenderTarget *iface, ID2D1Mesh **mesh) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, mesh %p.\n", iface, mesh); + + return ID2D1RenderTarget_CreateMesh(render_target->dxgi_target, mesh); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawLine(ID2D1DCRenderTarget *iface, + D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawRectangle(ID2D1DCRenderTarget *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, rect %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_rect_f(rect), brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_FillRectangle(ID2D1DCRenderTarget *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, rect %s, brush %p.\n", iface, debug_d2d_rect_f(rect), brush); + + ID2D1RenderTarget_FillRectangle(render_target->dxgi_target, rect, brush); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawRoundedRectangle(ID2D1DCRenderTarget *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, rect, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawRoundedRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_FillRoundedRectangle(ID2D1DCRenderTarget *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush); + + ID2D1RenderTarget_FillRoundedRectangle(render_target->dxgi_target, rect, brush); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawEllipse(ID2D1DCRenderTarget *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, ellipse, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawEllipse(render_target->dxgi_target, ellipse, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_FillEllipse(ID2D1DCRenderTarget *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush); + + ID2D1RenderTarget_FillEllipse(render_target->dxgi_target, ellipse, brush); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawGeometry(ID2D1DCRenderTarget *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, geometry, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawGeometry(render_target->dxgi_target, geometry, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_FillGeometry(ID2D1DCRenderTarget *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush); + + ID2D1RenderTarget_FillGeometry(render_target->dxgi_target, geometry, brush, opacity_brush); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_FillMesh(ID2D1DCRenderTarget *iface, + ID2D1Mesh *mesh, ID2D1Brush *brush) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, mesh %p, brush %p.\n", iface, mesh, brush); + + ID2D1RenderTarget_FillMesh(render_target->dxgi_target, mesh, brush); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_FillOpacityMask(ID2D1DCRenderTarget *iface, + ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content, + const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, mask %p, brush %p, content %#x, dst_rect %s, src_rect %s.\n", + iface, mask, brush, content, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect)); + + ID2D1RenderTarget_FillOpacityMask(render_target->dxgi_target, + mask, brush, content, dst_rect, src_rect); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawBitmap(ID2D1DCRenderTarget *iface, + ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, + D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, src_rect %s.\n", + iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, debug_d2d_rect_f(src_rect)); + + ID2D1RenderTarget_DrawBitmap(render_target->dxgi_target, + bitmap, dst_rect, opacity, interpolation_mode, src_rect); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawText(ID2D1DCRenderTarget *iface, + const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect, + ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, " + "brush %p, options %#x, measuring_mode %#x.\n", + iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect), + brush, options, measuring_mode); + + ID2D1RenderTarget_DrawText(render_target->dxgi_target, string, string_len, + text_format, layout_rect, brush, options, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawTextLayout(ID2D1DCRenderTarget *iface, + D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); + + ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_DrawGlyphRun(ID2D1DCRenderTarget *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, + DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); + + ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target, + baseline_origin, glyph_run, brush, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SetTransform(ID2D1DCRenderTarget *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + ID2D1RenderTarget_SetTransform(render_target->dxgi_target, transform); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_GetTransform(ID2D1DCRenderTarget *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + ID2D1RenderTarget_GetTransform(render_target->dxgi_target, transform); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SetAntialiasMode(ID2D1DCRenderTarget *iface, + D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + ID2D1RenderTarget_SetAntialiasMode(render_target->dxgi_target, antialias_mode); +} + +static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_dc_render_target_GetAntialiasMode(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetAntialiasMode(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SetTextAntialiasMode(ID2D1DCRenderTarget *iface, + D2D1_TEXT_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + ID2D1RenderTarget_SetTextAntialiasMode(render_target->dxgi_target, antialias_mode); +} + +static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_dc_render_target_GetTextAntialiasMode(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetTextAntialiasMode(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SetTextRenderingParams(ID2D1DCRenderTarget *iface, + IDWriteRenderingParams *text_rendering_params) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + ID2D1RenderTarget_SetTextRenderingParams(render_target->dxgi_target, text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_GetTextRenderingParams(ID2D1DCRenderTarget *iface, + IDWriteRenderingParams **text_rendering_params) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + ID2D1RenderTarget_GetTextRenderingParams(render_target->dxgi_target, text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SetTags(ID2D1DCRenderTarget *iface, D2D1_TAG tag1, D2D1_TAG tag2) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2)); + + ID2D1RenderTarget_SetTags(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_GetTags(ID2D1DCRenderTarget *iface, D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + ID2D1RenderTarget_GetTags(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_PushLayer(ID2D1DCRenderTarget *iface, + const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, layer_parameters %p, layer %p.\n", iface, layer_parameters, layer); + + ID2D1RenderTarget_PushLayer(render_target->dxgi_target, layer_parameters, layer); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_PopLayer(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_PopLayer(render_target->dxgi_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_Flush(ID2D1DCRenderTarget *iface, D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + return ID2D1RenderTarget_Flush(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SaveDrawingState(ID2D1DCRenderTarget *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + ID2D1RenderTarget_SaveDrawingState(render_target->dxgi_target, state_block); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_RestoreDrawingState(ID2D1DCRenderTarget *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + ID2D1RenderTarget_RestoreDrawingState(render_target->dxgi_target, state_block); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_PushAxisAlignedClip(ID2D1DCRenderTarget *iface, + const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, clip_rect %s, antialias_mode %#x.\n", iface, debug_d2d_rect_f(clip_rect), antialias_mode); + + ID2D1RenderTarget_PushAxisAlignedClip(render_target->dxgi_target, clip_rect, antialias_mode); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_PopAxisAlignedClip(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_PopAxisAlignedClip(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_Clear(ID2D1DCRenderTarget *iface, const D2D1_COLOR_F *color) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, color %p.\n", iface, color); + + ID2D1RenderTarget_Clear(render_target->dxgi_target, color); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_BeginDraw(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + const RECT *dst_rect = &render_target->dst_rect; + HDC hdc; + + TRACE("iface %p.\n", iface); + + if (render_target->dxgi_surface) + { + if (SUCCEEDED(IDXGISurface1_GetDC(render_target->dxgi_surface, TRUE, &hdc))) + { + BitBlt(hdc, 0, 0, dst_rect->right - dst_rect->left, dst_rect->bottom - dst_rect->top, + render_target->hdc, dst_rect->left, dst_rect->top, SRCCOPY); + IDXGISurface1_ReleaseDC(render_target->dxgi_surface, NULL); + } + } + + ID2D1RenderTarget_BeginDraw(render_target->dxgi_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_EndDraw(ID2D1DCRenderTarget *iface, + D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + return ID2D1RenderTarget_EndDraw(render_target->dxgi_target, tag1, tag2); +} + +static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_dc_render_target_GetPixelFormat(ID2D1DCRenderTarget *iface, + D2D1_PIXEL_FORMAT *format) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, format %p.\n", iface, format); + + *format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target); + return format; +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_SetDpi(ID2D1DCRenderTarget *iface, float dpi_x, float dpi_y) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y); + + ID2D1RenderTarget_SetDpi(render_target->dxgi_target, dpi_x, dpi_y); +} + +static void STDMETHODCALLTYPE d2d_dc_render_target_GetDpi(ID2D1DCRenderTarget *iface, float *dpi_x, float *dpi_y) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + ID2D1RenderTarget_GetDpi(render_target->dxgi_target, dpi_x, dpi_y); +} + +static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_dc_render_target_GetSize(ID2D1DCRenderTarget *iface, D2D1_SIZE_F *size) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, size %p.\n", iface, size); + + if (render_target->hdc) + *size = ID2D1RenderTarget_GetSize(render_target->dxgi_target); + else + size->width = size->height = 0.0f; + + return size; +} + +static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_dc_render_target_GetPixelSize(ID2D1DCRenderTarget *iface, + D2D1_SIZE_U *pixel_size) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p, pixel_size %p.\n", iface, pixel_size); + + if (render_target->hdc) + *pixel_size = ID2D1RenderTarget_GetPixelSize(render_target->dxgi_target); + else + pixel_size->width = pixel_size->height = 0; + + return pixel_size; +} + +static UINT32 STDMETHODCALLTYPE d2d_dc_render_target_GetMaximumBitmapSize(ID2D1DCRenderTarget *iface) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetMaximumBitmapSize(render_target->dxgi_target); +} + +static BOOL STDMETHODCALLTYPE d2d_dc_render_target_IsSupported(ID2D1DCRenderTarget *iface, + const D2D1_RENDER_TARGET_PROPERTIES *desc) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + const D2D1_RENDER_TARGET_PROPERTIES *target_desc = &render_target->desc; + D2D1_PIXEL_FORMAT pixel_format; + + TRACE("iface %p, desc %p.\n", iface, desc); + + if (desc->type != D2D1_RENDER_TARGET_TYPE_DEFAULT + && target_desc->type != desc->type) + { + return FALSE; + } + + pixel_format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target); + + if (desc->pixelFormat.format != DXGI_FORMAT_UNKNOWN + && pixel_format.format != desc->pixelFormat.format) + { + return FALSE; + } + + if (desc->pixelFormat.alphaMode != D2D1_ALPHA_MODE_UNKNOWN + && pixel_format.alphaMode != desc->pixelFormat.alphaMode) + { + return FALSE; + } + + return (target_desc->usage & desc->usage) == desc->usage; +} + +static HRESULT STDMETHODCALLTYPE d2d_dc_render_target_BindDC(ID2D1DCRenderTarget *iface, + const HDC hdc, const RECT *rect) +{ + struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + struct d2d_bitmap *bitmap_impl; + IDXGISurface1 *dxgi_surface; + ID2D1DeviceContext *context; + D2D1_SIZE_U bitmap_size; + ID2D1Bitmap *bitmap; + DWORD obj_type; + HRESULT hr; + + TRACE("iface %p, hdc %p, rect %s.\n", iface, hdc, wine_dbgstr_rect(rect)); + + obj_type = GetObjectType(hdc); + if (obj_type != OBJ_DC && obj_type != OBJ_ENHMETADC && obj_type != OBJ_MEMDC) + return E_INVALIDARG; + + /* Switch dxgi target to new surface. */ + ID2D1RenderTarget_QueryInterface(render_target->dxgi_target, &IID_ID2D1DeviceContext, (void **)&context); + + bitmap_size.width = rect->right - rect->left; + bitmap_size.height = rect->bottom - rect->top; + + memset(&bitmap_desc, 0, sizeof(bitmap_desc)); + bitmap_desc.pixelFormat = render_target->desc.pixelFormat; + bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW | + D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE; + if (FAILED(hr = ID2D1DeviceContext_CreateBitmap(context, bitmap_size, NULL, 0, &bitmap_desc, + (ID2D1Bitmap1 **)&bitmap))) + { + WARN("Failed to create target bitmap, hr %#lx.\n", hr); + ID2D1DeviceContext_Release(context); + return hr; + } + + bitmap_impl = unsafe_impl_from_ID2D1Bitmap(bitmap); + ID3D11Resource_QueryInterface(bitmap_impl->resource, &IID_IDXGISurface1, (void **)&dxgi_surface); + + ID2D1DeviceContext_SetTarget(context, (ID2D1Image *)bitmap); + ID2D1Bitmap_Release(bitmap); + ID2D1DeviceContext_Release(context); + + if (render_target->dxgi_surface) + IDXGISurface1_Release(render_target->dxgi_surface); + render_target->dxgi_surface = dxgi_surface; + + render_target->hdc = hdc; + render_target->dst_rect = *rect; + + return hr; +} + +static const struct ID2D1DCRenderTargetVtbl d2d_dc_render_target_vtbl = +{ + d2d_dc_render_target_QueryInterface, + d2d_dc_render_target_AddRef, + d2d_dc_render_target_Release, + d2d_dc_render_target_GetFactory, + d2d_dc_render_target_CreateBitmap, + d2d_dc_render_target_CreateBitmapFromWicBitmap, + d2d_dc_render_target_CreateSharedBitmap, + d2d_dc_render_target_CreateBitmapBrush, + d2d_dc_render_target_CreateSolidColorBrush, + d2d_dc_render_target_CreateGradientStopCollection, + d2d_dc_render_target_CreateLinearGradientBrush, + d2d_dc_render_target_CreateRadialGradientBrush, + d2d_dc_render_target_CreateCompatibleRenderTarget, + d2d_dc_render_target_CreateLayer, + d2d_dc_render_target_CreateMesh, + d2d_dc_render_target_DrawLine, + d2d_dc_render_target_DrawRectangle, + d2d_dc_render_target_FillRectangle, + d2d_dc_render_target_DrawRoundedRectangle, + d2d_dc_render_target_FillRoundedRectangle, + d2d_dc_render_target_DrawEllipse, + d2d_dc_render_target_FillEllipse, + d2d_dc_render_target_DrawGeometry, + d2d_dc_render_target_FillGeometry, + d2d_dc_render_target_FillMesh, + d2d_dc_render_target_FillOpacityMask, + d2d_dc_render_target_DrawBitmap, + d2d_dc_render_target_DrawText, + d2d_dc_render_target_DrawTextLayout, + d2d_dc_render_target_DrawGlyphRun, + d2d_dc_render_target_SetTransform, + d2d_dc_render_target_GetTransform, + d2d_dc_render_target_SetAntialiasMode, + d2d_dc_render_target_GetAntialiasMode, + d2d_dc_render_target_SetTextAntialiasMode, + d2d_dc_render_target_GetTextAntialiasMode, + d2d_dc_render_target_SetTextRenderingParams, + d2d_dc_render_target_GetTextRenderingParams, + d2d_dc_render_target_SetTags, + d2d_dc_render_target_GetTags, + d2d_dc_render_target_PushLayer, + d2d_dc_render_target_PopLayer, + d2d_dc_render_target_Flush, + d2d_dc_render_target_SaveDrawingState, + d2d_dc_render_target_RestoreDrawingState, + d2d_dc_render_target_PushAxisAlignedClip, + d2d_dc_render_target_PopAxisAlignedClip, + d2d_dc_render_target_Clear, + d2d_dc_render_target_BeginDraw, + d2d_dc_render_target_EndDraw, + d2d_dc_render_target_GetPixelFormat, + d2d_dc_render_target_SetDpi, + d2d_dc_render_target_GetDpi, + d2d_dc_render_target_GetSize, + d2d_dc_render_target_GetPixelSize, + d2d_dc_render_target_GetMaximumBitmapSize, + d2d_dc_render_target_IsSupported, + d2d_dc_render_target_BindDC, +}; + +static const struct d2d_device_context_ops d2d_dc_render_target_ops = +{ + d2d_dc_render_target_present, +}; + +HRESULT d2d_dc_render_target_init(struct d2d_dc_render_target *render_target, ID2D1Factory1 *factory, + ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc) +{ + IDXGIDevice *dxgi_device; + ID2D1Device *device; + HRESULT hr; + + render_target->ID2D1DCRenderTarget_iface.lpVtbl = &d2d_dc_render_target_vtbl; + + /* Set with BindDC(). */ + SetRectEmpty(&render_target->dst_rect); + render_target->hdc = NULL; + + render_target->desc = *desc; + render_target->desc.usage |= D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE; + + switch (desc->pixelFormat.format) + { + case DXGI_FORMAT_B8G8R8A8_UNORM: + if (desc->pixelFormat.alphaMode == D2D1_ALPHA_MODE_PREMULTIPLIED + || desc->pixelFormat.alphaMode == D2D1_ALPHA_MODE_IGNORE) + break; + + default: + FIXME("Unhandled format %#x, alpha mode %u.\n", desc->pixelFormat.format, desc->pixelFormat.alphaMode); + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; + } + + if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device))) + { + WARN("Failed to get DXGI device interface, hr %#lx.\n", hr); + return hr; + } + + hr = d2d_factory_create_device(factory, dxgi_device, false, &IID_ID2D1Device, (void **)&device); + IDXGIDevice_Release(dxgi_device); + if (FAILED(hr)) + { + WARN("Failed to create D2D device, hr %#lx.\n", hr); + return hr; + } + + hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1* )device), NULL, + (IUnknown *)&render_target->ID2D1DCRenderTarget_iface, &d2d_dc_render_target_ops, + desc, (void **)&render_target->dxgi_inner); + ID2D1Device_Release(device); + if (FAILED(hr)) + { + WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr); + return hr; + } + + if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner, + &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target))) + { + WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr); + IUnknown_Release(render_target->dxgi_inner); + return hr; + } + + render_target->d3d_device = d3d_device; + ID3D10Device1_AddRef(render_target->d3d_device); + + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/device.c b/WineFix/lib/d2d1/src/device.c new file mode 100644 index 0000000..3969046 --- /dev/null +++ b/WineFix/lib/d2d1/src/device.c @@ -0,0 +1,4734 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" +#include + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +#define INITIAL_CLIP_STACK_SIZE 4 + +static const D2D1_MATRIX_3X2_F identity = +{{{ + 1.0f, 0.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, +}}}; + +struct d2d_draw_text_layout_ctx +{ + ID2D1Brush *brush; + D2D1_DRAW_TEXT_OPTIONS options; +}; + +static inline struct d2d_device *impl_from_ID2D1Device(ID2D1Device6 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_device, ID2D1Device6_iface); +} + +static ID2D1Brush *d2d_draw_get_text_brush(struct d2d_draw_text_layout_ctx *context, IUnknown *effect) +{ + ID2D1Brush *brush = NULL; + + if (effect && SUCCEEDED(IUnknown_QueryInterface(effect, &IID_ID2D1Brush, (void**)&brush))) + return brush; + + ID2D1Brush_AddRef(context->brush); + return context->brush; +} + +static void d2d_rect_intersect(D2D1_RECT_F *dst, const D2D1_RECT_F *src) +{ + if (src->left > dst->left) + dst->left = src->left; + if (src->top > dst->top) + dst->top = src->top; + if (src->right < dst->right) + dst->right = src->right; + if (src->bottom < dst->bottom) + dst->bottom = src->bottom; +} + +static void d2d_rect_set(D2D1_RECT_F *dst, float left, float top, float right, float bottom) +{ + dst->left = left; + dst->top = top; + dst->right = right; + dst->bottom = bottom; +} + +static void d2d_size_set(D2D1_SIZE_U *dst, float width, float height) +{ + dst->width = width; + dst->height = height; +} + +static BOOL d2d_clip_stack_init(struct d2d_clip_stack *stack) +{ + if (!(stack->stack = malloc(INITIAL_CLIP_STACK_SIZE * sizeof(*stack->stack)))) + return FALSE; + + stack->size = INITIAL_CLIP_STACK_SIZE; + stack->count = 0; + + return TRUE; +} + +static void d2d_clip_stack_cleanup(struct d2d_clip_stack *stack) +{ + free(stack->stack); +} + +static BOOL d2d_clip_stack_push(struct d2d_clip_stack *stack, const D2D1_RECT_F *rect) +{ + D2D1_RECT_F r; + + if (!d2d_array_reserve((void **)&stack->stack, &stack->size, stack->count + 1, sizeof(*stack->stack))) + return FALSE; + + r = *rect; + if (stack->count) + d2d_rect_intersect(&r, &stack->stack[stack->count - 1]); + stack->stack[stack->count++] = r; + + return TRUE; +} + +static void d2d_clip_stack_pop(struct d2d_clip_stack *stack) +{ + if (!stack->count) + return; + --stack->count; +} + +static void d2d_device_context_draw(struct d2d_device_context *render_target, enum d2d_shape_type shape_type, + ID3D11Buffer *ib, unsigned int index_count, ID3D11Buffer *vb, unsigned int vb_stride, + struct d2d_brush *brush, struct d2d_brush *opacity_brush) +{ + struct d2d_shape_resources *shape_resources = &render_target->shape_resources[shape_type]; + ID3DDeviceContextState *prev_state; + ID3D11Device1 *device = render_target->d3d_device; + ID3D11DeviceContext1 *context; + ID3D11Buffer *vs_cb = render_target->vs_cb, *ps_cb = render_target->ps_cb; + D3D11_RECT scissor_rect; + unsigned int offset; + D3D11_VIEWPORT vp; + + vp.TopLeftX = 0; + vp.TopLeftY = 0; + vp.Width = render_target->pixel_size.width; + vp.Height = render_target->pixel_size.height; + vp.MinDepth = 0.0f; + vp.MaxDepth = 1.0f; + + if (render_target->cs) + EnterCriticalSection(render_target->cs); + + ID3D11Device1_GetImmediateContext1(device, &context); + ID3D11DeviceContext1_SwapDeviceContextState(context, render_target->d3d_state, &prev_state); + + ID3D11DeviceContext1_IASetInputLayout(context, shape_resources->il); + ID3D11DeviceContext1_IASetPrimitiveTopology(context, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + ID3D11DeviceContext1_IASetIndexBuffer(context, ib, DXGI_FORMAT_R16_UINT, 0); + offset = 0; + ID3D11DeviceContext1_IASetVertexBuffers(context, 0, 1, &vb, &vb_stride, &offset); + ID3D11DeviceContext1_VSSetConstantBuffers(context, 0, 1, &vs_cb); + ID3D11DeviceContext1_VSSetShader(context, shape_resources->vs, NULL, 0); + ID3D11DeviceContext1_PSSetConstantBuffers(context, 0, 1, &ps_cb); + ID3D11DeviceContext1_PSSetShader(context, render_target->ps, NULL, 0); + ID3D11DeviceContext1_RSSetViewports(context, 1, &vp); + if (render_target->clip_stack.count) + { + const D2D1_RECT_F *clip_rect; + + clip_rect = &render_target->clip_stack.stack[render_target->clip_stack.count - 1]; + scissor_rect.left = ceilf(clip_rect->left - 0.5f); + scissor_rect.top = ceilf(clip_rect->top - 0.5f); + scissor_rect.right = ceilf(clip_rect->right - 0.5f); + scissor_rect.bottom = ceilf(clip_rect->bottom - 0.5f); + } + else + { + scissor_rect.left = 0.0f; + scissor_rect.top = 0.0f; + scissor_rect.right = render_target->pixel_size.width; + scissor_rect.bottom = render_target->pixel_size.height; + } + ID3D11DeviceContext1_RSSetScissorRects(context, 1, &scissor_rect); + ID3D11DeviceContext1_RSSetState(context, render_target->rs); + ID3D11DeviceContext1_OMSetRenderTargets(context, 1, &render_target->target.bitmap->rtv, NULL); + if (brush) + { + ID3D11DeviceContext1_OMSetBlendState(context, render_target->bs, NULL, D3D11_DEFAULT_SAMPLE_MASK); + d2d_brush_bind_resources(brush, render_target, 0); + } + else + { + ID3D11DeviceContext1_OMSetBlendState(context, NULL, NULL, D3D11_DEFAULT_SAMPLE_MASK); + } + if (opacity_brush) + d2d_brush_bind_resources(opacity_brush, render_target, 1); + + if (ib) + ID3D11DeviceContext1_DrawIndexed(context, index_count, 0, 0); + else + ID3D11DeviceContext1_Draw(context, index_count, 0); + + ID3D11DeviceContext1_SwapDeviceContextState(context, prev_state, NULL); + ID3D11DeviceContext1_Release(context); + ID3DDeviceContextState_Release(prev_state); + + if (render_target->cs) + LeaveCriticalSection(render_target->cs); +} + +static void d2d_device_context_set_error(struct d2d_device_context *context, HRESULT code) +{ + context->error.code = code; + context->error.tag1 = context->drawing_state.tag1; + context->error.tag2 = context->drawing_state.tag2; +} + +static inline struct d2d_device_context *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_device_context, IUnknown_iface); +} + +static inline struct d2d_device_context *impl_from_ID2D1DeviceContext(ID2D1DeviceContext6 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_device_context, ID2D1DeviceContext6_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out) +{ + struct d2d_device_context *context = impl_from_IUnknown(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1DeviceContext6) + || IsEqualGUID(iid, &IID_ID2D1DeviceContext5) + || IsEqualGUID(iid, &IID_ID2D1DeviceContext4) + || IsEqualGUID(iid, &IID_ID2D1DeviceContext3) + || IsEqualGUID(iid, &IID_ID2D1DeviceContext2) + || IsEqualGUID(iid, &IID_ID2D1DeviceContext1) + || IsEqualGUID(iid, &IID_ID2D1DeviceContext) + || IsEqualGUID(iid, &IID_ID2D1RenderTarget) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1DeviceContext6_AddRef(&context->ID2D1DeviceContext6_iface); + *out = &context->ID2D1DeviceContext6_iface; + return S_OK; + } + else if (IsEqualGUID(iid, &IID_ID2D1GdiInteropRenderTarget)) + { + ID2D1GdiInteropRenderTarget_AddRef(&context->ID2D1GdiInteropRenderTarget_iface); + *out = &context->ID2D1GdiInteropRenderTarget_iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_device_context_inner_AddRef(IUnknown *iface) +{ + struct d2d_device_context *context = impl_from_IUnknown(iface); + ULONG refcount = InterlockedIncrement(&context->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_device_context_inner_Release(IUnknown *iface) +{ + struct d2d_device_context *context = impl_from_IUnknown(iface); + ULONG refcount = InterlockedDecrement(&context->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + unsigned int i, j, k; + + d2d_clip_stack_cleanup(&context->clip_stack); + IDWriteRenderingParams_Release(context->default_text_rendering_params); + if (context->text_rendering_params) + IDWriteRenderingParams_Release(context->text_rendering_params); + if (context->bs) + ID3D11BlendState_Release(context->bs); + ID3D11RasterizerState_Release(context->rs); + ID3D11Buffer_Release(context->vb); + ID3D11Buffer_Release(context->ib); + ID3D11Buffer_Release(context->ps_cb); + ID3D11PixelShader_Release(context->ps); + ID3D11Buffer_Release(context->vs_cb); + for (i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i) + { + ID3D11VertexShader_Release(context->shape_resources[i].vs); + ID3D11InputLayout_Release(context->shape_resources[i].il); + } + for (i = 0; i < D2D_SAMPLER_INTERPOLATION_MODE_COUNT; ++i) + { + for (j = 0; j < D2D_SAMPLER_EXTEND_MODE_COUNT; ++j) + { + for (k = 0; k < D2D_SAMPLER_EXTEND_MODE_COUNT; ++k) + { + if (context->sampler_states[i][j][k]) + ID3D11SamplerState_Release(context->sampler_states[i][j][k]); + } + } + } + if (context->d3d_state) + ID3DDeviceContextState_Release(context->d3d_state); + if (context->target.object) + IUnknown_Release(context->target.object); + ID3D11Device1_Release(context->d3d_device); + ID2D1Factory_Release(context->factory); + ID2D1Device6_Release(&context->device->ID2D1Device6_iface); + d2d_device_indexed_objects_clear(&context->vertex_buffers); + free(context); + } + + return refcount; +} + +static const struct IUnknownVtbl d2d_device_context_inner_unknown_vtbl = +{ + d2d_device_context_inner_QueryInterface, + d2d_device_context_inner_AddRef, + d2d_device_context_inner_Release, +}; + +static HRESULT STDMETHODCALLTYPE d2d_device_context_QueryInterface(ID2D1DeviceContext6 *iface, + REFIID iid, void **out) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + return IUnknown_QueryInterface(context->outer_unknown, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_device_context_AddRef(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + return IUnknown_AddRef(context->outer_unknown); +} + +static ULONG STDMETHODCALLTYPE d2d_device_context_Release(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + return IUnknown_Release(context->outer_unknown); +} + +static void STDMETHODCALLTYPE d2d_device_context_GetFactory(ID2D1DeviceContext6 *iface, ID2D1Factory **factory) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + *factory = render_target->factory; + ID2D1Factory_AddRef(*factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmap(ID2D1DeviceContext6 *iface, + D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + struct d2d_bitmap *object; + HRESULT hr; + + TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n", + iface, size.width, size.height, src_data, pitch, desc, bitmap); + + if (desc) + { + memcpy(&bitmap_desc, desc, sizeof(*desc)); + bitmap_desc.bitmapOptions = 0; + bitmap_desc.colorContext = NULL; + } + + if (SUCCEEDED(hr = d2d_bitmap_create(context, size, src_data, pitch, desc ? &bitmap_desc : NULL, &object))) + *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromWicBitmap(ID2D1DeviceContext6 *iface, + IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + struct d2d_bitmap *object; + HRESULT hr; + + TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n", + iface, bitmap_source, desc, bitmap); + + if (desc) + { + memcpy(&bitmap_desc, desc, sizeof(*desc)); + bitmap_desc.bitmapOptions = 0; + bitmap_desc.colorContext = NULL; + } + + if (SUCCEEDED(hr = d2d_bitmap_create_from_wic_bitmap(context, bitmap_source, desc ? &bitmap_desc : NULL, &object))) + *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSharedBitmap(ID2D1DeviceContext6 *iface, + REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + struct d2d_bitmap *object; + HRESULT hr; + + TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n", + iface, debugstr_guid(iid), data, desc, bitmap); + + if (desc) + { + memcpy(&bitmap_desc, desc, sizeof(*desc)); + if (IsEqualIID(iid, &IID_IDXGISurface) || IsEqualIID(iid, &IID_IDXGISurface1)) + bitmap_desc.bitmapOptions = d2d_get_bitmap_options_for_surface(data); + else + bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW; + bitmap_desc.colorContext = NULL; + } + + if (SUCCEEDED(hr = d2d_bitmap_create_shared(context, iid, data, desc ? &bitmap_desc : NULL, &object))) + *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapBrush(ID2D1DeviceContext6 *iface, + ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, + const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *object; + HRESULT hr; + + TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n", + iface, bitmap, bitmap_brush_desc, brush_desc, brush); + + if (SUCCEEDED(hr = d2d_bitmap_brush_create(context->factory, bitmap, (const D2D1_BITMAP_BRUSH_PROPERTIES1 *)bitmap_brush_desc, + brush_desc, &object))) + *brush = (ID2D1BitmapBrush *)&object->ID2D1Brush_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSolidColorBrush(ID2D1DeviceContext6 *iface, + const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *object; + HRESULT hr; + + TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush); + + if (SUCCEEDED(hr = d2d_solid_color_brush_create(render_target->factory, color, desc, &object))) + *brush = (ID2D1SolidColorBrush *)&object->ID2D1Brush_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateGradientStopCollection(ID2D1DeviceContext6 *iface, + const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, + ID2D1GradientStopCollection **gradient) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_gradient *object; + HRESULT hr; + + TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n", + iface, stops, stop_count, gamma, extend_mode, gradient); + + if (SUCCEEDED(hr = d2d_gradient_create(render_target->factory, render_target->d3d_device, + stops, stop_count, gamma, extend_mode, &object))) + *gradient = &object->ID2D1GradientStopCollection_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateLinearGradientBrush(ID2D1DeviceContext6 *iface, + const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *object; + HRESULT hr; + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + if (SUCCEEDED(hr = d2d_linear_gradient_brush_create(render_target->factory, gradient_brush_desc, brush_desc, + gradient, &object))) + *brush = (ID2D1LinearGradientBrush *)&object->ID2D1Brush_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateRadialGradientBrush(ID2D1DeviceContext6 *iface, + const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *object; + HRESULT hr; + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + if (SUCCEEDED(hr = d2d_radial_gradient_brush_create(render_target->factory, + gradient_brush_desc, brush_desc, gradient, &object))) + *brush = (ID2D1RadialGradientBrush *)&object->ID2D1Brush_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateCompatibleRenderTarget(ID2D1DeviceContext6 *iface, + const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **rt) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_bitmap_render_target *object; + HRESULT hr; + + TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p.\n", + iface, size, pixel_size, format, options, rt); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_bitmap_render_target_init(object, render_target, size, pixel_size, + format, options))) + { + WARN("Failed to initialise render target, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created render target %p.\n", object); + *rt = &object->ID2D1BitmapRenderTarget_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateLayer(ID2D1DeviceContext6 *iface, + const D2D1_SIZE_F *size, ID2D1Layer **layer) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_layer *object; + HRESULT hr; + + TRACE("iface %p, size %p, layer %p.\n", iface, size, layer); + + if (SUCCEEDED(hr = d2d_layer_create(render_target->factory, size, &object))) + *layer = &object->ID2D1Layer_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateMesh(ID2D1DeviceContext6 *iface, ID2D1Mesh **mesh) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_mesh *object; + HRESULT hr; + + TRACE("iface %p, mesh %p.\n", iface, mesh); + + if (SUCCEEDED(hr = d2d_mesh_create(render_target->factory, &object))) + *mesh = &object->ID2D1Mesh_iface; + + return hr; +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawLine(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + ID2D1PathGeometry *geometry; + ID2D1GeometrySink *sink; + HRESULT hr; + + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_line(context->target.command_list, context, p0, p1, brush, stroke_width, stroke_style); + return; + } + + if (FAILED(hr = ID2D1Factory_CreatePathGeometry(context->factory, &geometry))) + { + WARN("Failed to create path geometry, hr %#lx.\n", hr); + return; + } + + if (FAILED(hr = ID2D1PathGeometry_Open(geometry, &sink))) + { + WARN("Failed to open geometry sink, hr %#lx.\n", hr); + ID2D1PathGeometry_Release(geometry); + return; + } + + ID2D1GeometrySink_BeginFigure(sink, p0, D2D1_FIGURE_BEGIN_HOLLOW); + ID2D1GeometrySink_AddLine(sink, p1); + ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN); + if (FAILED(hr = ID2D1GeometrySink_Close(sink))) + WARN("Failed to close geometry sink, hr %#lx.\n", hr); + ID2D1GeometrySink_Release(sink); + + ID2D1DeviceContext6_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style); + ID2D1PathGeometry_Release(geometry); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawRectangle(ID2D1DeviceContext6 *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + ID2D1RectangleGeometry *geometry; + HRESULT hr; + + TRACE("iface %p, rect %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_rect_f(rect), brush, stroke_width, stroke_style); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_rectangle(context->target.command_list, context, rect, brush, stroke_width, stroke_style); + return; + } + + if (FAILED(hr = ID2D1Factory_CreateRectangleGeometry(context->factory, rect, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + ID2D1DeviceContext6_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style); + ID2D1RectangleGeometry_Release(geometry); +} + +static void STDMETHODCALLTYPE d2d_device_context_FillRectangle(ID2D1DeviceContext6 *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + ID2D1RectangleGeometry *geometry; + HRESULT hr; + + TRACE("iface %p, rect %s, brush %p.\n", iface, debug_d2d_rect_f(rect), brush); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_fill_rectangle(context->target.command_list, context, rect, brush); + return; + } + + if (FAILED(hr = ID2D1Factory_CreateRectangleGeometry(context->factory, rect, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + ID2D1DeviceContext6_FillGeometry(iface, (ID2D1Geometry *)geometry, brush, NULL); + ID2D1RectangleGeometry_Release(geometry); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawRoundedRectangle(ID2D1DeviceContext6 *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + ID2D1RoundedRectangleGeometry *geometry; + HRESULT hr; + + TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, rect, brush, stroke_width, stroke_style); + + if (FAILED(render_target->error.code)) + return; + + if (FAILED(hr = ID2D1Factory_CreateRoundedRectangleGeometry(render_target->factory, rect, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + ID2D1DeviceContext6_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style); + ID2D1RoundedRectangleGeometry_Release(geometry); +} + +static void STDMETHODCALLTYPE d2d_device_context_FillRoundedRectangle(ID2D1DeviceContext6 *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + ID2D1RoundedRectangleGeometry *geometry; + HRESULT hr; + + TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush); + + if (FAILED(render_target->error.code)) + return; + + if (FAILED(hr = ID2D1Factory_CreateRoundedRectangleGeometry(render_target->factory, rect, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + ID2D1DeviceContext6_FillGeometry(iface, (ID2D1Geometry *)geometry, brush, NULL); + ID2D1RoundedRectangleGeometry_Release(geometry); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawEllipse(ID2D1DeviceContext6 *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + ID2D1EllipseGeometry *geometry; + HRESULT hr; + + TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, ellipse, brush, stroke_width, stroke_style); + + if (FAILED(render_target->error.code)) + return; + + if (FAILED(hr = ID2D1Factory_CreateEllipseGeometry(render_target->factory, ellipse, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + ID2D1DeviceContext6_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style); + ID2D1EllipseGeometry_Release(geometry); +} + +static void STDMETHODCALLTYPE d2d_device_context_FillEllipse(ID2D1DeviceContext6 *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + ID2D1EllipseGeometry *geometry; + HRESULT hr; + + TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush); + + if (FAILED(render_target->error.code)) + return; + + if (FAILED(hr = ID2D1Factory_CreateEllipseGeometry(render_target->factory, ellipse, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + ID2D1DeviceContext6_FillGeometry(iface, (ID2D1Geometry *)geometry, brush, NULL); + ID2D1EllipseGeometry_Release(geometry); +} + +static HRESULT d2d_device_context_update_ps_cb(struct d2d_device_context *context, + struct d2d_brush *brush, struct d2d_brush *opacity_brush, BOOL outline, BOOL is_arc) +{ + D3D11_MAPPED_SUBRESOURCE map_desc; + ID3D11DeviceContext *d3d_context; + struct d2d_ps_cb *cb_data; + HRESULT hr; + + ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context); + + if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->ps_cb, + 0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc))) + { + WARN("Failed to map constant buffer, hr %#lx.\n", hr); + ID3D11DeviceContext_Release(d3d_context); + return hr; + } + + cb_data = map_desc.pData; + cb_data->outline = outline; + cb_data->is_arc = is_arc; + cb_data->pad[0] = 0; + cb_data->pad[1] = 0; + if (!d2d_brush_fill_cb(brush, &cb_data->colour_brush)) + WARN("Failed to initialize colour brush buffer.\n"); + if (!d2d_brush_fill_cb(opacity_brush, &cb_data->opacity_brush)) + WARN("Failed to initialize opacity brush buffer.\n"); + + ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->ps_cb, 0); + ID3D11DeviceContext_Release(d3d_context); + + return hr; +} + +static HRESULT d2d_device_context_update_vs_cb(struct d2d_device_context *context, + const D2D_MATRIX_3X2_F *geometry_transform, float stroke_width) +{ + D3D11_MAPPED_SUBRESOURCE map_desc; + ID3D11DeviceContext *d3d_context; + const D2D1_MATRIX_3X2_F *w; + struct d2d_vs_cb *cb_data; + float tmp_x, tmp_y; + HRESULT hr; + + ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context); + + if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->vs_cb, + 0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc))) + { + WARN("Failed to map constant buffer, hr %#lx.\n", hr); + ID3D11DeviceContext_Release(d3d_context); + return hr; + } + + cb_data = map_desc.pData; + cb_data->transform_geometry._11 = geometry_transform->_11; + cb_data->transform_geometry._21 = geometry_transform->_21; + cb_data->transform_geometry._31 = geometry_transform->_31; + cb_data->transform_geometry.pad0 = 0.0f; + cb_data->transform_geometry._12 = geometry_transform->_12; + cb_data->transform_geometry._22 = geometry_transform->_22; + cb_data->transform_geometry._32 = geometry_transform->_32; + cb_data->transform_geometry.stroke_width = stroke_width; + + w = &context->drawing_state.transform; + + tmp_x = context->desc.dpiX / 96.0f; + cb_data->transform_rtx.x = w->_11 * tmp_x; + cb_data->transform_rtx.y = w->_21 * tmp_x; + cb_data->transform_rtx.z = w->_31 * tmp_x; + cb_data->transform_rtx.w = 2.0f / context->pixel_size.width; + + tmp_y = context->desc.dpiY / 96.0f; + cb_data->transform_rty.x = w->_12 * tmp_y; + cb_data->transform_rty.y = w->_22 * tmp_y; + cb_data->transform_rty.z = w->_32 * tmp_y; + cb_data->transform_rty.w = -2.0f / context->pixel_size.height; + + ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->vs_cb, 0); + ID3D11DeviceContext_Release(d3d_context); + + return S_OK; +} + +static void d2d_device_context_draw_geometry(struct d2d_device_context *render_target, + const struct d2d_geometry *geometry, struct d2d_brush *brush, float stroke_width) +{ + D3D11_SUBRESOURCE_DATA buffer_data; + D3D11_BUFFER_DESC buffer_desc; + ID3D11Buffer *ib, *vb; + HRESULT hr; + + if (FAILED(hr = d2d_device_context_update_vs_cb(render_target, &geometry->transform, stroke_width))) + { + WARN("Failed to update vs constant buffer, hr %#lx.\n", hr); + return; + } + + if (FAILED(hr = d2d_device_context_update_ps_cb(render_target, brush, NULL, TRUE, FALSE))) + { + WARN("Failed to update ps constant buffer, hr %#lx.\n", hr); + return; + } + + buffer_desc.Usage = D3D11_USAGE_DEFAULT; + buffer_desc.CPUAccessFlags = 0; + buffer_desc.MiscFlags = 0; + + buffer_data.SysMemPitch = 0; + buffer_data.SysMemSlicePitch = 0; + + if (geometry->outline.face_count) + { + buffer_desc.ByteWidth = geometry->outline.face_count * sizeof(*geometry->outline.faces); + buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + buffer_data.pSysMem = geometry->outline.faces; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) + { + WARN("Failed to create index buffer, hr %#lx.\n", hr); + return; + } + + buffer_desc.ByteWidth = geometry->outline.vertex_count * sizeof(*geometry->outline.vertices); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = geometry->outline.vertices; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) + { + ERR("Failed to create vertex buffer, hr %#lx.\n", hr); + ID3D11Buffer_Release(ib); + return; + } + + d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_OUTLINE, ib, 3 * geometry->outline.face_count, vb, + sizeof(*geometry->outline.vertices), brush, NULL); + + ID3D11Buffer_Release(vb); + ID3D11Buffer_Release(ib); + } + + if (geometry->outline.bezier_face_count) + { + buffer_desc.ByteWidth = geometry->outline.bezier_face_count * sizeof(*geometry->outline.bezier_faces); + buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + buffer_data.pSysMem = geometry->outline.bezier_faces; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) + { + WARN("Failed to create curves index buffer, hr %#lx.\n", hr); + return; + } + + buffer_desc.ByteWidth = geometry->outline.bezier_count * sizeof(*geometry->outline.beziers); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = geometry->outline.beziers; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) + { + ERR("Failed to create curves vertex buffer, hr %#lx.\n", hr); + ID3D11Buffer_Release(ib); + return; + } + + d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_BEZIER_OUTLINE, ib, + 3 * geometry->outline.bezier_face_count, vb, + sizeof(*geometry->outline.beziers), brush, NULL); + + ID3D11Buffer_Release(vb); + ID3D11Buffer_Release(ib); + } + + if (geometry->outline.arc_face_count) + { + buffer_desc.ByteWidth = geometry->outline.arc_face_count * sizeof(*geometry->outline.arc_faces); + buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + buffer_data.pSysMem = geometry->outline.arc_faces; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) + { + WARN("Failed to create arcs index buffer, hr %#lx.\n", hr); + return; + } + + buffer_desc.ByteWidth = geometry->outline.arc_count * sizeof(*geometry->outline.arcs); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = geometry->outline.arcs; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) + { + ERR("Failed to create arcs vertex buffer, hr %#lx.\n", hr); + ID3D11Buffer_Release(ib); + return; + } + + if (SUCCEEDED(d2d_device_context_update_ps_cb(render_target, brush, NULL, TRUE, TRUE))) + d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_ARC_OUTLINE, ib, + 3 * geometry->outline.arc_face_count, vb, + sizeof(*geometry->outline.arcs), brush, NULL); + + ID3D11Buffer_Release(vb); + ID3D11Buffer_Release(ib); + } +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawGeometry(ID2D1DeviceContext6 *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + const struct d2d_geometry *geometry_impl = unsafe_impl_from_ID2D1Geometry(geometry); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *brush_impl = unsafe_impl_from_ID2D1Brush(brush); + struct d2d_stroke_style *stroke_style_impl = unsafe_impl_from_ID2D1StrokeStyle(stroke_style); + + TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, geometry, brush, stroke_width, stroke_style); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_geometry(context->target.command_list, context, geometry, brush, + stroke_width, stroke_style); + return; + } + + if (stroke_style) + FIXME("Ignoring stroke style %p.\n", stroke_style); + + if (stroke_style_impl) + { + if (stroke_style_impl->desc.transformType == D2D1_STROKE_TRANSFORM_TYPE_FIXED) + stroke_width /= context->drawing_state.transform.m11; + } + + d2d_device_context_draw_geometry(context, geometry_impl, brush_impl, stroke_width); +} + +static void d2d_device_context_fill_geometry(struct d2d_device_context *render_target, + const struct d2d_geometry *geometry, struct d2d_brush *brush, struct d2d_brush *opacity_brush) +{ + D3D11_SUBRESOURCE_DATA buffer_data; + D3D11_BUFFER_DESC buffer_desc; + ID3D11Buffer *ib, *vb; + HRESULT hr; + + buffer_desc.Usage = D3D11_USAGE_DEFAULT; + buffer_desc.CPUAccessFlags = 0; + buffer_desc.MiscFlags = 0; + + buffer_data.SysMemPitch = 0; + buffer_data.SysMemSlicePitch = 0; + + if (FAILED(hr = d2d_device_context_update_vs_cb(render_target, &geometry->transform, 0.0f))) + { + WARN("Failed to update vs constant buffer, hr %#lx.\n", hr); + return; + } + + if (FAILED(hr = d2d_device_context_update_ps_cb(render_target, brush, opacity_brush, FALSE, FALSE))) + { + WARN("Failed to update ps constant buffer, hr %#lx.\n", hr); + return; + } + + if (geometry->fill.face_count) + { + buffer_desc.ByteWidth = geometry->fill.face_count * sizeof(*geometry->fill.faces); + buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + buffer_data.pSysMem = geometry->fill.faces; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) + { + WARN("Failed to create index buffer, hr %#lx.\n", hr); + return; + } + + buffer_desc.ByteWidth = geometry->fill.vertex_count * sizeof(*geometry->fill.vertices); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = geometry->fill.vertices; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) + { + ERR("Failed to create vertex buffer, hr %#lx.\n", hr); + ID3D11Buffer_Release(ib); + return; + } + + d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_TRIANGLE, ib, 3 * geometry->fill.face_count, vb, + sizeof(*geometry->fill.vertices), brush, opacity_brush); + + ID3D11Buffer_Release(vb); + ID3D11Buffer_Release(ib); + } + + if (geometry->fill.bezier_vertex_count) + { + buffer_desc.ByteWidth = geometry->fill.bezier_vertex_count * sizeof(*geometry->fill.bezier_vertices); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = geometry->fill.bezier_vertices; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) + { + ERR("Failed to create curves vertex buffer, hr %#lx.\n", hr); + return; + } + + d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_CURVE, NULL, geometry->fill.bezier_vertex_count, vb, + sizeof(*geometry->fill.bezier_vertices), brush, opacity_brush); + + ID3D11Buffer_Release(vb); + } + + if (geometry->fill.arc_vertex_count) + { + buffer_desc.ByteWidth = geometry->fill.arc_vertex_count * sizeof(*geometry->fill.arc_vertices); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = geometry->fill.arc_vertices; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) + { + ERR("Failed to create arc vertex buffer, hr %#lx.\n", hr); + return; + } + + if (SUCCEEDED(d2d_device_context_update_ps_cb(render_target, brush, opacity_brush, FALSE, TRUE))) + d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_CURVE, NULL, geometry->fill.arc_vertex_count, vb, + sizeof(*geometry->fill.arc_vertices), brush, opacity_brush); + + ID3D11Buffer_Release(vb); + } +} + +static void STDMETHODCALLTYPE d2d_device_context_FillGeometry(ID2D1DeviceContext6 *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush) +{ + const struct d2d_geometry *geometry_impl = unsafe_impl_from_ID2D1Geometry(geometry); + struct d2d_brush *opacity_brush_impl = unsafe_impl_from_ID2D1Brush(opacity_brush); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *brush_impl = unsafe_impl_from_ID2D1Brush(brush); + + TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (opacity_brush && brush_impl->type != D2D_BRUSH_TYPE_BITMAP) + { + d2d_device_context_set_error(context, D2DERR_INCOMPATIBLE_BRUSH_TYPES); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_fill_geometry(context->target.command_list, context, geometry, brush, opacity_brush); + else + d2d_device_context_fill_geometry(context, geometry_impl, brush_impl, opacity_brush_impl); +} + +static void STDMETHODCALLTYPE d2d_device_context_FillMesh(ID2D1DeviceContext6 *iface, + ID2D1Mesh *mesh, ID2D1Brush *brush) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p, mesh %p, brush %p stub!\n", iface, mesh, brush); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_fill_mesh(context->target.command_list, context, mesh, brush); +} + +static void STDMETHODCALLTYPE d2d_device_context_FillOpacityMask(ID2D1DeviceContext6 *iface, + ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content, + const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p, mask %p, brush %p, content %#x, dst_rect %s, src_rect %s stub!\n", + iface, mask, brush, content, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect)); + + if (FAILED(context->error.code)) + return; + + if (context->drawing_state.antialiasMode != D2D1_ANTIALIAS_MODE_ALIASED) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if ((unsigned int)content > D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE) + { + d2d_device_context_set_error(context, E_INVALIDARG); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_fill_opacity_mask(context->target.command_list, context, mask, brush, dst_rect, src_rect); +} + +static void d2d_device_context_draw_bitmap(struct d2d_device_context *context, ID2D1Bitmap *bitmap, + const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode, + const D2D1_RECT_F *src_rect, const D2D1_POINT_2F *offset, + const D2D1_MATRIX_4X4_F *perspective_transform) +{ + D2D1_BITMAP_BRUSH_PROPERTIES1 bitmap_brush_desc; + D2D1_BRUSH_PROPERTIES brush_desc; + struct d2d_brush *brush; + D2D1_SIZE_F size; + D2D1_RECT_F s, d; + HRESULT hr; + + if (perspective_transform) + FIXME("Perspective transform is ignored.\n"); + + size = ID2D1Bitmap_GetSize(bitmap); + d2d_rect_set(&s, 0.0f, 0.0f, size.width, size.height); + if (src_rect && src_rect->left <= src_rect->right + && src_rect->top <= src_rect->bottom) + { + d2d_rect_intersect(&s, src_rect); + } + + if (s.left == s.right || s.top == s.bottom) + return; + + if (dst_rect) + { + d = *dst_rect; + } + else + { + d.left = 0.0f; + d.top = 0.0f; + d.right = s.right - s.left; + d.bottom = s.bottom - s.top; + } + + if (offset) + { + d.left += offset->x; + d.top += offset->y; + d.right += offset->x; + d.bottom += offset->y; + } + + bitmap_brush_desc.extendModeX = D2D1_EXTEND_MODE_CLAMP; + bitmap_brush_desc.extendModeY = D2D1_EXTEND_MODE_CLAMP; + bitmap_brush_desc.interpolationMode = interpolation_mode; + + brush_desc.opacity = opacity; + brush_desc.transform._11 = fabsf((d.right - d.left) / (s.right - s.left)); + brush_desc.transform._21 = 0.0f; + brush_desc.transform._31 = min(d.left, d.right) - min(s.left, s.right) * brush_desc.transform._11; + brush_desc.transform._12 = 0.0f; + brush_desc.transform._22 = fabsf((d.bottom - d.top) / (s.bottom - s.top)); + brush_desc.transform._32 = min(d.top, d.bottom) - min(s.top, s.bottom) * brush_desc.transform._22; + + if (FAILED(hr = d2d_bitmap_brush_create(context->factory, bitmap, &bitmap_brush_desc, &brush_desc, &brush))) + { + ERR("Failed to create bitmap brush, hr %#lx.\n", hr); + return; + } + + d2d_device_context_FillRectangle(&context->ID2D1DeviceContext6_iface, &d, &brush->ID2D1Brush_iface); + ID2D1Brush_Release(&brush->ID2D1Brush_iface); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawBitmap(ID2D1DeviceContext6 *iface, + ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, + D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, src_rect %s.\n", + iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, debug_d2d_rect_f(src_rect)); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR + && interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_LINEAR) + { + d2d_device_context_set_error(context, E_INVALIDARG); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_bitmap(context->target.command_list, bitmap, dst_rect, opacity, + d2d1_1_interp_mode_from_d2d1(interpolation_mode), src_rect, NULL); + } + else + { + d2d_device_context_draw_bitmap(context, bitmap, dst_rect, opacity, + d2d1_1_interp_mode_from_d2d1(interpolation_mode), src_rect, NULL, NULL); + } +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawText(ID2D1DeviceContext6 *iface, + const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect, + ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + IDWriteTextLayout *text_layout; + IDWriteFactory *dwrite_factory; + D2D1_POINT_2F origin; + float width, height; + HRESULT hr; + + TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, " + "brush %p, options %#x, measuring_mode %#x.\n", + iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect), + brush, options, measuring_mode); + + if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, + &IID_IDWriteFactory, (IUnknown **)&dwrite_factory))) + { + ERR("Failed to create dwrite factory, hr %#lx.\n", hr); + return; + } + + width = max(0.0f, layout_rect->right - layout_rect->left); + height = max(0.0f, layout_rect->bottom - layout_rect->top); + if (measuring_mode == DWRITE_MEASURING_MODE_NATURAL) + hr = IDWriteFactory_CreateTextLayout(dwrite_factory, string, string_len, text_format, + width, height, &text_layout); + else + hr = IDWriteFactory_CreateGdiCompatibleTextLayout(dwrite_factory, string, string_len, text_format, + width, height, render_target->desc.dpiX / 96.0f, (DWRITE_MATRIX *)&render_target->drawing_state.transform, + measuring_mode == DWRITE_MEASURING_MODE_GDI_NATURAL, &text_layout); + IDWriteFactory_Release(dwrite_factory); + if (FAILED(hr)) + { + ERR("Failed to create text layout, hr %#lx.\n", hr); + return; + } + + d2d_point_set(&origin, min(layout_rect->left, layout_rect->right), min(layout_rect->top, layout_rect->bottom)); + ID2D1DeviceContext1_DrawTextLayout((ID2D1DeviceContext1 *)iface, origin, text_layout, brush, options); + IDWriteTextLayout_Release(text_layout); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawTextLayout(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_draw_text_layout_ctx ctx; + HRESULT hr; + + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); + + ctx.brush = brush; + ctx.options = options; + + if (FAILED(hr = IDWriteTextLayout_Draw(layout, + &ctx, &render_target->IDWriteTextRenderer_iface, origin.x, origin.y))) + FIXME("Failed to draw text layout, hr %#lx.\n", hr); +} + +static D2D1_ANTIALIAS_MODE d2d_device_context_set_aa_mode_from_text_aa_mode(struct d2d_device_context *rt) +{ + D2D1_ANTIALIAS_MODE prev_antialias_mode = rt->drawing_state.antialiasMode; + rt->drawing_state.antialiasMode = rt->drawing_state.textAntialiasMode == D2D1_TEXT_ANTIALIAS_MODE_ALIASED ? + D2D1_ANTIALIAS_MODE_ALIASED : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE; + return prev_antialias_mode; +} + +static void d2d_device_context_draw_glyph_run_outline(struct d2d_device_context *render_target, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush) +{ + D2D1_MATRIX_3X2_F *transform, prev_transform; + D2D1_ANTIALIAS_MODE prev_antialias_mode; + ID2D1PathGeometry *geometry; + ID2D1GeometrySink *sink; + HRESULT hr; + + if (FAILED(hr = ID2D1Factory_CreatePathGeometry(render_target->factory, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + return; + } + + if (FAILED(hr = ID2D1PathGeometry_Open(geometry, &sink))) + { + ERR("Failed to open geometry sink, hr %#lx.\n", hr); + ID2D1PathGeometry_Release(geometry); + return; + } + + if (FAILED(hr = IDWriteFontFace_GetGlyphRunOutline(glyph_run->fontFace, glyph_run->fontEmSize, + glyph_run->glyphIndices, glyph_run->glyphAdvances, glyph_run->glyphOffsets, glyph_run->glyphCount, + glyph_run->isSideways, glyph_run->bidiLevel & 1, (IDWriteGeometrySink *)sink))) + { + ERR("Failed to get glyph run outline, hr %#lx.\n", hr); + ID2D1GeometrySink_Release(sink); + ID2D1PathGeometry_Release(geometry); + return; + } + + if (FAILED(hr = ID2D1GeometrySink_Close(sink))) + ERR("Failed to close geometry sink, hr %#lx.\n", hr); + ID2D1GeometrySink_Release(sink); + + transform = &render_target->drawing_state.transform; + prev_transform = *transform; + transform->_31 += baseline_origin.x * transform->_11 + baseline_origin.y * transform->_21; + transform->_32 += baseline_origin.x * transform->_12 + baseline_origin.y * transform->_22; + prev_antialias_mode = d2d_device_context_set_aa_mode_from_text_aa_mode(render_target); + d2d_device_context_fill_geometry(render_target, unsafe_impl_from_ID2D1Geometry((ID2D1Geometry *)geometry), + unsafe_impl_from_ID2D1Brush(brush), NULL); + render_target->drawing_state.antialiasMode = prev_antialias_mode; + *transform = prev_transform; + + ID2D1PathGeometry_Release(geometry); +} + +static void d2d_device_context_draw_glyph_run_bitmap(struct d2d_device_context *context, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, + DWRITE_RENDERING_MODE rendering_mode, DWRITE_MEASURING_MODE measuring_mode, + DWRITE_TEXT_ANTIALIAS_MODE antialias_mode) +{ + ID2D1RectangleGeometry *geometry = NULL; + ID2D1BitmapBrush *opacity_brush = NULL; + D2D1_BITMAP_PROPERTIES bitmap_desc; + ID2D1Bitmap *opacity_bitmap = NULL; + IDWriteGlyphRunAnalysis *analysis; + DWRITE_TEXTURE_TYPE texture_type; + D2D1_BRUSH_PROPERTIES brush_desc; + IDWriteFactory2 *dwrite_factory; + D2D1_MATRIX_3X2_F *transform, m; + void *opacity_values = NULL; + size_t opacity_values_size; + D2D1_SIZE_U bitmap_size; + float scale_x, scale_y; + D2D1_RECT_F run_rect; + RECT bounds; + HRESULT hr; + + if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, + &IID_IDWriteFactory2, (IUnknown **)&dwrite_factory))) + { + ERR("Failed to create dwrite factory, hr %#lx.\n", hr); + return; + } + + transform = &context->drawing_state.transform; + + scale_x = context->desc.dpiX / 96.0f; + m._11 = transform->_11 * scale_x; + m._21 = transform->_21 * scale_x; + m._31 = transform->_31 * scale_x; + + scale_y = context->desc.dpiY / 96.0f; + m._12 = transform->_12 * scale_y; + m._22 = transform->_22 * scale_y; + m._32 = transform->_32 * scale_y; + + hr = IDWriteFactory2_CreateGlyphRunAnalysis(dwrite_factory, glyph_run, (DWRITE_MATRIX *)&m, + rendering_mode, measuring_mode, DWRITE_GRID_FIT_MODE_DEFAULT, antialias_mode, + baseline_origin.x, baseline_origin.y, &analysis); + IDWriteFactory2_Release(dwrite_factory); + if (FAILED(hr)) + { + ERR("Failed to create glyph run analysis, hr %#lx.\n", hr); + return; + } + + if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED || antialias_mode == DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE) + texture_type = DWRITE_TEXTURE_ALIASED_1x1; + else + texture_type = DWRITE_TEXTURE_CLEARTYPE_3x1; + + if (FAILED(hr = IDWriteGlyphRunAnalysis_GetAlphaTextureBounds(analysis, texture_type, &bounds))) + { + ERR("Failed to get alpha texture bounds, hr %#lx.\n", hr); + goto done; + } + + d2d_size_set(&bitmap_size, bounds.right - bounds.left, bounds.bottom - bounds.top); + if (!bitmap_size.width || !bitmap_size.height) + { + /* Empty run, nothing to do. */ + goto done; + } + + if (texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1) + bitmap_size.width *= 3; + if (!(opacity_values = calloc(bitmap_size.height, bitmap_size.width))) + { + ERR("Failed to allocate opacity values.\n"); + goto done; + } + opacity_values_size = bitmap_size.height * bitmap_size.width; + + if (FAILED(hr = IDWriteGlyphRunAnalysis_CreateAlphaTexture(analysis, + texture_type, &bounds, opacity_values, opacity_values_size))) + { + ERR("Failed to create alpha texture, hr %#lx.\n", hr); + goto done; + } + + bitmap_desc.pixelFormat.format = DXGI_FORMAT_A8_UNORM; + bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED; + bitmap_desc.dpiX = context->desc.dpiX; + if (texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1) + bitmap_desc.dpiX *= 3.0f; + bitmap_desc.dpiY = context->desc.dpiY; + if (FAILED(hr = d2d_device_context_CreateBitmap(&context->ID2D1DeviceContext6_iface, + bitmap_size, opacity_values, bitmap_size.width, &bitmap_desc, &opacity_bitmap))) + { + ERR("Failed to create opacity bitmap, hr %#lx.\n", hr); + goto done; + } + + d2d_rect_set(&run_rect, bounds.left / scale_x, bounds.top / scale_y, + bounds.right / scale_x, bounds.bottom / scale_y); + + brush_desc.opacity = 1.0f; + brush_desc.transform._11 = 1.0f; + brush_desc.transform._12 = 0.0f; + brush_desc.transform._21 = 0.0f; + brush_desc.transform._22 = 1.0f; + brush_desc.transform._31 = run_rect.left; + brush_desc.transform._32 = run_rect.top; + if (FAILED(hr = d2d_device_context_CreateBitmapBrush(&context->ID2D1DeviceContext6_iface, + opacity_bitmap, NULL, &brush_desc, &opacity_brush))) + { + ERR("Failed to create opacity bitmap brush, hr %#lx.\n", hr); + goto done; + } + + if (FAILED(hr = ID2D1Factory_CreateRectangleGeometry(context->factory, &run_rect, &geometry))) + { + ERR("Failed to create geometry, hr %#lx.\n", hr); + goto done; + } + + m = *transform; + *transform = identity; + d2d_device_context_fill_geometry(context, unsafe_impl_from_ID2D1Geometry((ID2D1Geometry *)geometry), + unsafe_impl_from_ID2D1Brush(brush), unsafe_impl_from_ID2D1Brush((ID2D1Brush *)opacity_brush)); + *transform = m; + +done: + if (geometry) + ID2D1RectangleGeometry_Release(geometry); + if (opacity_brush) + ID2D1BitmapBrush_Release(opacity_brush); + if (opacity_bitmap) + ID2D1Bitmap_Release(opacity_bitmap); + free(opacity_values); + IDWriteGlyphRunAnalysis_Release(analysis); +} + +static void d2d_device_context_draw_glyph_run(struct d2d_device_context *context, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, + const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode) +{ + DWRITE_TEXT_ANTIALIAS_MODE antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE; + IDWriteRenderingParams *rendering_params; + DWRITE_RENDERING_MODE rendering_mode; + HRESULT hr; + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_glyph_run(context->target.command_list, context, baseline_origin, glyph_run, + glyph_run_desc, brush, measuring_mode); + return; + } + + rendering_params = context->text_rendering_params ? context->text_rendering_params + : context->default_text_rendering_params; + + rendering_mode = IDWriteRenderingParams_GetRenderingMode(rendering_params); + + switch (context->drawing_state.textAntialiasMode) + { + case D2D1_TEXT_ANTIALIAS_MODE_ALIASED: + if (rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL + || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC + || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL + || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC) + d2d_device_context_set_error(context, E_INVALIDARG); + break; + + case D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE: + if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED + || rendering_mode == DWRITE_RENDERING_MODE_OUTLINE) + d2d_device_context_set_error(context, E_INVALIDARG); + break; + + case D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE: + if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED) + d2d_device_context_set_error(context, E_INVALIDARG); + break; + + default: + break; + } + + if (FAILED(context->error.code)) + return; + + rendering_mode = DWRITE_RENDERING_MODE_DEFAULT; + switch (context->drawing_state.textAntialiasMode) + { + case D2D1_TEXT_ANTIALIAS_MODE_DEFAULT: + if (IDWriteRenderingParams_GetClearTypeLevel(rendering_params) > 0.0f) + antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE; + break; + + case D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE: + antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE; + break; + + case D2D1_TEXT_ANTIALIAS_MODE_ALIASED: + rendering_mode = DWRITE_RENDERING_MODE_ALIASED; + break; + + default: + break; + } + + if (rendering_mode == DWRITE_RENDERING_MODE_DEFAULT) + { + if (FAILED(hr = IDWriteFontFace_GetRecommendedRenderingMode(glyph_run->fontFace, glyph_run->fontEmSize, + max(context->desc.dpiX, context->desc.dpiY) / 96.0f, + measuring_mode, rendering_params, &rendering_mode))) + { + ERR("Failed to get recommended rendering mode, hr %#lx.\n", hr); + rendering_mode = DWRITE_RENDERING_MODE_OUTLINE; + } + } + + if (rendering_mode == DWRITE_RENDERING_MODE_OUTLINE) + d2d_device_context_draw_glyph_run_outline(context, baseline_origin, glyph_run, brush); + else + d2d_device_context_draw_glyph_run_bitmap(context, baseline_origin, glyph_run, brush, + rendering_mode, measuring_mode, antialias_mode); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, + DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); + + d2d_device_context_draw_glyph_run(context, baseline_origin, glyph_run, NULL, brush, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_device_context_SetTransform(ID2D1DeviceContext6 *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_transform(context->target.command_list, transform); + + context->drawing_state.transform = *transform; +} + +static void STDMETHODCALLTYPE d2d_device_context_GetTransform(ID2D1DeviceContext6 *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = render_target->drawing_state.transform; +} + +static void STDMETHODCALLTYPE d2d_device_context_SetAntialiasMode(ID2D1DeviceContext6 *iface, + D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, antialias_mode %#x stub!\n", iface, antialias_mode); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_antialias_mode(context->target.command_list, antialias_mode); + + context->drawing_state.antialiasMode = antialias_mode; +} + +static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_device_context_GetAntialiasMode(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + return render_target->drawing_state.antialiasMode; +} + +static void STDMETHODCALLTYPE d2d_device_context_SetTextAntialiasMode(ID2D1DeviceContext6 *iface, + D2D1_TEXT_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_text_antialias_mode(context->target.command_list, antialias_mode); + + context->drawing_state.textAntialiasMode = antialias_mode; +} + +static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_device_context_GetTextAntialiasMode(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + return render_target->drawing_state.textAntialiasMode; +} + +static void STDMETHODCALLTYPE d2d_device_context_SetTextRenderingParams(ID2D1DeviceContext6 *iface, + IDWriteRenderingParams *text_rendering_params) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_text_rendering_params(context->target.command_list, text_rendering_params); + + if (text_rendering_params) + IDWriteRenderingParams_AddRef(text_rendering_params); + if (context->text_rendering_params) + IDWriteRenderingParams_Release(context->text_rendering_params); + context->text_rendering_params = text_rendering_params; +} + +static void STDMETHODCALLTYPE d2d_device_context_GetTextRenderingParams(ID2D1DeviceContext6 *iface, + IDWriteRenderingParams **text_rendering_params) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + if ((*text_rendering_params = render_target->text_rendering_params)) + IDWriteRenderingParams_AddRef(*text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_device_context_SetTags(ID2D1DeviceContext6 *iface, D2D1_TAG tag1, D2D1_TAG tag2) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2)); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_tags(context->target.command_list, tag1, tag2); + + context->drawing_state.tag1 = tag1; + context->drawing_state.tag2 = tag2; +} + +static void STDMETHODCALLTYPE d2d_device_context_GetTags(ID2D1DeviceContext6 *iface, D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + *tag1 = render_target->drawing_state.tag1; + *tag2 = render_target->drawing_state.tag2; +} + +static void STDMETHODCALLTYPE d2d_device_context_PushLayer(ID2D1DeviceContext6 *iface, + const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p, layer_parameters %p, layer %p stub!\n", iface, layer_parameters, layer); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + D2D1_LAYER_PARAMETERS1 parameters; + + memcpy(¶meters, layer_parameters, sizeof(*layer_parameters)); + parameters.layerOptions = D2D1_LAYER_OPTIONS1_NONE; + d2d_command_list_push_layer(context->target.command_list, context, ¶meters, layer); + } +} + +static void STDMETHODCALLTYPE d2d_device_context_PopLayer(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p stub!\n", iface); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_pop_layer(context->target.command_list); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_Flush(ID2D1DeviceContext6 *iface, D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p, tag1 %p, tag2 %p stub!\n", iface, tag1, tag2); + + if (context->ops && context->ops->device_context_present) + context->ops->device_context_present(context->outer_unknown); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_SaveDrawingState(ID2D1DeviceContext6 *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_state_block *state_block_impl; + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + if (!(state_block_impl = unsafe_impl_from_ID2D1DrawingStateBlock(state_block))) return; + state_block_impl->drawing_state = render_target->drawing_state; + if (render_target->text_rendering_params) + IDWriteRenderingParams_AddRef(render_target->text_rendering_params); + if (state_block_impl->text_rendering_params) + IDWriteRenderingParams_Release(state_block_impl->text_rendering_params); + state_block_impl->text_rendering_params = render_target->text_rendering_params; +} + +static void STDMETHODCALLTYPE d2d_device_context_RestoreDrawingState(ID2D1DeviceContext6 *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_state_block *state_block_impl; + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + if (!(state_block_impl = unsafe_impl_from_ID2D1DrawingStateBlock(state_block))) return; + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + struct d2d_command_list *command_list = context->target.command_list; + + if (context->drawing_state.antialiasMode != state_block_impl->drawing_state.antialiasMode) + d2d_command_list_set_antialias_mode(command_list, state_block_impl->drawing_state.antialiasMode); + d2d_command_list_set_text_antialias_mode(command_list, state_block_impl->drawing_state.textAntialiasMode); + d2d_command_list_set_tags(command_list, state_block_impl->drawing_state.tag1, state_block_impl->drawing_state.tag2); + d2d_command_list_set_transform(command_list, &state_block_impl->drawing_state.transform); + d2d_command_list_set_primitive_blend(command_list, state_block_impl->drawing_state.primitiveBlend); + d2d_command_list_set_unit_mode(command_list, state_block_impl->drawing_state.unitMode); + d2d_command_list_set_text_rendering_params(command_list, state_block_impl->text_rendering_params); + } + + context->drawing_state = state_block_impl->drawing_state; + if (state_block_impl->text_rendering_params) + IDWriteRenderingParams_AddRef(state_block_impl->text_rendering_params); + if (context->text_rendering_params) + IDWriteRenderingParams_Release(context->text_rendering_params); + context->text_rendering_params = state_block_impl->text_rendering_params; +} + +static void STDMETHODCALLTYPE d2d_device_context_PushAxisAlignedClip(ID2D1DeviceContext6 *iface, + const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D1_RECT_F transformed_rect; + float x_scale, y_scale; + D2D1_POINT_2F point; + + TRACE("iface %p, clip_rect %s, antialias_mode %#x.\n", iface, debug_d2d_rect_f(clip_rect), antialias_mode); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_push_clip(context->target.command_list, clip_rect, antialias_mode); + + if (antialias_mode != D2D1_ANTIALIAS_MODE_ALIASED) + FIXME("Ignoring antialias_mode %#x.\n", antialias_mode); + + x_scale = context->desc.dpiX / 96.0f; + y_scale = context->desc.dpiY / 96.0f; + d2d_point_transform(&point, &context->drawing_state.transform, + clip_rect->left * x_scale, clip_rect->top * y_scale); + d2d_rect_set(&transformed_rect, point.x, point.y, point.x, point.y); + d2d_point_transform(&point, &context->drawing_state.transform, + clip_rect->left * x_scale, clip_rect->bottom * y_scale); + d2d_rect_expand(&transformed_rect, &point); + d2d_point_transform(&point, &context->drawing_state.transform, + clip_rect->right * x_scale, clip_rect->top * y_scale); + d2d_rect_expand(&transformed_rect, &point); + d2d_point_transform(&point, &context->drawing_state.transform, + clip_rect->right * x_scale, clip_rect->bottom * y_scale); + d2d_rect_expand(&transformed_rect, &point); + + if (!d2d_clip_stack_push(&context->clip_stack, &transformed_rect)) + WARN("Failed to push clip rect.\n"); +} + +static void STDMETHODCALLTYPE d2d_device_context_PopAxisAlignedClip(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_pop_clip(context->target.command_list); + + d2d_clip_stack_pop(&context->clip_stack); +} + +static void STDMETHODCALLTYPE d2d_device_context_Clear(ID2D1DeviceContext6 *iface, const D2D1_COLOR_F *colour) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D3D11_MAPPED_SUBRESOURCE map_desc; + ID3D11DeviceContext *d3d_context; + struct d2d_ps_cb *ps_cb_data; + struct d2d_vs_cb *vs_cb_data; + D2D1_COLOR_F *c; + HRESULT hr; + + TRACE("iface %p, colour %p.\n", iface, colour); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_clear(context->target.command_list, colour); + return; + } + + ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context); + + if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->vs_cb, + 0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc))) + { + WARN("Failed to map vs constant buffer, hr %#lx.\n", hr); + ID3D11DeviceContext_Release(d3d_context); + return; + } + + vs_cb_data = map_desc.pData; + vs_cb_data->transform_geometry._11 = 1.0f; + vs_cb_data->transform_geometry._21 = 0.0f; + vs_cb_data->transform_geometry._31 = 0.0f; + vs_cb_data->transform_geometry.pad0 = 0.0f; + vs_cb_data->transform_geometry._12 = 0.0f; + vs_cb_data->transform_geometry._22 = 1.0f; + vs_cb_data->transform_geometry._32 = 0.0f; + vs_cb_data->transform_geometry.stroke_width = 0.0f; + vs_cb_data->transform_rtx.x = 1.0f; + vs_cb_data->transform_rtx.y = 0.0f; + vs_cb_data->transform_rtx.z = 1.0f; + vs_cb_data->transform_rtx.w = 1.0f; + vs_cb_data->transform_rty.x = 0.0f; + vs_cb_data->transform_rty.y = 1.0f; + vs_cb_data->transform_rty.z = 1.0f; + vs_cb_data->transform_rty.w = -1.0f; + + ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->vs_cb, 0); + + if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->ps_cb, + 0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc))) + { + WARN("Failed to map ps constant buffer, hr %#lx.\n", hr); + ID3D11DeviceContext_Release(d3d_context); + return; + } + + ps_cb_data = map_desc.pData; + memset(ps_cb_data, 0, sizeof(*ps_cb_data)); + ps_cb_data->colour_brush.type = D2D_BRUSH_TYPE_SOLID; + ps_cb_data->colour_brush.opacity = 1.0f; + ps_cb_data->opacity_brush.type = D2D_BRUSH_TYPE_COUNT; + c = &ps_cb_data->colour_brush.u.solid.colour; + if (colour) + *c = *colour; + if (context->desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_IGNORE) + c->a = 1.0f; + c->r *= c->a; + c->g *= c->a; + c->b *= c->a; + + ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->ps_cb, 0); + ID3D11DeviceContext_Release(d3d_context); + + d2d_device_context_draw(context, D2D_SHAPE_TYPE_TRIANGLE, context->ib, 6, + context->vb, context->vb_stride, NULL, NULL); +} + +static void STDMETHODCALLTYPE d2d_device_context_BeginDraw(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_begin_draw(context->target.command_list, context); + + memset(&context->error, 0, sizeof(context->error)); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_EndDraw(ID2D1DeviceContext6 *iface, + D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + HRESULT hr; + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + FIXME("Unimplemented for command list target.\n"); + return E_NOTIMPL; + } + + if (tag1) + *tag1 = context->error.tag1; + if (tag2) + *tag2 = context->error.tag2; + + if (context->ops && context->ops->device_context_present) + { + if (FAILED(hr = context->ops->device_context_present(context->outer_unknown))) + context->error.code = hr; + } + + return context->error.code; +} + +static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_device_context_GetPixelFormat(ID2D1DeviceContext6 *iface, + D2D1_PIXEL_FORMAT *format) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, format %p.\n", iface, format); + + *format = render_target->desc.pixelFormat; + return format; +} + +static void STDMETHODCALLTYPE d2d_device_context_SetDpi(ID2D1DeviceContext6 *iface, float dpi_x, float dpi_y) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y); + + if (dpi_x == 0.0f && dpi_y == 0.0f) + { + dpi_x = 96.0f; + dpi_y = 96.0f; + } + else if (dpi_x <= 0.0f || dpi_y <= 0.0f) + return; + + render_target->desc.dpiX = dpi_x; + render_target->desc.dpiY = dpi_y; +} + +static void STDMETHODCALLTYPE d2d_device_context_GetDpi(ID2D1DeviceContext6 *iface, float *dpi_x, float *dpi_y) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + *dpi_x = render_target->desc.dpiX; + *dpi_y = render_target->desc.dpiY; +} + +static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_device_context_GetSize(ID2D1DeviceContext6 *iface, D2D1_SIZE_F *size) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, size %p.\n", iface, size); + + size->width = render_target->pixel_size.width / (render_target->desc.dpiX / 96.0f); + size->height = render_target->pixel_size.height / (render_target->desc.dpiY / 96.0f); + return size; +} + +static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_device_context_GetPixelSize(ID2D1DeviceContext6 *iface, + D2D1_SIZE_U *pixel_size) +{ + struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, pixel_size %p.\n", iface, pixel_size); + + *pixel_size = render_target->pixel_size; + return pixel_size; +} + +static UINT32 STDMETHODCALLTYPE d2d_device_context_GetMaximumBitmapSize(ID2D1DeviceContext6 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION; +} + +static BOOL STDMETHODCALLTYPE d2d_device_context_IsSupported(ID2D1DeviceContext6 *iface, + const D2D1_RENDER_TARGET_PROPERTIES *desc) +{ + FIXME("iface %p, desc %p stub!\n", iface, desc); + + return FALSE; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateBitmap(ID2D1DeviceContext6 *iface, + D2D1_SIZE_U size, const void *src_data, UINT32 pitch, + const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_bitmap *object; + HRESULT hr; + + TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n", + iface, size.width, size.height, src_data, pitch, desc, bitmap); + + if (SUCCEEDED(hr = d2d_bitmap_create(context, size, src_data, pitch, desc, &object))) + *bitmap = &object->ID2D1Bitmap1_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateBitmapFromWicBitmap( + ID2D1DeviceContext6 *iface, IWICBitmapSource *bitmap_source, + const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_bitmap *object; + HRESULT hr; + + TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n", iface, bitmap_source, desc, bitmap); + + if (SUCCEEDED(hr = d2d_bitmap_create_from_wic_bitmap(context, bitmap_source, desc, &object))) + *bitmap = &object->ID2D1Bitmap1_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContext(ID2D1DeviceContext6 *iface, + D2D1_COLOR_SPACE space, const BYTE *profile, UINT32 profile_size, ID2D1ColorContext **color_context) +{ + FIXME("iface %p, space %#x, profile %p, profile_size %u, color_context %p stub!\n", + iface, space, profile, profile_size, color_context); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromFilename(ID2D1DeviceContext6 *iface, + const WCHAR *filename, ID2D1ColorContext **color_context) +{ + FIXME("iface %p, filename %s, color_context %p stub!\n", iface, debugstr_w(filename), color_context); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromWicColorContext(ID2D1DeviceContext6 *iface, + IWICColorContext *wic_color_context, ID2D1ColorContext **color_context) +{ + FIXME("iface %p, wic_color_context %p, color_context %p stub!\n", iface, wic_color_context, color_context); + + return E_NOTIMPL; +} + +static BOOL d2d_bitmap_check_options_with_surface(unsigned int options, unsigned int surface_options) +{ + switch (options) + { + case D2D1_BITMAP_OPTIONS_NONE: + case D2D1_BITMAP_OPTIONS_TARGET: + case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW: + case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE: + case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE: + case D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_CPU_READ: + case D2D1_BITMAP_OPTIONS_CANNOT_DRAW: + break; + default: + WARN("Invalid bitmap options %#x.\n", options); + return FALSE; + } + + if (options && (options & D2D1_BITMAP_OPTIONS_TARGET) != (surface_options & D2D1_BITMAP_OPTIONS_TARGET)) + return FALSE; + if (!(options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW) && (surface_options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW)) + return FALSE; + if (options & D2D1_BITMAP_OPTIONS_TARGET) + { + if (options & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE && !(surface_options & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE)) + return FALSE; + return TRUE; + } + + if (options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW) + { + if (!(surface_options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW)) + return FALSE; + + if (options & D2D1_BITMAP_OPTIONS_CPU_READ && !(surface_options & D2D1_BITMAP_OPTIONS_CPU_READ)) + return FALSE; + } + + return TRUE; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromDxgiSurface(ID2D1DeviceContext6 *iface, + IDXGISurface *surface, const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + unsigned int surface_options; + struct d2d_bitmap *object; + HRESULT hr; + + TRACE("iface %p, surface %p, desc %p, bitmap %p.\n", iface, surface, desc, bitmap); + + surface_options = d2d_get_bitmap_options_for_surface(surface); + + if (desc) + { + if (!d2d_bitmap_check_options_with_surface(desc->bitmapOptions, surface_options)) + { + WARN("Incompatible bitmap options %#x, surface options %#x.\n", + desc->bitmapOptions, surface_options); + return E_INVALIDARG; + } + } + else + { + DXGI_SURFACE_DESC surface_desc; + + if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc))) + { + WARN("Failed to get surface desc, hr %#lx.\n", hr); + return hr; + } + + memset(&bitmap_desc, 0, sizeof(bitmap_desc)); + bitmap_desc.pixelFormat.format = surface_desc.Format; + bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED; + bitmap_desc.bitmapOptions = surface_options; + desc = &bitmap_desc; + } + + if (SUCCEEDED(hr = d2d_bitmap_create_shared(context, &IID_IDXGISurface, surface, desc, &object))) + *bitmap = &object->ID2D1Bitmap1_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateEffect(ID2D1DeviceContext6 *iface, + REFCLSID effect_id, ID2D1Effect **effect) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, effect_id %s, effect %p.\n", iface, debugstr_guid(effect_id), effect); + + return d2d_effect_create(context, effect_id, effect); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateGradientStopCollection( + ID2D1DeviceContext6 *iface, const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, + D2D1_COLOR_SPACE preinterpolation_space, D2D1_COLOR_SPACE postinterpolation_space, + D2D1_BUFFER_PRECISION buffer_precision, D2D1_EXTEND_MODE extend_mode, + D2D1_COLOR_INTERPOLATION_MODE color_interpolation_mode, ID2D1GradientStopCollection1 **gradient) +{ + FIXME("iface %p, stops %p, stop_count %u, preinterpolation_space %#x, postinterpolation_space %#x, " + "buffer_precision %#x, extend_mode %#x, color_interpolation_mode %#x, gradient %p stub!\n", + iface, stops, stop_count, preinterpolation_space, postinterpolation_space, + buffer_precision, extend_mode, color_interpolation_mode, gradient); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateImageBrush(ID2D1DeviceContext6 *iface, + ID2D1Image *image, const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, + const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1ImageBrush **brush) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *object; + HRESULT hr; + + TRACE("iface %p, image %p, image_brush_desc %p, brush_desc %p, brush %p.\n", iface, image, image_brush_desc, + brush_desc, brush); + + if (SUCCEEDED(hr = d2d_image_brush_create(context->factory, image, image_brush_desc, + brush_desc, &object))) + *brush = (ID2D1ImageBrush *)&object->ID2D1Brush_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateBitmapBrush(ID2D1DeviceContext6 *iface, + ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, + const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush1 **brush) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_brush *object; + HRESULT hr; + + TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n", iface, bitmap, bitmap_brush_desc, + brush_desc, brush); + + if (SUCCEEDED(hr = d2d_bitmap_brush_create(context->factory, bitmap, bitmap_brush_desc, brush_desc, &object))) + *brush = (ID2D1BitmapBrush1 *)&object->ID2D1Brush_iface; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateCommandList(ID2D1DeviceContext6 *iface, + ID2D1CommandList **command_list) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_command_list *object; + HRESULT hr; + + TRACE("iface %p, command_list %p.\n", iface, command_list); + + if (SUCCEEDED(hr = d2d_command_list_create(context->factory, &object))) + *command_list = &object->ID2D1CommandList_iface; + + return hr; +} + +static BOOL STDMETHODCALLTYPE d2d_device_context_IsDxgiFormatSupported(ID2D1DeviceContext6 *iface, DXGI_FORMAT format) +{ + FIXME("iface %p, format %#x stub!\n", iface, format); + + return FALSE; +} + +static BOOL STDMETHODCALLTYPE d2d_device_context_IsBufferPrecisionSupported(ID2D1DeviceContext6 *iface, + D2D1_BUFFER_PRECISION buffer_precision) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + DXGI_FORMAT format; + UINT support = 0; + HRESULT hr; + + TRACE("iface %p, buffer_precision %u.\n", iface, buffer_precision); + + switch (buffer_precision) + { + case D2D1_BUFFER_PRECISION_8BPC_UNORM: format = DXGI_FORMAT_R8G8B8A8_UNORM; break; + case D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB: format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; break; + case D2D1_BUFFER_PRECISION_16BPC_UNORM: format = DXGI_FORMAT_R16G16B16A16_UNORM; break; + case D2D1_BUFFER_PRECISION_16BPC_FLOAT: format = DXGI_FORMAT_R16G16B16A16_FLOAT; break; + case D2D1_BUFFER_PRECISION_32BPC_FLOAT: format = DXGI_FORMAT_R32G32B32A32_FLOAT; break; + default: + WARN("Unexpected precision %u.\n", buffer_precision); + return FALSE; + } + + if (FAILED(hr = ID3D11Device1_CheckFormatSupport(context->d3d_device, format, &support))) + { + WARN("Format support check failed, hr %#lx.\n", hr); + } + + return !!(support & D3D11_FORMAT_SUPPORT_BUFFER); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetImageLocalBounds(ID2D1DeviceContext6 *iface, + ID2D1Image *image, D2D1_RECT_F *local_bounds) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D_SIZE_U pixel_size; + ID2D1Bitmap *bitmap; + D2D_SIZE_F size; + + TRACE("iface %p, image %p, local_bounds %p.\n", iface, image, local_bounds); + + if (SUCCEEDED(ID2D1Image_QueryInterface(image, &IID_ID2D1Bitmap, (void **)&bitmap))) + { + local_bounds->left = 0.0f; + local_bounds->top = 0.0f; + switch (context->drawing_state.unitMode) + { + case D2D1_UNIT_MODE_DIPS: + size = ID2D1Bitmap_GetSize(bitmap); + local_bounds->right = size.width; + local_bounds->bottom = size.height; + break; + + case D2D1_UNIT_MODE_PIXELS: + pixel_size = ID2D1Bitmap_GetPixelSize(bitmap); + local_bounds->right = pixel_size.width; + local_bounds->bottom = pixel_size.height; + break; + + default: + WARN("Unknown unit mode %#x.\n", context->drawing_state.unitMode); + break; + } + ID2D1Bitmap_Release(bitmap); + + return S_OK; + } + else + { + FIXME("Unable to get local bounds of image %p.\n", image); + + return E_NOTIMPL; + } +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetImageWorldBounds(ID2D1DeviceContext6 *iface, + ID2D1Image *image, D2D1_RECT_F *world_bounds) +{ + FIXME("iface %p, image %p, world_bounds %p stub!\n", iface, image, world_bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetGlyphRunWorldBounds(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, + DWRITE_MEASURING_MODE measuring_mode, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, baseline_origin %s, glyph_run %p, measuring_mode %#x, bounds %p stub!\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, measuring_mode, bounds); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_GetDevice(ID2D1DeviceContext6 *iface, ID2D1Device **device) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (ID2D1Device *)&context->device->ID2D1Device6_iface; + ID2D1Device_AddRef(*device); +} + +static void d2d_device_context_reset_target(struct d2d_device_context *context) +{ + if (!context->target.object) + return; + + IUnknown_Release(context->target.object); + memset(&context->target, 0, sizeof(context->target)); + + /* Note that DPI settings are kept. */ + memset(&context->desc.pixelFormat, 0, sizeof(context->desc.pixelFormat)); + memset(&context->pixel_size, 0, sizeof(context->pixel_size)); + + if (context->bs) + ID3D11BlendState_Release(context->bs); + context->bs = NULL; +} + +static void STDMETHODCALLTYPE d2d_device_context_SetTarget(ID2D1DeviceContext6 *iface, ID2D1Image *target) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_command_list *command_list_impl; + struct d2d_bitmap *bitmap_impl; + ID2D1CommandList *command_list; + D3D11_BLEND_DESC blend_desc; + ID2D1Bitmap *bitmap; + HRESULT hr; + + TRACE("iface %p, target %p.\n", iface, target); + + if (!target) + { + d2d_device_context_reset_target(context); + return; + } + + if (SUCCEEDED(ID2D1Image_QueryInterface(target, &IID_ID2D1Bitmap, (void **)&bitmap))) + { + bitmap_impl = unsafe_impl_from_ID2D1Bitmap(bitmap); + + if (!(bitmap_impl->options & D2D1_BITMAP_OPTIONS_TARGET)) + { + ID2D1Bitmap_Release(bitmap); + d2d_device_context_set_error(context, D2DERR_INVALID_TARGET); + return; + } + + d2d_device_context_reset_target(context); + + /* Set sizes and pixel format. */ + context->pixel_size = bitmap_impl->pixel_size; + context->desc.pixelFormat = bitmap_impl->format; + context->target.bitmap = bitmap_impl; + context->target.object = target; + context->target.type = D2D_TARGET_BITMAP; + + memset(&blend_desc, 0, sizeof(blend_desc)); + blend_desc.IndependentBlendEnable = FALSE; + blend_desc.RenderTarget[0].BlendEnable = TRUE; + blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; + blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; + blend_desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; + blend_desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; + blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA; + blend_desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; + blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; + if (FAILED(hr = ID3D11Device1_CreateBlendState(context->d3d_device, &blend_desc, &context->bs))) + WARN("Failed to create blend state, hr %#lx.\n", hr); + } + else if (SUCCEEDED(ID2D1Image_QueryInterface(target, &IID_ID2D1CommandList, (void **)&command_list))) + { + command_list_impl = unsafe_impl_from_ID2D1CommandList(command_list); + + d2d_device_context_reset_target(context); + + context->target.command_list = command_list_impl; + context->target.object = target; + context->target.type = D2D_TARGET_COMMAND_LIST; + } + else + { + WARN("Unsupported target type.\n"); + } +} + +static void STDMETHODCALLTYPE d2d_device_context_GetTarget(ID2D1DeviceContext6 *iface, ID2D1Image **target) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, target %p.\n", iface, target); + + *target = context->target.object ? context->target.object : NULL; + if (*target) + ID2D1Image_AddRef(*target); +} + +static void STDMETHODCALLTYPE d2d_device_context_SetRenderingControls(ID2D1DeviceContext6 *iface, + const D2D1_RENDERING_CONTROLS *rendering_controls) +{ + FIXME("iface %p, rendering_controls %p stub!\n", iface, rendering_controls); +} + +static void STDMETHODCALLTYPE d2d_device_context_GetRenderingControls(ID2D1DeviceContext6 *iface, + D2D1_RENDERING_CONTROLS *rendering_controls) +{ + FIXME("iface %p, rendering_controls %p stub!\n", iface, rendering_controls); +} + +static void STDMETHODCALLTYPE d2d_device_context_SetPrimitiveBlend(ID2D1DeviceContext6 *iface, + D2D1_PRIMITIVE_BLEND primitive_blend) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, primitive_blend %u.\n", iface, primitive_blend); + + if (primitive_blend > D2D1_PRIMITIVE_BLEND_MAX) + { + WARN("Unknown blend mode %u.\n", primitive_blend); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_primitive_blend(context->target.command_list, primitive_blend); + + context->drawing_state.primitiveBlend = primitive_blend; +} + +static D2D1_PRIMITIVE_BLEND STDMETHODCALLTYPE d2d_device_context_GetPrimitiveBlend(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + return context->drawing_state.primitiveBlend; +} + +static void STDMETHODCALLTYPE d2d_device_context_SetUnitMode(ID2D1DeviceContext6 *iface, D2D1_UNIT_MODE unit_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, unit_mode %#x.\n", iface, unit_mode); + + if (unit_mode != D2D1_UNIT_MODE_DIPS && unit_mode != D2D1_UNIT_MODE_PIXELS) + { + WARN("Unknown unit mode %#x.\n", unit_mode); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_set_unit_mode(context->target.command_list, unit_mode); + + context->drawing_state.unitMode = unit_mode; +} + +static D2D1_UNIT_MODE STDMETHODCALLTYPE d2d_device_context_GetUnitMode(ID2D1DeviceContext6 *iface) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p.\n", iface); + + return context->drawing_state.unitMode; +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_DrawGlyphRun(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, + const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, baseline_origin %s, glyph_run %p, glyph_run_desc %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, glyph_run_desc, brush, measuring_mode); + + d2d_device_context_draw_glyph_run(context, baseline_origin, glyph_run, glyph_run_desc, brush, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawImage(ID2D1DeviceContext6 *iface, ID2D1Image *image, + const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, D2D1_INTERPOLATION_MODE interpolation_mode, + D2D1_COMPOSITE_MODE composite_mode) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + ID2D1Bitmap *bitmap; + + TRACE("iface %p, image %p, target_offset %s, image_rect %s, interpolation_mode %#x, composite_mode %#x.\n", + iface, image, debug_d2d_point_2f(target_offset), debug_d2d_rect_f(image_rect), + interpolation_mode, composite_mode); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_image(context->target.command_list, image, target_offset, image_rect, + interpolation_mode, composite_mode); + return; + } + + if (composite_mode != D2D1_COMPOSITE_MODE_SOURCE_OVER) + FIXME("Unhandled composite mode %#x.\n", composite_mode); + + if (SUCCEEDED(ID2D1Image_QueryInterface(image, &IID_ID2D1Bitmap, (void **)&bitmap))) + { + d2d_device_context_draw_bitmap(context, bitmap, NULL, 1.0f, interpolation_mode, image_rect, target_offset, NULL); + + ID2D1Bitmap_Release(bitmap); + return; + } + + FIXME("Unhandled image %p.\n", image); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawGdiMetafile(ID2D1DeviceContext6 *iface, + ID2D1GdiMetafile *metafile, const D2D1_POINT_2F *target_offset) +{ + FIXME("iface %p, metafile %p, target_offset %s stub!\n", + iface, metafile, debug_d2d_point_2f(target_offset)); +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_DrawBitmap(ID2D1DeviceContext6 *iface, + ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode, + const D2D1_RECT_F *src_rect, const D2D1_MATRIX_4X4_F *perspective_transform) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, " + "src_rect %s, perspective_transform %p.\n", + iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, + debug_d2d_rect_f(src_rect), perspective_transform); + + if (FAILED(context->error.code)) + return; + + if (context->target.type == D2D_TARGET_UNKNOWN) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + d2d_command_list_draw_bitmap(context->target.command_list, bitmap, dst_rect, opacity, interpolation_mode, + src_rect, perspective_transform); + } + else + { + d2d_device_context_draw_bitmap(context, bitmap, dst_rect, opacity, interpolation_mode, src_rect, + NULL, perspective_transform); + } +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_PushLayer(ID2D1DeviceContext6 *iface, + const D2D1_LAYER_PARAMETERS1 *layer_parameters, ID2D1Layer *layer) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p, layer_parameters %p, layer %p stub!\n", iface, layer_parameters, layer); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_push_layer(context->target.command_list, context, layer_parameters, layer); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_InvalidateEffectInputRectangle(ID2D1DeviceContext6 *iface, + ID2D1Effect *effect, UINT32 input, const D2D1_RECT_F *input_rect) +{ + FIXME("iface %p, effect %p, input %u, input_rect %s stub!\n", + iface, effect, input, debug_d2d_rect_f(input_rect)); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetEffectInvalidRectangleCount(ID2D1DeviceContext6 *iface, + ID2D1Effect *effect, UINT32 *rect_count) +{ + FIXME("iface %p, effect %p, rect_count %p stub!\n", iface, effect, rect_count); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetEffectInvalidRectangles(ID2D1DeviceContext6 *iface, + ID2D1Effect *effect, D2D1_RECT_F *rectangles, UINT32 rect_count) +{ + FIXME("iface %p, effect %p, rectangles %p, rect_count %u stub!\n", iface, effect, rectangles, rect_count); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetEffectRequiredInputRectangles(ID2D1DeviceContext6 *iface, + ID2D1Effect *effect, const D2D1_RECT_F *image_rect, const D2D1_EFFECT_INPUT_DESCRIPTION *desc, + D2D1_RECT_F *input_rect, UINT32 input_count) +{ + FIXME("iface %p, effect %p, image_rect %s, desc %p, input_rect %p, input_count %u stub!\n", + iface, effect, debug_d2d_rect_f(image_rect), desc, input_rect, input_count); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_FillOpacityMask(ID2D1DeviceContext6 *iface, + ID2D1Bitmap *mask, ID2D1Brush *brush, const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + + FIXME("iface %p, mask %p, brush %p, dst_rect %s, src_rect %s stub!\n", + iface, mask, brush, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect)); + + if (FAILED(context->error.code)) + return; + + if (context->drawing_state.antialiasMode != D2D1_ANTIALIAS_MODE_ALIASED) + { + d2d_device_context_set_error(context, D2DERR_WRONG_STATE); + return; + } + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + d2d_command_list_fill_opacity_mask(context->target.command_list, context, mask, brush, dst_rect, src_rect); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateFilledGeometryRealization(ID2D1DeviceContext6 *iface, + ID2D1Geometry *geometry, float tolerance, ID2D1GeometryRealization **realization) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_geometry_realization *object; + HRESULT hr; + + TRACE("iface %p, geometry %p, tolerance %.8e, realization %p.\n", iface, geometry, tolerance, + realization); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_geometry_realization_init(object, context->factory, geometry))) + { + WARN("Failed to initialise geometry realization, hr %#lx.\n", hr); + free(object); + return hr; + } + object->filled = true; + + TRACE("Created geometry realization %p.\n", object); + *realization = &object->ID2D1GeometryRealization_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateStrokedGeometryRealization( + ID2D1DeviceContext6 *iface, ID2D1Geometry *geometry, float tolerance, float stroke_width, + ID2D1StrokeStyle *stroke_style, ID2D1GeometryRealization **realization) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_geometry_realization *object; + HRESULT hr; + + TRACE("iface %p, geometry %p, tolerance %.8e, stroke_width %.8e, stroke_style %p, realization %p.\n", + iface, geometry, tolerance, stroke_width, stroke_style, realization); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_geometry_realization_init(object, context->factory, geometry))) + { + WARN("Failed to initialise geometry realization, hr %#lx.\n", hr); + free(object); + return hr; + } + object->stroke_width = stroke_width; + object->stroke_style = stroke_style; + if (object->stroke_style) + ID2D1StrokeStyle_AddRef(object->stroke_style); + + TRACE("Created geometry realization %p.\n", object); + *realization = &object->ID2D1GeometryRealization_iface; + + return S_OK; +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawGeometryRealization(ID2D1DeviceContext6 *iface, + ID2D1GeometryRealization *realization, ID2D1Brush *brush) +{ + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + struct d2d_geometry_realization *r = unsafe_impl_from_ID2D1GeometryRealization(realization); + + FIXME("iface %p, realization %p, brush %p semi-stub!\n", iface, realization, brush); + + if (context->target.type == D2D_TARGET_COMMAND_LIST) + { + if (r->filled) + { + d2d_command_list_fill_geometry(context->target.command_list, context, r->geometry, brush, NULL); + } + else + { + d2d_command_list_draw_geometry(context->target.command_list, context, r->geometry, brush, + r->stroke_width, r->stroke_style); + } + return; + } +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateInk(ID2D1DeviceContext6 *iface, + const D2D1_INK_POINT *start_point, ID2D1Ink **ink) +{ + FIXME("iface %p, start_point %p, ink %p stub!\n", iface, start_point, ink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateInkStyle(ID2D1DeviceContext6 *iface, + const D2D1_INK_STYLE_PROPERTIES *ink_style_properties, ID2D1InkStyle **ink_style) +{ + FIXME("iface %p, ink_style_properties %p, ink_style %p stub!\n", iface, ink_style_properties, ink_style); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateGradientMesh(ID2D1DeviceContext6 *iface, + const D2D1_GRADIENT_MESH_PATCH *patches, UINT32 patches_count, + ID2D1GradientMesh **gradient_mesh) +{ + FIXME("iface %p, patches %p, patches_count %u, gradient_mesh %p stub!\n", iface, patches, + patches_count, gradient_mesh); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateImageSourceFromWic(ID2D1DeviceContext6 *iface, + IWICBitmapSource *wic_bitmap_source, D2D1_IMAGE_SOURCE_LOADING_OPTIONS loading_options, + D2D1_ALPHA_MODE alpha_mode, ID2D1ImageSourceFromWic **image_source) +{ + FIXME("iface %p, wic_bitmap_source %p, loading_options %#x, alpha_mode %u, image_source %p stub!\n", + iface, wic_bitmap_source, loading_options, alpha_mode, image_source); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateLookupTable3D(ID2D1DeviceContext6 *iface, + D2D1_BUFFER_PRECISION precision, const UINT32 *extents, const BYTE *data, + UINT32 data_count, const UINT32 *strides, ID2D1LookupTable3D **lookup_table) +{ + FIXME("iface %p, precision %u, extents %p, data %p, data_count %u, strides %p, lookup_table %p stub!\n", + iface, precision, extents, data, data_count, strides, lookup_table); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateImageSourceFromDxgi(ID2D1DeviceContext6 *iface, + IDXGISurface **surfaces, UINT32 surface_count, DXGI_COLOR_SPACE_TYPE color_space, + D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS options, ID2D1ImageSource **image_source) +{ + FIXME("iface %p, surfaces %p, surface_count %u, color_space %u, options %#x, image_source %p stub!\n", + iface, surfaces, surface_count, color_space, options, image_source); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetGradientMeshWorldBounds(ID2D1DeviceContext6 *iface, + ID2D1GradientMesh *gradient_mesh, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, gradient_mesh %p, bounds %p stub!\n", iface, gradient_mesh, bounds); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawInk(ID2D1DeviceContext6 *iface, ID2D1Ink *ink, + ID2D1Brush *brush, ID2D1InkStyle *ink_style) +{ + FIXME("iface %p, ink %p, brush %p, ink_style %p stub!\n", iface, ink, brush, ink_style); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawGradientMesh(ID2D1DeviceContext6 *iface, + ID2D1GradientMesh *gradient_mesh) +{ + FIXME("iface %p, gradient_mesh %p stub!\n", iface, gradient_mesh); +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext2_DrawGdiMetafile( + ID2D1DeviceContext6 *iface, ID2D1GdiMetafile *gdi_metafile, const D2D1_RECT_F *dst_rect, + const D2D1_RECT_F *src_rect) +{ + FIXME("iface %p, gdi_metafile %p, dst_rect %s, src_rect %s stub!\n", iface, gdi_metafile, + debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect)); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateTransformedImageSource(ID2D1DeviceContext6 *iface, + ID2D1ImageSource *source, const D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES *props, + ID2D1TransformedImageSource **transformed) +{ + FIXME("iface %p, source %p, props %p, transformed %p stub!\n", iface, source, props, transformed); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSpriteBatch(ID2D1DeviceContext6 *iface, + ID2D1SpriteBatch **sprite_batch) +{ + FIXME("iface %p, sprite_batch %p stub!\n", iface, sprite_batch); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawSpriteBatch(ID2D1DeviceContext6 *iface, + ID2D1SpriteBatch *sprite_batch, UINT32 start_index, UINT32 sprite_count, ID2D1Bitmap *bitmap, + D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, D2D1_SPRITE_OPTIONS sprite_options) +{ + FIXME("iface %p, sprite_batch %p, start_index %u, sprite_count %u, bitmap %p, interpolation_mode %u," + "sprite_options %u stub!\n", iface, sprite_batch, start_index, sprite_count, bitmap, + interpolation_mode, sprite_options); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSvgGlyphStyle(ID2D1DeviceContext6 *iface, + ID2D1SvgGlyphStyle **svg_glyph_style) +{ + FIXME("iface %p, svg_glyph_style %p stub!\n", iface, svg_glyph_style); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext4_DrawText(ID2D1DeviceContext6 *iface, + const WCHAR *string, UINT32 string_length, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect, + ID2D1Brush *default_fill_brush, ID2D1SvgGlyphStyle *svg_glyph_style, UINT32 color_palette_index, + D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode) +{ + FIXME("iface %p, string %s, string_length %u, text_format %p, layout_rect %s, default_fill_brush %p," + "svg_glyph_style %p, color_palette_index %u, options %#x, measuring_mode %u stub!\n", + iface, debugstr_wn(string, string_length), string_length, text_format, debug_d2d_rect_f(layout_rect), + default_fill_brush, svg_glyph_style, color_palette_index, options, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext4_DrawTextLayout(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F origin, IDWriteTextLayout *text_layout, ID2D1Brush *default_fill_brush, + ID2D1SvgGlyphStyle *svg_glyph_style, UINT32 color_palette_index, D2D1_DRAW_TEXT_OPTIONS options) +{ + FIXME("iface %p, origin %s, text_layout %p, default_fill_brush %p, svg_glyph_style %p, color_palette_index %u," + "options %#x stub!\n", iface, debug_d2d_point_2f(&origin), text_layout, default_fill_brush, + svg_glyph_style, color_palette_index, options); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawColorBitmapGlyphRun(ID2D1DeviceContext6 *iface, + DWRITE_GLYPH_IMAGE_FORMATS glyph_image_format, D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, + DWRITE_MEASURING_MODE measuring_mode, D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION bitmap_snap_option) +{ + FIXME("iface %p, glyph_image_format %#x, baseline_origin %s, glyph_run %p, measuring_mode %u, bitmap_snap_option %#x stub!\n", + iface, glyph_image_format, debug_d2d_point_2f(&baseline_origin), glyph_run, measuring_mode, bitmap_snap_option); +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawSvgGlyphRun(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *default_fill_brush, + ID2D1SvgGlyphStyle *svg_glyph_style, UINT32 color_palette_index, DWRITE_MEASURING_MODE measuring_mode) +{ + FIXME("iface %p, baseline_origin %s, glyph_run %p, default_fill_brush %p, svg_glyph_style %p," + "color_palette_index %u, measuring_mode %u stub!\n", iface, debug_d2d_point_2f(&baseline_origin), + glyph_run, default_fill_brush, svg_glyph_style, color_palette_index, measuring_mode); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetColorBitmapGlyphImage(ID2D1DeviceContext6 *iface, + DWRITE_GLYPH_IMAGE_FORMATS glyph_image_format, D2D1_POINT_2F glyph_origin, IDWriteFontFace *font_face, + FLOAT font_em_size, UINT16 glyph_index, BOOL is_sideways, const D2D1_MATRIX_3X2_F *world_transform, + FLOAT dpi_x, FLOAT dpi_y, D2D1_MATRIX_3X2_F *glyph_transform, ID2D1Image **glyph_image) +{ + FIXME("iface %p, glyph_image_format %u, glyph_origin %s, font_face %p, font_em_size %f, glyph_index %u," + "is_sideways %d, world_transform %p, dpi_x %f, dpi_y %f, glyph_transform %p, glyph_image %p stub!\n", + iface, glyph_image_format, debug_d2d_point_2f(&glyph_origin), font_face, font_em_size, glyph_index, + is_sideways, world_transform, dpi_x, dpi_y, glyph_transform, glyph_image); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_GetSvgGlyphImage(ID2D1DeviceContext6 *iface, + D2D1_POINT_2F glyph_origin, IDWriteFontFace *font_face, FLOAT font_em_size, UINT16 glyph_index, + BOOL is_sideways, const D2D1_MATRIX_3X2_F *world_transform, ID2D1Brush *default_fill_brush, + ID2D1SvgGlyphStyle *svg_glyph_style, UINT32 color_palette_index, D2D1_MATRIX_3X2_F *glyph_transform, + ID2D1CommandList **glyph_image) +{ + FIXME("iface %p, glyph_origin %s, font_face %p, font_em_size %f, glyph_index %u, is_sideways %d," + "world_transform %p, default_fill_brush %p, svg_glyph_style %p, color_palette_index %u," + "glyph_transform %p, glyph_image %p stub!\n", iface, debug_d2d_point_2f(&glyph_origin), + font_face, font_em_size, glyph_index, is_sideways, world_transform, default_fill_brush, + svg_glyph_style, color_palette_index, glyph_transform, glyph_image); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSvgDocument(ID2D1DeviceContext6 *iface, + IStream *input_xml_stream, D2D1_SIZE_F viewport_size, ID2D1SvgDocument **svg_document) +{ + FIXME("iface %p, input_xml_stream %p, svg_document %p stub!\n", iface, input_xml_stream, + svg_document); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_DrawSvgDocument(ID2D1DeviceContext6 *iface, + ID2D1SvgDocument *svg_document) +{ + FIXME("iface %p, svg_document %p stub!\n", iface, svg_document); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromDxgiColorSpace( + ID2D1DeviceContext6 *iface, DXGI_COLOR_SPACE_TYPE color_space, ID2D1ColorContext1 **color_context) +{ + FIXME("iface %p, color_space %u, color_context %p stub!\n", iface, color_space, color_context); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromSimpleColorProfile( + ID2D1DeviceContext6 *iface, const D2D1_SIMPLE_COLOR_PROFILE *simple_profile, ID2D1ColorContext1 **color_context) +{ + FIXME("iface %p, simple_profile %p, color_context %p stub!\n", iface, simple_profile, color_context); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_device_context_BlendImage(ID2D1DeviceContext6 *iface, ID2D1Image *image, + D2D1_BLEND_MODE blend_mode, const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, + D2D1_INTERPOLATION_MODE interpolation_mode) +{ + FIXME("iface %p, image %p, blend_mode %u, target_offset %s, image_rect %s, interpolation_mode %u stub!\n", + iface, image, blend_mode, debug_d2d_point_2f(target_offset), debug_d2d_rect_f(image_rect), + interpolation_mode); +} + +static const struct ID2D1DeviceContext6Vtbl d2d_device_context_vtbl = +{ + d2d_device_context_QueryInterface, + d2d_device_context_AddRef, + d2d_device_context_Release, + d2d_device_context_GetFactory, + d2d_device_context_CreateBitmap, + d2d_device_context_CreateBitmapFromWicBitmap, + d2d_device_context_CreateSharedBitmap, + d2d_device_context_CreateBitmapBrush, + d2d_device_context_CreateSolidColorBrush, + d2d_device_context_CreateGradientStopCollection, + d2d_device_context_CreateLinearGradientBrush, + d2d_device_context_CreateRadialGradientBrush, + d2d_device_context_CreateCompatibleRenderTarget, + d2d_device_context_CreateLayer, + d2d_device_context_CreateMesh, + d2d_device_context_DrawLine, + d2d_device_context_DrawRectangle, + d2d_device_context_FillRectangle, + d2d_device_context_DrawRoundedRectangle, + d2d_device_context_FillRoundedRectangle, + d2d_device_context_DrawEllipse, + d2d_device_context_FillEllipse, + d2d_device_context_DrawGeometry, + d2d_device_context_FillGeometry, + d2d_device_context_FillMesh, + d2d_device_context_FillOpacityMask, + d2d_device_context_DrawBitmap, + d2d_device_context_DrawText, + d2d_device_context_DrawTextLayout, + d2d_device_context_DrawGlyphRun, + d2d_device_context_SetTransform, + d2d_device_context_GetTransform, + d2d_device_context_SetAntialiasMode, + d2d_device_context_GetAntialiasMode, + d2d_device_context_SetTextAntialiasMode, + d2d_device_context_GetTextAntialiasMode, + d2d_device_context_SetTextRenderingParams, + d2d_device_context_GetTextRenderingParams, + d2d_device_context_SetTags, + d2d_device_context_GetTags, + d2d_device_context_PushLayer, + d2d_device_context_PopLayer, + d2d_device_context_Flush, + d2d_device_context_SaveDrawingState, + d2d_device_context_RestoreDrawingState, + d2d_device_context_PushAxisAlignedClip, + d2d_device_context_PopAxisAlignedClip, + d2d_device_context_Clear, + d2d_device_context_BeginDraw, + d2d_device_context_EndDraw, + d2d_device_context_GetPixelFormat, + d2d_device_context_SetDpi, + d2d_device_context_GetDpi, + d2d_device_context_GetSize, + d2d_device_context_GetPixelSize, + d2d_device_context_GetMaximumBitmapSize, + d2d_device_context_IsSupported, + d2d_device_context_ID2D1DeviceContext_CreateBitmap, + d2d_device_context_ID2D1DeviceContext_CreateBitmapFromWicBitmap, + d2d_device_context_CreateColorContext, + d2d_device_context_CreateColorContextFromFilename, + d2d_device_context_CreateColorContextFromWicColorContext, + d2d_device_context_CreateBitmapFromDxgiSurface, + d2d_device_context_CreateEffect, + d2d_device_context_ID2D1DeviceContext_CreateGradientStopCollection, + d2d_device_context_CreateImageBrush, + d2d_device_context_ID2D1DeviceContext_CreateBitmapBrush, + d2d_device_context_CreateCommandList, + d2d_device_context_IsDxgiFormatSupported, + d2d_device_context_IsBufferPrecisionSupported, + d2d_device_context_GetImageLocalBounds, + d2d_device_context_GetImageWorldBounds, + d2d_device_context_GetGlyphRunWorldBounds, + d2d_device_context_GetDevice, + d2d_device_context_SetTarget, + d2d_device_context_GetTarget, + d2d_device_context_SetRenderingControls, + d2d_device_context_GetRenderingControls, + d2d_device_context_SetPrimitiveBlend, + d2d_device_context_GetPrimitiveBlend, + d2d_device_context_SetUnitMode, + d2d_device_context_GetUnitMode, + d2d_device_context_ID2D1DeviceContext_DrawGlyphRun, + d2d_device_context_DrawImage, + d2d_device_context_DrawGdiMetafile, + d2d_device_context_ID2D1DeviceContext_DrawBitmap, + d2d_device_context_ID2D1DeviceContext_PushLayer, + d2d_device_context_InvalidateEffectInputRectangle, + d2d_device_context_GetEffectInvalidRectangleCount, + d2d_device_context_GetEffectInvalidRectangles, + d2d_device_context_GetEffectRequiredInputRectangles, + d2d_device_context_ID2D1DeviceContext_FillOpacityMask, + d2d_device_context_CreateFilledGeometryRealization, + d2d_device_context_CreateStrokedGeometryRealization, + d2d_device_context_DrawGeometryRealization, + d2d_device_context_CreateInk, + d2d_device_context_CreateInkStyle, + d2d_device_context_CreateGradientMesh, + d2d_device_context_CreateImageSourceFromWic, + d2d_device_context_CreateLookupTable3D, + d2d_device_context_CreateImageSourceFromDxgi, + d2d_device_context_GetGradientMeshWorldBounds, + d2d_device_context_DrawInk, + d2d_device_context_DrawGradientMesh, + d2d_device_context_ID2D1DeviceContext2_DrawGdiMetafile, + d2d_device_context_CreateTransformedImageSource, + d2d_device_context_CreateSpriteBatch, + d2d_device_context_DrawSpriteBatch, + d2d_device_context_CreateSvgGlyphStyle, + d2d_device_context_ID2D1DeviceContext4_DrawText, + d2d_device_context_ID2D1DeviceContext4_DrawTextLayout, + d2d_device_context_DrawColorBitmapGlyphRun, + d2d_device_context_DrawSvgGlyphRun, + d2d_device_context_GetColorBitmapGlyphImage, + d2d_device_context_GetSvgGlyphImage, + d2d_device_context_CreateSvgDocument, + d2d_device_context_DrawSvgDocument, + d2d_device_context_CreateColorContextFromDxgiColorSpace, + d2d_device_context_CreateColorContextFromSimpleColorProfile, + d2d_device_context_BlendImage, +}; + +static inline struct d2d_device_context *impl_from_IDWriteTextRenderer(IDWriteTextRenderer *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_device_context, IDWriteTextRenderer_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_QueryInterface(IDWriteTextRenderer *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_IDWriteTextRenderer) + || IsEqualGUID(iid, &IID_IDWritePixelSnapping) + || IsEqualGUID(iid, &IID_IUnknown)) + { + IDWriteTextRenderer_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_text_renderer_AddRef(IDWriteTextRenderer *iface) +{ + struct d2d_device_context *context = impl_from_IDWriteTextRenderer(iface); + + TRACE("iface %p.\n", iface); + + return d2d_device_context_AddRef(&context->ID2D1DeviceContext6_iface); +} + +static ULONG STDMETHODCALLTYPE d2d_text_renderer_Release(IDWriteTextRenderer *iface) +{ + struct d2d_device_context *context = impl_from_IDWriteTextRenderer(iface); + + TRACE("iface %p.\n", iface); + + return d2d_device_context_Release(&context->ID2D1DeviceContext6_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_IsPixelSnappingDisabled(IDWriteTextRenderer *iface, + void *ctx, BOOL *disabled) +{ + struct d2d_draw_text_layout_ctx *context = ctx; + + TRACE("iface %p, ctx %p, disabled %p.\n", iface, ctx, disabled); + + *disabled = context->options & D2D1_DRAW_TEXT_OPTIONS_NO_SNAP; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_GetCurrentTransform(IDWriteTextRenderer *iface, + void *ctx, DWRITE_MATRIX *transform) +{ + struct d2d_device_context *context = impl_from_IDWriteTextRenderer(iface); + + TRACE("iface %p, ctx %p, transform %p.\n", iface, ctx, transform); + + d2d_device_context_GetTransform(&context->ID2D1DeviceContext6_iface, (D2D1_MATRIX_3X2_F *)transform); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_GetPixelsPerDip(IDWriteTextRenderer *iface, void *ctx, float *ppd) +{ + struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface); + + TRACE("iface %p, ctx %p, ppd %p.\n", iface, ctx, ppd); + + *ppd = render_target->desc.dpiY / 96.0f; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawGlyphRun(IDWriteTextRenderer *iface, void *ctx, + float baseline_origin_x, float baseline_origin_y, DWRITE_MEASURING_MODE measuring_mode, + const DWRITE_GLYPH_RUN *glyph_run, const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, IUnknown *effect) +{ + struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface); + D2D1_POINT_2F baseline_origin = {baseline_origin_x, baseline_origin_y}; + struct d2d_draw_text_layout_ctx *context = ctx; + BOOL color_font = FALSE; + ID2D1Brush *brush; + + TRACE("iface %p, ctx %p, baseline_origin_x %.8e, baseline_origin_y %.8e, " + "measuring_mode %#x, glyph_run %p, glyph_run_desc %p, effect %p.\n", + iface, ctx, baseline_origin_x, baseline_origin_y, + measuring_mode, glyph_run, glyph_run_desc, effect); + + if (context->options & ~(D2D1_DRAW_TEXT_OPTIONS_NO_SNAP | D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT)) + FIXME("Ignoring options %#x.\n", context->options); + + brush = d2d_draw_get_text_brush(context, effect); + + TRACE("%s\n", debugstr_wn(glyph_run_desc->string, glyph_run_desc->stringLength)); + + if (context->options & D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT) + { + IDWriteFontFace2 *fontface; + + if (SUCCEEDED(IDWriteFontFace_QueryInterface(glyph_run->fontFace, + &IID_IDWriteFontFace2, (void **)&fontface))) + { + color_font = IDWriteFontFace2_IsColorFont(fontface); + IDWriteFontFace2_Release(fontface); + } + } + + if (color_font) + { + IDWriteColorGlyphRunEnumerator *layers; + IDWriteFactory2 *dwrite_factory; + HRESULT hr; + + if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory2, + (IUnknown **)&dwrite_factory))) + { + ERR("Failed to create dwrite factory, hr %#lx.\n", hr); + ID2D1Brush_Release(brush); + return hr; + } + + hr = IDWriteFactory2_TranslateColorGlyphRun(dwrite_factory, baseline_origin_x, baseline_origin_y, + glyph_run, glyph_run_desc, measuring_mode, (DWRITE_MATRIX *)&render_target->drawing_state.transform, 0, &layers); + IDWriteFactory2_Release(dwrite_factory); + if (FAILED(hr)) + { + ERR("Failed to create colour glyph run enumerator, hr %#lx.\n", hr); + ID2D1Brush_Release(brush); + return hr; + } + + for (;;) + { + const DWRITE_COLOR_GLYPH_RUN *color_run; + ID2D1Brush *color_brush; + D2D1_POINT_2F origin; + BOOL has_run = FALSE; + + if (FAILED(hr = IDWriteColorGlyphRunEnumerator_MoveNext(layers, &has_run))) + { + ERR("Failed to switch colour glyph layer, hr %#lx.\n", hr); + break; + } + + if (!has_run) + break; + + if (FAILED(hr = IDWriteColorGlyphRunEnumerator_GetCurrentRun(layers, &color_run))) + { + ERR("Failed to get current colour run, hr %#lx.\n", hr); + break; + } + + if (color_run->paletteIndex == 0xffff) + color_brush = brush; + else + { + if (FAILED(hr = d2d_device_context_CreateSolidColorBrush(&render_target->ID2D1DeviceContext6_iface, + &color_run->runColor, NULL, (ID2D1SolidColorBrush **)&color_brush))) + { + ERR("Failed to create solid colour brush, hr %#lx.\n", hr); + break; + } + } + + origin.x = color_run->baselineOriginX; + origin.y = color_run->baselineOriginY; + d2d_device_context_draw_glyph_run(render_target, origin, &color_run->glyphRun, + color_run->glyphRunDescription, color_brush, measuring_mode); + + if (color_brush != brush) + ID2D1Brush_Release(color_brush); + } + + IDWriteColorGlyphRunEnumerator_Release(layers); + } + else + d2d_device_context_draw_glyph_run(render_target, baseline_origin, glyph_run, glyph_run_desc, + brush, measuring_mode); + + ID2D1Brush_Release(brush); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawUnderline(IDWriteTextRenderer *iface, void *ctx, + float baseline_origin_x, float baseline_origin_y, const DWRITE_UNDERLINE *underline, IUnknown *effect) +{ + struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface); + const D2D1_MATRIX_3X2_F *m = &render_target->drawing_state.transform; + struct d2d_draw_text_layout_ctx *context = ctx; + D2D1_ANTIALIAS_MODE prev_antialias_mode; + D2D1_POINT_2F start, end; + ID2D1Brush *brush; + float thickness; + + TRACE("iface %p, ctx %p, baseline_origin_x %.8e, baseline_origin_y %.8e, underline %p, effect %p\n", + iface, ctx, baseline_origin_x, baseline_origin_y, underline, effect); + + /* minimal thickness in DIPs that will result in at least 1 pixel thick line */ + thickness = max(96.0f / (render_target->desc.dpiY * sqrtf(m->_21 * m->_21 + m->_22 * m->_22)), + underline->thickness); + + brush = d2d_draw_get_text_brush(context, effect); + + start.x = baseline_origin_x; + start.y = baseline_origin_y + underline->offset + thickness / 2.0f; + end.x = start.x + underline->width; + end.y = start.y; + prev_antialias_mode = d2d_device_context_set_aa_mode_from_text_aa_mode(render_target); + d2d_device_context_DrawLine(&render_target->ID2D1DeviceContext6_iface, start, end, brush, thickness, NULL); + render_target->drawing_state.antialiasMode = prev_antialias_mode; + + ID2D1Brush_Release(brush); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawStrikethrough(IDWriteTextRenderer *iface, void *ctx, + float baseline_origin_x, float baseline_origin_y, const DWRITE_STRIKETHROUGH *strikethrough, IUnknown *effect) +{ + struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface); + const D2D1_MATRIX_3X2_F *m = &render_target->drawing_state.transform; + struct d2d_draw_text_layout_ctx *context = ctx; + D2D1_ANTIALIAS_MODE prev_antialias_mode; + D2D1_POINT_2F start, end; + ID2D1Brush *brush; + float thickness; + + TRACE("iface %p, ctx %p, baseline_origin_x %.8e, baseline_origin_y %.8e, strikethrough %p, effect %p.\n", + iface, ctx, baseline_origin_x, baseline_origin_y, strikethrough, effect); + + /* minimal thickness in DIPs that will result in at least 1 pixel thick line */ + thickness = max(96.0f / (render_target->desc.dpiY * sqrtf(m->_21 * m->_21 + m->_22 * m->_22)), + strikethrough->thickness); + + brush = d2d_draw_get_text_brush(context, effect); + + start.x = baseline_origin_x; + start.y = baseline_origin_y + strikethrough->offset + thickness / 2.0f; + end.x = start.x + strikethrough->width; + end.y = start.y; + prev_antialias_mode = d2d_device_context_set_aa_mode_from_text_aa_mode(render_target); + d2d_device_context_DrawLine(&render_target->ID2D1DeviceContext6_iface, start, end, brush, thickness, NULL); + render_target->drawing_state.antialiasMode = prev_antialias_mode; + + ID2D1Brush_Release(brush); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawInlineObject(IDWriteTextRenderer *iface, void *ctx, + float origin_x, float origin_y, IDWriteInlineObject *object, BOOL is_sideways, BOOL is_rtl, IUnknown *effect) +{ + struct d2d_draw_text_layout_ctx *context = ctx; + ID2D1Brush *brush; + HRESULT hr; + + TRACE("iface %p, ctx %p, origin_x %.8e, origin_y %.8e, object %p, is_sideways %#x, is_rtl %#x, effect %p.\n", + iface, ctx, origin_x, origin_y, object, is_sideways, is_rtl, effect); + + /* Inline objects may not pass effects all the way down, when using layout object internally for example. + This is how default trimming sign object in DirectWrite works - it does not use effect passed to Draw(), + and resulting DrawGlyphRun() is always called with NULL effect, however original effect is used and correct + brush is selected at Direct2D level. */ + brush = context->brush; + context->brush = d2d_draw_get_text_brush(context, effect); + + hr = IDWriteInlineObject_Draw(object, ctx, iface, origin_x, origin_y, is_sideways, is_rtl, effect); + + ID2D1Brush_Release(context->brush); + context->brush = brush; + + return hr; +} + +static const struct IDWriteTextRendererVtbl d2d_text_renderer_vtbl = +{ + d2d_text_renderer_QueryInterface, + d2d_text_renderer_AddRef, + d2d_text_renderer_Release, + d2d_text_renderer_IsPixelSnappingDisabled, + d2d_text_renderer_GetCurrentTransform, + d2d_text_renderer_GetPixelsPerDip, + d2d_text_renderer_DrawGlyphRun, + d2d_text_renderer_DrawUnderline, + d2d_text_renderer_DrawStrikethrough, + d2d_text_renderer_DrawInlineObject, +}; + +static inline struct d2d_device_context *impl_from_ID2D1GdiInteropRenderTarget(ID2D1GdiInteropRenderTarget *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_device_context, ID2D1GdiInteropRenderTarget_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_gdi_interop_render_target_QueryInterface(ID2D1GdiInteropRenderTarget *iface, + REFIID iid, void **out) +{ + struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + return IUnknown_QueryInterface(render_target->outer_unknown, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_gdi_interop_render_target_AddRef(ID2D1GdiInteropRenderTarget *iface) +{ + struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return IUnknown_AddRef(render_target->outer_unknown); +} + +static ULONG STDMETHODCALLTYPE d2d_gdi_interop_render_target_Release(ID2D1GdiInteropRenderTarget *iface) +{ + struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return IUnknown_Release(render_target->outer_unknown); +} + +static HRESULT d2d_gdi_interop_get_surface(struct d2d_device_context *context, IDXGISurface1 **surface) +{ + ID3D11Resource *resource; + HRESULT hr; + + if (context->target.type != D2D_TARGET_BITMAP) + { + FIXME("Unimplemented for target type %u.\n", context->target.type); + return E_NOTIMPL; + } + + if (!(context->target.bitmap->options & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE)) + return D2DERR_TARGET_NOT_GDI_COMPATIBLE; + + ID3D11RenderTargetView_GetResource(context->target.bitmap->rtv, &resource); + hr = ID3D11Resource_QueryInterface(resource, &IID_IDXGISurface1, (void **)surface); + ID3D11Resource_Release(resource); + if (FAILED(hr)) + { + *surface = NULL; + WARN("Failed to get DXGI surface, %#lx.\n", hr); + return hr; + } + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_gdi_interop_render_target_GetDC(ID2D1GdiInteropRenderTarget *iface, + D2D1_DC_INITIALIZE_MODE mode, HDC *dc) +{ + struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface); + IDXGISurface1 *surface; + HRESULT hr; + + TRACE("iface %p, mode %d, dc %p.\n", iface, mode, dc); + + *dc = NULL; + + if (render_target->target.hdc) + return D2DERR_WRONG_STATE; + + if (FAILED(hr = d2d_gdi_interop_get_surface(render_target, &surface))) + return hr; + + hr = IDXGISurface1_GetDC(surface, mode != D2D1_DC_INITIALIZE_MODE_COPY, &render_target->target.hdc); + IDXGISurface1_Release(surface); + + if (SUCCEEDED(hr)) + *dc = render_target->target.hdc; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_gdi_interop_render_target_ReleaseDC(ID2D1GdiInteropRenderTarget *iface, + const RECT *update) +{ + struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface); + IDXGISurface1 *surface; + RECT update_rect; + HRESULT hr; + + TRACE("iface %p, update rect %s.\n", iface, wine_dbgstr_rect(update)); + + if (!render_target->target.hdc) + return D2DERR_WRONG_STATE; + + if (FAILED(hr = d2d_gdi_interop_get_surface(render_target, &surface))) + return hr; + + render_target->target.hdc = NULL; + if (update) + update_rect = *update; + hr = IDXGISurface1_ReleaseDC(surface, update ? &update_rect : NULL); + IDXGISurface1_Release(surface); + + return hr; +} + +static const struct ID2D1GdiInteropRenderTargetVtbl d2d_gdi_interop_render_target_vtbl = +{ + d2d_gdi_interop_render_target_QueryInterface, + d2d_gdi_interop_render_target_AddRef, + d2d_gdi_interop_render_target_Release, + d2d_gdi_interop_render_target_GetDC, + d2d_gdi_interop_render_target_ReleaseDC, +}; + + +static const D3D11_INPUT_ELEMENT_DESC shape_il_desc_outline[] = +{ + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"PREV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"NEXT", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0}, +}; +static const D3D11_INPUT_ELEMENT_DESC shape_il_desc_curve_outline[] = +{ + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"P", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"P", 1, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"P", 2, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"PREV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"NEXT", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 40, D3D11_INPUT_PER_VERTEX_DATA, 0}, +}; +static const D3D11_INPUT_ELEMENT_DESC shape_il_desc_triangle[] = +{ + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, +}; +static const D3D11_INPUT_ELEMENT_DESC shape_il_desc_curve[] = +{ + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0}, +}; +static const char shape_vs_code_outline[] = + "float3x2 transform_geometry;\n" + "float stroke_width;\n" + "float4 transform_rtx;\n" + "float4 transform_rty;\n" + "\n" + "struct output\n" + "{\n" + " float2 p : WORLD_POSITION;\n" + " float4 b : BEZIER;\n" + " nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n" + " float4 position : SV_POSITION;\n" + "};\n" + "\n" + "/* The lines PₚᵣₑᵥP₀ and P₀Pₙₑₓₜ, both offset by ±½w, intersect each other at:\n" + " *\n" + " * Pᵢ = P₀ ± w · ½q⃑ᵢ.\n" + " *\n" + " * Where:\n" + " *\n" + " * q⃑ᵢ = q̂ₚᵣₑᵥ⊥ + tan(½θ) · -q̂ₚᵣₑᵥ\n" + " * θ = ∠PₚᵣₑᵥP₀Pₙₑₓₜ\n" + " * q⃑ₚᵣₑᵥ = P₀ - Pₚᵣₑᵥ */\n" + "void main(float2 position : POSITION, float2 prev : PREV, float2 next : NEXT, out struct output o)\n" + "{\n" + " float2 q_prev, q_next, v_p, q_i;\n" + " float2x2 geom;\n" + " float l;\n" + "\n" + " o.stroke_transform = float2x2(transform_rtx.xy, transform_rty.xy) * stroke_width * 0.5f;\n" + "\n" + " geom = float2x2(transform_geometry._11_21, transform_geometry._12_22);\n" + " q_prev = normalize(mul(geom, prev));\n" + " q_next = normalize(mul(geom, next));\n" + "\n" + " /* tan(½θ) = sin(θ) / (1 + cos(θ))\n" + " * = (q̂ₚᵣₑᵥ⊥ · q̂ₙₑₓₜ) / (1 + (q̂ₚᵣₑᵥ · q̂ₙₑₓₜ)) */\n" + " v_p = float2(-q_prev.y, q_prev.x);\n" + " l = -dot(v_p, q_next) / (1.0f + dot(q_prev, q_next));\n" + " q_i = l * q_prev + v_p;\n" + "\n" + " o.b = float4(0.0, 0.0, 0.0, 0.0);\n" + "\n" + " o.p = mul(float3(position, 1.0f), transform_geometry) + stroke_width * 0.5f * q_i;\n" + " position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n" + " * float2(transform_rtx.w, transform_rty.w);\n" + " o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n" + "}\n"; +/* ⎡p0.x p0.y 1⎤ + * A = ⎢p1.x p1.y 1⎥ + * ⎣p2.x p2.y 1⎦ + * + * ⎡0 0⎤ + * B = ⎢½ 0⎥ + * ⎣1 1⎦ + * + * A' = ⎡p1.x-p0.x p1.y-p0.y⎤ + * ⎣p2.x-p0.x p2.y-p0.y⎦ + * + * B' = ⎡½ 0⎤ + * ⎣1 1⎦ + * + * A'T = B' + * T = A'⁻¹B' + */ +static const char shape_vs_code_bezier_outline[] = + "float3x2 transform_geometry;\n" + "float stroke_width;\n" + "float4 transform_rtx;\n" + "float4 transform_rty;\n" + "\n" + "struct output\n" + "{\n" + " float2 p : WORLD_POSITION;\n" + " float4 b : BEZIER;\n" + " nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n" + " float4 position : SV_POSITION;\n" + "};\n" + "\n" + "void main(float2 position : POSITION, float2 p0 : P0, float2 p1 : P1, float2 p2 : P2,\n" + " float2 prev : PREV, float2 next : NEXT, out struct output o)\n" + "{\n" + " float2 q_prev, q_next, v_p, q_i, p;\n" + " float2x2 geom, rt;\n" + " float l;\n" + "\n" + " geom = float2x2(transform_geometry._11_21, transform_geometry._12_22);\n" + " rt = float2x2(transform_rtx.xy, transform_rty.xy);\n" + " o.stroke_transform = rt * stroke_width * 0.5f;\n" + "\n" + " p = mul(geom, position);\n" + " p0 = mul(geom, p0);\n" + " p1 = mul(geom, p1);\n" + " p2 = mul(geom, p2);\n" + "\n" + " p -= p0;\n" + " p1 -= p0;\n" + " p2 -= p0;\n" + "\n" + " q_prev = normalize(mul(geom, prev));\n" + " q_next = normalize(mul(geom, next));\n" + "\n" + " v_p = float2(-q_prev.y, q_prev.x);\n" + " l = -dot(v_p, q_next) / (1.0f + dot(q_prev, q_next));\n" + " q_i = l * q_prev + v_p;\n" + " p += 0.5f * stroke_width * q_i;\n" + "\n" + " v_p = mul(rt, p2);\n" + " v_p = normalize(float2(-v_p.y, v_p.x));\n" + " if (abs(dot(mul(rt, p1), v_p)) < 1.0f)\n" + " {\n" + " o.b.xzw = float3(0.0f, 0.0f, 0.0f);\n" + " o.b.y = dot(mul(rt, p), v_p);\n" + " }\n" + " else\n" + " {\n" + " o.b.zw = sign(dot(mul(rt, p1), v_p)) * v_p;\n" + " v_p = -float2(-p.y, p.x) / dot(float2(-p1.y, p1.x), p2);\n" + " o.b.x = dot(v_p, p1 - 0.5f * p2);\n" + " o.b.y = dot(v_p, p1);\n" + " }\n" + "\n" + " o.p = mul(float3(position, 1.0f), transform_geometry) + 0.5f * stroke_width * q_i;\n" + " position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n" + " * float2(transform_rtx.w, transform_rty.w);\n" + " o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n" + "}\n"; +/* ⎡p0.x p0.y 1⎤ + * A = ⎢p1.x p1.y 1⎥ + * ⎣p2.x p2.y 1⎦ + * + * ⎡1 0⎤ + * B = ⎢1 1⎥ + * ⎣0 1⎦ + * + * A' = ⎡p1.x-p0.x p1.y-p0.y⎤ + * ⎣p2.x-p0.x p2.y-p0.y⎦ + * + * B' = ⎡ 0 1⎤ + * ⎣-1 1⎦ + * + * A'T = B' + * T = A'⁻¹B' = (B'⁻¹A')⁻¹ + */ +static const char shape_vs_code_arc_outline[] = + "float3x2 transform_geometry;\n" + "float stroke_width;\n" + "float4 transform_rtx;\n" + "float4 transform_rty;\n" + "\n" + "struct output\n" + "{\n" + " float2 p : WORLD_POSITION;\n" + " float4 b : BEZIER;\n" + " nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n" + " float4 position : SV_POSITION;\n" + "};\n" + "\n" + "void main(float2 position : POSITION, float2 p0 : P0, float2 p1 : P1, float2 p2 : P2,\n" + " float2 prev : PREV, float2 next : NEXT, out struct output o)\n" + "{\n" + " float2 q_prev, q_next, v_p, q_i, p;\n" + " float2x2 geom, rt, p_inv;\n" + " float l;\n" + " float a;\n" + " float2 bc;\n" + "\n" + " geom = float2x2(transform_geometry._11_21, transform_geometry._12_22);\n" + " rt = float2x2(transform_rtx.xy, transform_rty.xy);\n" + " o.stroke_transform = rt * stroke_width * 0.5f;\n" + "\n" + " p = mul(geom, position);\n" + " p0 = mul(geom, p0);\n" + " p1 = mul(geom, p1);\n" + " p2 = mul(geom, p2);\n" + "\n" + " p -= p0;\n" + " p1 -= p0;\n" + " p2 -= p0;\n" + "\n" + " q_prev = normalize(mul(geom, prev));\n" + " q_next = normalize(mul(geom, next));\n" + "\n" + " v_p = float2(-q_prev.y, q_prev.x);\n" + " l = -dot(v_p, q_next) / (1.0f + dot(q_prev, q_next));\n" + " q_i = l * q_prev + v_p;\n" + " p += 0.5f * stroke_width * q_i;\n" + "\n" + " p_inv = float2x2(p1.y, -p1.x, p2.y - p1.y, p1.x - p2.x) / (p1.x * p2.y - p2.x * p1.y);\n" + " o.b.xy = mul(p_inv, p) + float2(1.0f, 0.0f);\n" + " o.b.zw = 0.0f;\n" + "\n" + " o.p = mul(float3(position, 1.0f), transform_geometry) + 0.5f * stroke_width * q_i;\n" + " position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n" + " * float2(transform_rtx.w, transform_rty.w);\n" + " o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n" + "}\n"; +static const char shape_vs_code_triangle[] = + "float3x2 transform_geometry;\n" + "float4 transform_rtx;\n" + "float4 transform_rty;\n" + "\n" + "struct output\n" + "{\n" + " float2 p : WORLD_POSITION;\n" + " float4 b : BEZIER;\n" + " nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n" + " float4 position : SV_POSITION;\n" + "};\n" + "\n" + "void main(float2 position : POSITION, out struct output o)\n" + "{\n" + " o.p = mul(float3(position, 1.0f), transform_geometry);\n" + " o.b = float4(1.0, 0.0, 1.0, 1.0);\n" + " o.stroke_transform = float2x2(1.0, 0.0, 0.0, 1.0);\n" + " position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n" + " * float2(transform_rtx.w, transform_rty.w);\n" + " o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n" + "}\n"; +static const char shape_vs_code_curve[] = + "float3x2 transform_geometry;\n" + "float4 transform_rtx;\n" + "float4 transform_rty;\n" + "\n" + "struct output\n" + "{\n" + " float2 p : WORLD_POSITION;\n" + " float4 b : BEZIER;\n" + " nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n" + " float4 position : SV_POSITION;\n" + "};\n" + "\n" + "void main(float2 position : POSITION, float3 texcoord : TEXCOORD0, out struct output o)\n" + "{\n" + " o.p = mul(float3(position, 1.0f), transform_geometry);\n" + " o.b = float4(texcoord, 1.0);\n" + " o.stroke_transform = float2x2(1.0, 0.0, 0.0, 1.0);\n" + " position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n" + " * float2(transform_rtx.w, transform_rty.w);\n" + " o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n" + "}\n"; +static const char shape_ps_code[] = + "#define BRUSH_TYPE_SOLID 0\n" + "#define BRUSH_TYPE_LINEAR 1\n" + "#define BRUSH_TYPE_RADIAL 2\n" + "#define BRUSH_TYPE_BITMAP 3\n" + "#define BRUSH_TYPE_COUNT 4\n" + "\n" + "bool outline;\n" + "bool is_arc;\n" + "struct brush\n" + "{\n" + " uint type;\n" + " float opacity;\n" + " float4 data[3];\n" + "} colour_brush, opacity_brush;\n" + "\n" + "SamplerState s0, s1;\n" + "Texture2D t0, t1;\n" + "Buffer b0, b1;\n" + "\n" + "struct input\n" + "{\n" + " float2 p : WORLD_POSITION;\n" + " float4 b : BEZIER;\n" + " nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n" + "};\n" + "\n" + "float4 sample_gradient(Buffer gradient, uint stop_count, float position)\n" + "{\n" + " float4 c_low, c_high;\n" + " float p_low, p_high;\n" + " uint i;\n" + "\n" + " p_low = gradient.Load(0).x;\n" + " c_low = gradient.Load(1);\n" + " c_high = c_low;\n" + "\n" + " if (position < p_low)\n" + " return c_low;\n" + "\n" + " [loop]\n" + " for (i = 1; i < stop_count; ++i)\n" + " {\n" + " p_high = gradient.Load(i * 2).x;\n" + " c_high = gradient.Load(i * 2 + 1);\n" + "\n" + " if (position >= p_low && position <= p_high)\n" + " return lerp(c_low, c_high, (position - p_low) / (p_high - p_low));\n" + "\n" + " p_low = p_high;\n" + " c_low = c_high;\n" + " }\n" + "\n" + " return c_high;\n" + "}\n" + "\n" + "float4 brush_linear(struct brush brush, Buffer gradient, float2 position)\n" + "{\n" + " float2 start, end, v_p, v_q;\n" + " uint stop_count;\n" + " float p;\n" + "\n" + " start = brush.data[0].xy;\n" + " end = brush.data[0].zw;\n" + " stop_count = asuint(brush.data[1].x);\n" + "\n" + " v_p = position - start;\n" + " v_q = end - start;\n" + " p = dot(v_q, v_p) / dot(v_q, v_q);\n" + "\n" + " return sample_gradient(gradient, stop_count, p);\n" + "}\n" + "\n" + "float4 brush_radial(struct brush brush, Buffer gradient, float2 position)\n" + "{\n" + " float2 centre, offset, ra, rb, v_p, v_q, r;\n" + " float b, c, l, t;\n" + " uint stop_count;\n" + "\n" + " centre = brush.data[0].xy;\n" + " offset = brush.data[0].zw;\n" + " ra = brush.data[1].xy;\n" + " rb = brush.data[1].zw;\n" + " stop_count = asuint(brush.data[2].x);\n" + "\n" + " /* Project onto ra, rb. */\n" + " r = float2(dot(ra, ra), dot(rb, rb));\n" + " v_p = position - (centre + offset);\n" + " v_p = float2(dot(v_p, ra), dot(v_p, rb)) / r;\n" + " v_q = float2(dot(offset, ra), dot(offset, rb)) / r;\n" + "\n" + " /* ‖t·p̂ + q⃑‖ = 1\n" + " * (t·p̂ + q⃑) · (t·p̂ + q⃑) = 1\n" + " * t² + 2·(p̂·q⃑)·t + (q⃑·q⃑) = 1\n" + " *\n" + " * b = p̂·q⃑\n" + " * c = q⃑·q⃑ - 1\n" + " * t = -b + √(b² - c) */\n" + " l = length(v_p);\n" + " b = dot(v_p, v_q) / l;\n" + " c = dot(v_q, v_q) - 1.0;\n" + " t = -b + sqrt(b * b - c);\n" + "\n" + " return sample_gradient(gradient, stop_count, l / t);\n" + "}\n" + "\n" + "float4 brush_bitmap(struct brush brush, Texture2D t, SamplerState s, float2 position)\n" + "{\n" + " float3 transform[2];\n" + " bool ignore_alpha;\n" + " float2 texcoord;\n" + " float4 colour;\n" + "\n" + " transform[0] = brush.data[0].xyz;\n" + " transform[1] = brush.data[1].xyz;\n" + " ignore_alpha = asuint(brush.data[1].w);\n" + "\n" + " texcoord.x = dot(position.xy, transform[0].xy) + transform[0].z;\n" + " texcoord.y = dot(position.xy, transform[1].xy) + transform[1].z;\n" + " colour = t.Sample(s, texcoord);\n" + " if (ignore_alpha)\n" + " colour.a = 1.0;\n" + " return colour;\n" + "}\n" + "\n" + "float4 sample_brush(struct brush brush, Texture2D t, SamplerState s, Buffer b, float2 position)\n" + "{\n" + " if (brush.type == BRUSH_TYPE_SOLID)\n" + " return brush.data[0] * brush.opacity;\n" + " if (brush.type == BRUSH_TYPE_LINEAR)\n" + " return brush_linear(brush, b, position) * brush.opacity;\n" + " if (brush.type == BRUSH_TYPE_RADIAL)\n" + " return brush_radial(brush, b, position) * brush.opacity;\n" + " if (brush.type == BRUSH_TYPE_BITMAP)\n" + " return brush_bitmap(brush, t, s, position) * brush.opacity;\n" + " return float4(0.0, 0.0, 0.0, brush.opacity);\n" + "}\n" + "\n" + "float4 main(struct input i) : SV_Target\n" + "{\n" + " float4 colour;\n" + "\n" + " colour = sample_brush(colour_brush, t0, s0, b0, i.p);\n" + " if (opacity_brush.type < BRUSH_TYPE_COUNT)\n" + " colour *= sample_brush(opacity_brush, t1, s1, b1, i.p).a;\n" + "\n" + " if (outline)\n" + " {\n" + " float2 du, dv, df;\n" + " float4 uv;\n" + "\n" + " /* Evaluate the implicit form of the curve (u² - v = 0\n" + " * for Béziers, u² + v² - 1 = 0 for arcs) in texture\n" + " * space, using the screen-space partial derivatives\n" + " * to convert the calculated distance to object space.\n" + " *\n" + " * d(x, y) = |f(x, y)| / ‖∇f(x, y)‖\n" + " * = |f(x, y)| / √((∂f/∂x)² + (∂f/∂y)²)\n" + " *\n" + " * For Béziers:\n" + " * f(x, y) = u(x, y)² - v(x, y)\n" + " * ∂f/∂x = 2u · ∂u/∂x - ∂v/∂x\n" + " * ∂f/∂y = 2u · ∂u/∂y - ∂v/∂y\n" + " *\n" + " * For arcs:\n" + " * f(x, y) = u(x, y)² + v(x, y)² - 1\n" + " * ∂f/∂x = 2u · ∂u/∂x + 2v · ∂v/∂x\n" + " * ∂f/∂y = 2u · ∂u/∂y + 2v · ∂v/∂y */\n" + " uv = i.b;\n" + " du = float2(ddx(uv.x), ddy(uv.x));\n" + " dv = float2(ddx(uv.y), ddy(uv.y));\n" + "\n" + " if (!is_arc)\n" + " {\n" + " df = 2.0f * uv.x * du - dv;\n" + "\n" + " clip(dot(df, uv.zw));\n" + " clip(length(mul(i.stroke_transform, df)) - abs(uv.x * uv.x - uv.y));\n" + " }\n" + " else\n" + " {\n" + " df = 2.0f * uv.x * du + 2.0f * uv.y * dv;\n" + "\n" + " clip(dot(df, uv.zw));\n" + " clip(length(mul(i.stroke_transform, df)) - abs(uv.x * uv.x + uv.y * uv.y - 1.0f));\n" + " }\n" + " }\n" + " else\n" + " {\n" + " /* Evaluate the implicit form of the curve in texture space.\n" + " * \"i.b.z\" determines which side of the curve is shaded. */\n" + " if (!is_arc)\n" + " {\n" + " clip((i.b.x * i.b.x - i.b.y) * i.b.z);\n" + " }\n" + " else\n" + " {\n" + " clip((i.b.x * i.b.x + i.b.y * i.b.y - 1.0) * i.b.z);\n" + " }\n" + " }\n" + "\n" + " return colour;\n" + "}\n"; +static const struct shape_info +{ + enum d2d_shape_type shape_type; + const D3D11_INPUT_ELEMENT_DESC *il_desc; + unsigned int il_element_count; + const char *name; + const char *vs_code; + size_t vs_code_size; +} +shape_info[] = +{ + {D2D_SHAPE_TYPE_OUTLINE, shape_il_desc_outline, ARRAY_SIZE(shape_il_desc_outline), + "outline", shape_vs_code_outline, sizeof(shape_vs_code_outline) - 1}, + {D2D_SHAPE_TYPE_BEZIER_OUTLINE, shape_il_desc_curve_outline, ARRAY_SIZE(shape_il_desc_curve_outline), + "bezier_outline", shape_vs_code_bezier_outline, sizeof(shape_vs_code_bezier_outline) - 1}, + {D2D_SHAPE_TYPE_ARC_OUTLINE, shape_il_desc_curve_outline, ARRAY_SIZE(shape_il_desc_curve_outline), + "arc_outline", shape_vs_code_arc_outline, sizeof(shape_vs_code_arc_outline) - 1}, + {D2D_SHAPE_TYPE_TRIANGLE, shape_il_desc_triangle, ARRAY_SIZE(shape_il_desc_triangle), + "triangle", shape_vs_code_triangle, sizeof(shape_vs_code_triangle) - 1}, + {D2D_SHAPE_TYPE_CURVE, shape_il_desc_curve, ARRAY_SIZE(shape_il_desc_curve), + "curve", shape_vs_code_curve, sizeof(shape_vs_code_curve) - 1}, +}; + +static HRESULT d2d_device_context_init(struct d2d_device_context *render_target, + struct d2d_device *device, IUnknown *outer_unknown, const struct d2d_device_context_ops *ops) +{ + D3D11_SUBRESOURCE_DATA buffer_data; + IDWriteFactory *dwrite_factory; + D3D11_RASTERIZER_DESC rs_desc; + D3D11_BUFFER_DESC buffer_desc; + struct d2d_factory *factory; + ID3D10Blob *precompiled; + unsigned int i; + HRESULT hr; + + static const struct + { + float x, y; + } + quad[] = + { + {-1.0f, 1.0f}, + {-1.0f, -1.0f}, + { 1.0f, 1.0f}, + { 1.0f, -1.0f}, + }; + static const UINT16 indices[] = {0, 1, 2, 2, 1, 3}; + static const D3D_FEATURE_LEVEL feature_levels = D3D_FEATURE_LEVEL_10_0; + + render_target->ID2D1DeviceContext6_iface.lpVtbl = &d2d_device_context_vtbl; + render_target->ID2D1GdiInteropRenderTarget_iface.lpVtbl = &d2d_gdi_interop_render_target_vtbl; + render_target->IDWriteTextRenderer_iface.lpVtbl = &d2d_text_renderer_vtbl; + render_target->IUnknown_iface.lpVtbl = &d2d_device_context_inner_unknown_vtbl; + render_target->refcount = 1; + ID2D1Device1_GetFactory((ID2D1Device1 *)&device->ID2D1Device6_iface, &render_target->factory); + render_target->device = device; + ID2D1Device6_AddRef(&render_target->device->ID2D1Device6_iface); + + factory = unsafe_impl_from_ID2D1Factory(render_target->factory); + if (factory->factory_type == D2D1_FACTORY_TYPE_MULTI_THREADED) + render_target->cs = &factory->cs; + + render_target->outer_unknown = outer_unknown ? outer_unknown : &render_target->IUnknown_iface; + render_target->ops = ops; + + if (FAILED(hr = IDXGIDevice_QueryInterface(device->dxgi_device, + &IID_ID3D11Device1, (void **)&render_target->d3d_device))) + { + WARN("Failed to query ID3D11Device1 interface, hr %#lx.\n", hr); + goto err; + } + + if (FAILED(hr = ID3D11Device1_CreateDeviceContextState(render_target->d3d_device, + 0, &feature_levels, 1, D3D11_SDK_VERSION, &IID_ID3D11Device1, NULL, + &render_target->d3d_state))) + { + WARN("Failed to create device context state, hr %#lx.\n", hr); + goto err; + } + + for (i = 0; i < ARRAY_SIZE(shape_info); ++i) + { + const struct shape_info *si = &shape_info[i]; + + assert(device->precompiled_shape_vs[i]); + precompiled = device->precompiled_shape_vs[i]; + if (FAILED(hr = ID3D11Device1_CreateInputLayout(render_target->d3d_device, si->il_desc, si->il_element_count, + ID3D10Blob_GetBufferPointer(precompiled), ID3D10Blob_GetBufferSize(precompiled), + &render_target->shape_resources[si->shape_type].il))) + { + WARN("Failed to create input layout for shape type %#x, hr %#lx.\n", si->shape_type, hr); + goto err; + } + + if (FAILED(hr = ID3D11Device1_CreateVertexShader(render_target->d3d_device, + ID3D10Blob_GetBufferPointer(precompiled), ID3D10Blob_GetBufferSize(precompiled), + NULL, &render_target->shape_resources[si->shape_type].vs))) + { + WARN("Failed to create vertex shader for shape type %#x, hr %#lx.\n", si->shape_type, hr); + goto err; + } + } + + buffer_desc.ByteWidth = sizeof(struct d2d_vs_cb); + buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + buffer_desc.MiscFlags = 0; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, NULL, + &render_target->vs_cb))) + { + WARN("Failed to create constant buffer, hr %#lx.\n", hr); + goto err; + } + + assert(device->precompiled_shape_ps); + precompiled = device->precompiled_shape_ps; + if (FAILED(hr = ID3D11Device1_CreatePixelShader(render_target->d3d_device, + ID3D10Blob_GetBufferPointer(precompiled), ID3D10Blob_GetBufferSize(precompiled), + NULL, &render_target->ps))) + { + WARN("Failed to create pixel shader, hr %#lx.\n", hr); + goto err; + } + + buffer_desc.ByteWidth = sizeof(struct d2d_ps_cb); + buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + buffer_desc.MiscFlags = 0; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, NULL, + &render_target->ps_cb))) + { + WARN("Failed to create constant buffer, hr %#lx.\n", hr); + goto err; + } + + buffer_desc.ByteWidth = sizeof(indices); + buffer_desc.Usage = D3D11_USAGE_DEFAULT; + buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + buffer_desc.CPUAccessFlags = 0; + buffer_desc.MiscFlags = 0; + + buffer_data.pSysMem = indices; + buffer_data.SysMemPitch = 0; + buffer_data.SysMemSlicePitch = 0; + + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, + &buffer_desc, &buffer_data, &render_target->ib))) + { + WARN("Failed to create clear index buffer, hr %#lx.\n", hr); + goto err; + } + + buffer_desc.ByteWidth = sizeof(quad); + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_data.pSysMem = quad; + + render_target->vb_stride = sizeof(*quad); + if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, + &buffer_desc, &buffer_data, &render_target->vb))) + { + WARN("Failed to create clear vertex buffer, hr %#lx.\n", hr); + goto err; + } + + rs_desc.FillMode = D3D11_FILL_SOLID; + rs_desc.CullMode = D3D11_CULL_NONE; + rs_desc.FrontCounterClockwise = FALSE; + rs_desc.DepthBias = 0; + rs_desc.DepthBiasClamp = 0.0f; + rs_desc.SlopeScaledDepthBias = 0.0f; + rs_desc.DepthClipEnable = TRUE; + rs_desc.ScissorEnable = TRUE; + rs_desc.MultisampleEnable = FALSE; + rs_desc.AntialiasedLineEnable = FALSE; + if (FAILED(hr = ID3D11Device1_CreateRasterizerState(render_target->d3d_device, &rs_desc, &render_target->rs))) + { + WARN("Failed to create clear rasteriser state, hr %#lx.\n", hr); + goto err; + } + + if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, + &IID_IDWriteFactory, (IUnknown **)&dwrite_factory))) + { + ERR("Failed to create dwrite factory, hr %#lx.\n", hr); + goto err; + } + + hr = IDWriteFactory_CreateRenderingParams(dwrite_factory, &render_target->default_text_rendering_params); + IDWriteFactory_Release(dwrite_factory); + if (FAILED(hr)) + { + ERR("Failed to create default text rendering parameters, hr %#lx.\n", hr); + goto err; + } + + render_target->drawing_state.transform = identity; + + if (!d2d_clip_stack_init(&render_target->clip_stack)) + { + WARN("Failed to initialize clip stack.\n"); + hr = E_FAIL; + goto err; + } + + render_target->desc.dpiX = 96.0f; + render_target->desc.dpiY = 96.0f; + + return S_OK; + +err: + if (render_target->default_text_rendering_params) + IDWriteRenderingParams_Release(render_target->default_text_rendering_params); + if (render_target->rs) + ID3D11RasterizerState_Release(render_target->rs); + if (render_target->vb) + ID3D11Buffer_Release(render_target->vb); + if (render_target->ib) + ID3D11Buffer_Release(render_target->ib); + if (render_target->ps_cb) + ID3D11Buffer_Release(render_target->ps_cb); + if (render_target->ps) + ID3D11PixelShader_Release(render_target->ps); + if (render_target->vs_cb) + ID3D11Buffer_Release(render_target->vs_cb); + for (i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i) + { + if (render_target->shape_resources[i].vs) + ID3D11VertexShader_Release(render_target->shape_resources[i].vs); + if (render_target->shape_resources[i].il) + ID3D11InputLayout_Release(render_target->shape_resources[i].il); + } + if (render_target->d3d_state) + ID3DDeviceContextState_Release(render_target->d3d_state); + if (render_target->d3d_device) + ID3D11Device1_Release(render_target->d3d_device); + ID2D1Device6_Release(&render_target->device->ID2D1Device6_iface); + ID2D1Factory_Release(render_target->factory); + return hr; +} + +HRESULT d2d_d3d_create_render_target(struct d2d_device *device, IDXGISurface *surface, IUnknown *outer_unknown, + const struct d2d_device_context_ops *ops, const D2D1_RENDER_TARGET_PROPERTIES *desc, void **render_target) +{ + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + struct d2d_device_context *object; + ID2D1Bitmap1 *bitmap; + HRESULT hr; + + if (desc->type != D2D1_RENDER_TARGET_TYPE_DEFAULT && desc->type != D2D1_RENDER_TARGET_TYPE_HARDWARE) + WARN("Ignoring render target type %#x.\n", desc->type); + if (desc->usage != D2D1_RENDER_TARGET_USAGE_NONE) + FIXME("Ignoring render target usage %#x.\n", desc->usage); + if (desc->minLevel != D2D1_FEATURE_LEVEL_DEFAULT) + WARN("Ignoring feature level %#x.\n", desc->minLevel); + + bitmap_desc.dpiX = desc->dpiX; + bitmap_desc.dpiY = desc->dpiY; + + if (bitmap_desc.dpiX == 0.0f && bitmap_desc.dpiY == 0.0f) + { + bitmap_desc.dpiX = 96.0f; + bitmap_desc.dpiY = 96.0f; + } + else if (bitmap_desc.dpiX <= 0.0f || bitmap_desc.dpiY <= 0.0f) + return E_INVALIDARG; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_device_context_init(object, device, outer_unknown, ops))) + { + WARN("Failed to initialise render target, hr %#lx.\n", hr); + free(object); + return hr; + } + + ID2D1DeviceContext6_SetDpi(&object->ID2D1DeviceContext6_iface, bitmap_desc.dpiX, bitmap_desc.dpiY); + + if (surface) + { + bitmap_desc.pixelFormat = desc->pixelFormat; + bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW; + if (desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE) + bitmap_desc.bitmapOptions |= D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE; + bitmap_desc.colorContext = NULL; + + if (FAILED(hr = ID2D1DeviceContext6_CreateBitmapFromDxgiSurface(&object->ID2D1DeviceContext6_iface, + surface, &bitmap_desc, &bitmap))) + { + WARN("Failed to create target bitmap, hr %#lx.\n", hr); + IUnknown_Release(&object->IUnknown_iface); + return hr; + } + + ID2D1DeviceContext6_SetTarget(&object->ID2D1DeviceContext6_iface, (ID2D1Image *)bitmap); + ID2D1Bitmap1_Release(bitmap); + } + else + object->desc.pixelFormat = desc->pixelFormat; + + TRACE("Created render target %p.\n", object); + *render_target = outer_unknown ? &object->IUnknown_iface : (IUnknown *)&object->ID2D1DeviceContext6_iface; + + return S_OK; +} + +static HRESULT WINAPI d2d_device_QueryInterface(ID2D1Device6 *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1Device6) + || IsEqualGUID(iid, &IID_ID2D1Device5) + || IsEqualGUID(iid, &IID_ID2D1Device4) + || IsEqualGUID(iid, &IID_ID2D1Device3) + || IsEqualGUID(iid, &IID_ID2D1Device2) + || IsEqualGUID(iid, &IID_ID2D1Device1) + || IsEqualGUID(iid, &IID_ID2D1Device) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Device6_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d2d_device_AddRef(ID2D1Device6 *iface) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + ULONG refcount = InterlockedIncrement(&device->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +void d2d_device_indexed_objects_clear(struct d2d_indexed_objects *objects) +{ + size_t i; + + for (i = 0; i < objects->count; ++i) + IUnknown_Release(objects->elements[i].object); + free(objects->elements); + objects->elements = NULL; +} + +static ULONG WINAPI d2d_device_Release(ID2D1Device6 *iface) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + ULONG refcount = InterlockedDecrement(&device->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + IDXGIDevice_Release(device->dxgi_device); + ID2D1Factory1_Release(device->factory); + d2d_device_indexed_objects_clear(&device->shaders); + for (unsigned int i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i) + { + if (device->precompiled_shape_vs[i]) + ID3D10Blob_Release(device->precompiled_shape_vs[i]); + } + if (device->precompiled_shape_ps) + ID3D10Blob_Release(device->precompiled_shape_ps); + free(device); + } + + return refcount; +} + +static void WINAPI d2d_device_GetFactory(ID2D1Device6 *iface, ID2D1Factory **factory) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + *factory = (ID2D1Factory *)device->factory; + ID2D1Factory1_AddRef(device->factory); +} + +static HRESULT d2d_device_create_device_context(struct d2d_device *device, + D2D1_DEVICE_CONTEXT_OPTIONS options, REFIID iid, void **context) +{ + struct d2d_device_context *object; + HRESULT hr; + + if (options) + FIXME("Options are ignored %#x.\n", options); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_device_context_init(object, device, NULL, NULL))) + { + WARN("Failed to initialise device context, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created device context %p.\n", object); + + hr = ID2D1DeviceContext6_QueryInterface(&object->ID2D1DeviceContext6_iface, iid, context); + ID2D1DeviceContext6_Release(&object->ID2D1DeviceContext6_iface); + + return hr; +} + +static HRESULT WINAPI d2d_device_CreateDeviceContext(ID2D1Device6 *iface, D2D1_DEVICE_CONTEXT_OPTIONS options, + ID2D1DeviceContext **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext, (void **)context); +} + +static HRESULT WINAPI d2d_device_CreatePrintControl(ID2D1Device6 *iface, IWICImagingFactory *wic_factory, + IPrintDocumentPackageTarget *document_target, const D2D1_PRINT_CONTROL_PROPERTIES *desc, + ID2D1PrintControl **print_control) +{ + FIXME("iface %p, wic_factory %p, document_target %p, desc %p, print_control %p stub!\n", iface, wic_factory, + document_target, desc, print_control); + + return E_NOTIMPL; +} + +static void WINAPI d2d_device_SetMaximumTextureMemory(ID2D1Device6 *iface, UINT64 max_texture_memory) +{ + FIXME("iface %p, max_texture_memory %s stub!\n", iface, wine_dbgstr_longlong(max_texture_memory)); +} + +static UINT64 WINAPI d2d_device_GetMaximumTextureMemory(ID2D1Device6 *iface) +{ + FIXME("iface %p stub!\n", iface); + + return 0; +} + +static HRESULT WINAPI d2d_device_ClearResources(ID2D1Device6 *iface, UINT msec_since_use) +{ + FIXME("iface %p, msec_since_use %u stub!\n", iface, msec_since_use); + + return E_NOTIMPL; +} + +static D2D1_RENDERING_PRIORITY WINAPI d2d_device_GetRenderingPriority(ID2D1Device6 *iface) +{ + FIXME("iface %p stub!\n", iface); + + return D2D1_RENDERING_PRIORITY_NORMAL; +} + +static void WINAPI d2d_device_SetRenderingPriority(ID2D1Device6 *iface, D2D1_RENDERING_PRIORITY priority) +{ + FIXME("iface %p, priority %#x stub!\n", iface, priority); +} + +static HRESULT WINAPI d2d_device_CreateDeviceContext1(ID2D1Device6 *iface, D2D1_DEVICE_CONTEXT_OPTIONS options, + ID2D1DeviceContext1 **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext1, (void **)context); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_ID2D1Device2_CreateDeviceContext(ID2D1Device6 *iface, + D2D1_DEVICE_CONTEXT_OPTIONS options, ID2D1DeviceContext2 **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext2, (void **)context); +} + +static void STDMETHODCALLTYPE d2d_device_FlushDeviceContexts(ID2D1Device6 *iface, + ID2D1Bitmap *bitmap) +{ + FIXME("iface %p, bitmap %p stub!\n", iface, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_GetDxgiDevice(ID2D1Device6 *iface, + IDXGIDevice **dxgi_device) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, dxgi_device %p.\n", iface, dxgi_device); + + if (!device->allow_get_dxgi_device) + { + *dxgi_device = NULL; + return D2DERR_INVALID_CALL; + } + + IDXGIDevice_AddRef(device->dxgi_device); + *dxgi_device = device->dxgi_device; + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_ID2D1Device3_CreateDeviceContext(ID2D1Device6 *iface, + D2D1_DEVICE_CONTEXT_OPTIONS options, ID2D1DeviceContext3 **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext3, (void **)context); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_ID2D1Device4_CreateDeviceContext(ID2D1Device6 *iface, + D2D1_DEVICE_CONTEXT_OPTIONS options, ID2D1DeviceContext4 **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext4, (void **)context); +} + +static void STDMETHODCALLTYPE d2d_device_SetMaximumColorGlyphCacheMemory(ID2D1Device6 *iface, + UINT64 size) +{ + FIXME("iface %p, size %s stub!\n", iface, wine_dbgstr_longlong(size)); +} + +static UINT64 STDMETHODCALLTYPE d2d_device_GetMaximumColorGlyphCacheMemory(ID2D1Device6 *iface) +{ + FIXME("iface %p stub!\n", iface); + + return 0; +} + +static HRESULT STDMETHODCALLTYPE d2d_device_ID2D1Device5_CreateDeviceContext(ID2D1Device6 *iface, + D2D1_DEVICE_CONTEXT_OPTIONS options, ID2D1DeviceContext5 **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext5, (void **)context); +} + +static HRESULT STDMETHODCALLTYPE d2d_device_ID2D1Device6_CreateDeviceContext(ID2D1Device6 *iface, + D2D1_DEVICE_CONTEXT_OPTIONS options, ID2D1DeviceContext6 **context) +{ + struct d2d_device *device = impl_from_ID2D1Device(iface); + + TRACE("iface %p, options %#x, context %p.\n", iface, options, context); + + return d2d_device_create_device_context(device, options, &IID_ID2D1DeviceContext6, (void **)context); +} + +static const struct ID2D1Device6Vtbl d2d_device_vtbl = +{ + d2d_device_QueryInterface, + d2d_device_AddRef, + d2d_device_Release, + d2d_device_GetFactory, + d2d_device_CreateDeviceContext, + d2d_device_CreatePrintControl, + d2d_device_SetMaximumTextureMemory, + d2d_device_GetMaximumTextureMemory, + d2d_device_ClearResources, + d2d_device_GetRenderingPriority, + d2d_device_SetRenderingPriority, + d2d_device_CreateDeviceContext1, + d2d_device_ID2D1Device2_CreateDeviceContext, + d2d_device_FlushDeviceContexts, + d2d_device_GetDxgiDevice, + d2d_device_ID2D1Device3_CreateDeviceContext, + d2d_device_ID2D1Device4_CreateDeviceContext, + d2d_device_SetMaximumColorGlyphCacheMemory, + d2d_device_GetMaximumColorGlyphCacheMemory, + d2d_device_ID2D1Device5_CreateDeviceContext, + d2d_device_ID2D1Device6_CreateDeviceContext, +}; + +struct d2d_device *unsafe_impl_from_ID2D1Device(ID2D1Device1 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (ID2D1Device1Vtbl *)&d2d_device_vtbl); + return CONTAINING_RECORD(iface, struct d2d_device, ID2D1Device6_iface); +} + +HRESULT d2d_device_init(struct d2d_device *device, ID2D1Factory1 *factory, IDXGIDevice *dxgi_device, + bool allow_get_dxgi_device) +{ + HRESULT hr; + ID3D10Blob *compiled; + + device->ID2D1Device6_iface.lpVtbl = &d2d_device_vtbl; + device->refcount = 1; + device->factory = factory; + ID2D1Factory1_AddRef(device->factory); + device->dxgi_device = dxgi_device; + IDXGIDevice_AddRef(device->dxgi_device); + device->allow_get_dxgi_device = allow_get_dxgi_device; + + for (unsigned int i = 0; i < ARRAY_SIZE(shape_info); ++i) + { + const struct shape_info *si = &shape_info[i]; + + if (FAILED(hr = D3DCompile(si->vs_code, si->vs_code_size, si->name, NULL, NULL, + "main", "vs_4_0", 0, 0, &compiled, NULL))) + { + WARN("Failed to compile shader for shape type %#x, hr %#lx.\n", si->shape_type, hr); + return hr; + } + device->precompiled_shape_vs[i] = compiled; + } + + if (FAILED(hr = D3DCompile(shape_ps_code, sizeof(shape_ps_code) - 1, "ps", NULL, NULL, + "main", "ps_4_0", 0, 0, &compiled, NULL))) + { + WARN("Failed to compile the pixel shader, hr %#lx.\n", hr); + return hr; + } + device->precompiled_shape_ps = compiled; + + return S_OK; +} + +HRESULT d2d_device_add_indexed_object(struct d2d_indexed_objects *objects, + const GUID *id, IUnknown *object) +{ + if (!d2d_array_reserve((void **)&objects->elements, &objects->size, objects->count + 1, + sizeof(*objects->elements))) + { + WARN("Failed to resize elements array.\n"); + return E_OUTOFMEMORY; + } + + objects->elements[objects->count].id = *id; + objects->elements[objects->count].object = object; + IUnknown_AddRef(object); + objects->count++; + + return S_OK; +} + +BOOL d2d_device_get_indexed_object(struct d2d_indexed_objects *objects, const GUID *id, + IUnknown **object) +{ + size_t i; + + for (i = 0; i < objects->count; ++i) + { + if (IsEqualGUID(id, &objects->elements[i].id)) + { + if (object) + { + *object = objects->elements[i].object; + IUnknown_AddRef(*object); + } + return TRUE; + } + } + + if (object) *object = NULL; + return FALSE; +} diff --git a/WineFix/lib/d2d1/src/effect.c b/WineFix/lib/d2d1/src/effect.c new file mode 100644 index 0000000..8e7ee8f --- /dev/null +++ b/WineFix/lib/d2d1/src/effect.c @@ -0,0 +1,2761 @@ +/* + * Copyright 2018 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_transform *impl_from_ID2D1OffsetTransform(ID2D1OffsetTransform *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_transform, ID2D1TransformNode_iface); +} + +static inline struct d2d_transform *impl_from_ID2D1BlendTransform(ID2D1BlendTransform *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_transform, ID2D1TransformNode_iface); +} + +static inline struct d2d_transform *impl_from_ID2D1BorderTransform(ID2D1BorderTransform *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_transform, ID2D1TransformNode_iface); +} + +static inline struct d2d_transform *impl_from_ID2D1BoundsAdjustmentTransform( + ID2D1BoundsAdjustmentTransform *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_transform, ID2D1TransformNode_iface); +} + +static inline struct d2d_vertex_buffer *impl_from_ID2D1VertexBuffer(ID2D1VertexBuffer *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_vertex_buffer, ID2D1VertexBuffer_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_vertex_buffer_QueryInterface(ID2D1VertexBuffer *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1VertexBuffer) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *out = iface; + ID2D1VertexBuffer_AddRef(iface); + return S_OK; + } + + WARN("Unsupported interface %s.\n", debugstr_guid(iid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_vertex_buffer_AddRef(ID2D1VertexBuffer *iface) +{ + struct d2d_vertex_buffer *buffer = impl_from_ID2D1VertexBuffer(iface); + ULONG refcount = InterlockedIncrement(&buffer->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_vertex_buffer_Release(ID2D1VertexBuffer *iface) +{ + struct d2d_vertex_buffer *buffer = impl_from_ID2D1VertexBuffer(iface); + ULONG refcount = InterlockedDecrement(&buffer->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + free(buffer); + + return refcount; +} + +static HRESULT STDMETHODCALLTYPE d2d_vertex_buffer_Map(ID2D1VertexBuffer *iface, BYTE **data, UINT32 size) +{ + FIXME("iface %p, data %p, size %u.\n", iface, data, size); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_vertex_buffer_Unmap(ID2D1VertexBuffer *iface) +{ + FIXME("iface %p.\n", iface); + + return E_NOTIMPL; +} + +static const ID2D1VertexBufferVtbl d2d_vertex_buffer_vtbl = +{ + d2d_vertex_buffer_QueryInterface, + d2d_vertex_buffer_AddRef, + d2d_vertex_buffer_Release, + d2d_vertex_buffer_Map, + d2d_vertex_buffer_Unmap, +}; + +static HRESULT d2d_vertex_buffer_create(ID2D1VertexBuffer **buffer) +{ + struct d2d_vertex_buffer *object; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1VertexBuffer_iface.lpVtbl = &d2d_vertex_buffer_vtbl; + object->refcount = 1; + + *buffer = &object->ID2D1VertexBuffer_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_offset_transform_QueryInterface(ID2D1OffsetTransform *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1OffsetTransform) + || IsEqualGUID(iid, &IID_ID2D1TransformNode) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *out = iface; + ID2D1OffsetTransform_AddRef(iface); + return S_OK; + } + + WARN("Unsupported interface %s.\n", debugstr_guid(iid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_offset_transform_AddRef(ID2D1OffsetTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1OffsetTransform(iface); + ULONG refcount = InterlockedIncrement(&transform->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_offset_transform_Release(ID2D1OffsetTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1OffsetTransform(iface); + ULONG refcount = InterlockedDecrement(&transform->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + free(transform); + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_offset_transform_GetInputCount(ID2D1OffsetTransform *iface) +{ + TRACE("iface %p.\n", iface); + + return 1; +} + +static void STDMETHODCALLTYPE d2d_offset_transform_SetOffset(ID2D1OffsetTransform *iface, + D2D1_POINT_2L offset) +{ + struct d2d_transform *transform = impl_from_ID2D1OffsetTransform(iface); + + TRACE("iface %p, offset %s.\n", iface, debug_d2d_point_2l(&offset)); + + transform->offset = offset; +} + +static D2D1_POINT_2L * STDMETHODCALLTYPE d2d_offset_transform_GetOffset(ID2D1OffsetTransform *iface, + D2D1_POINT_2L *offset) +{ + struct d2d_transform *transform = impl_from_ID2D1OffsetTransform(iface); + + TRACE("iface %p.\n", iface); + + *offset = transform->offset; + return offset; +} + +static const ID2D1OffsetTransformVtbl d2d_offset_transform_vtbl = +{ + d2d_offset_transform_QueryInterface, + d2d_offset_transform_AddRef, + d2d_offset_transform_Release, + d2d_offset_transform_GetInputCount, + d2d_offset_transform_SetOffset, + d2d_offset_transform_GetOffset, +}; + +static HRESULT d2d_offset_transform_create(D2D1_POINT_2L offset, ID2D1OffsetTransform **transform) +{ + struct d2d_transform *object; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1TransformNode_iface.lpVtbl = (ID2D1TransformNodeVtbl *)&d2d_offset_transform_vtbl; + object->refcount = 1; + object->offset = offset; + + *transform = (ID2D1OffsetTransform *)&object->ID2D1TransformNode_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_blend_transform_QueryInterface(ID2D1BlendTransform *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1BlendTransform) + || IsEqualGUID(iid, &IID_ID2D1ConcreteTransform) + || IsEqualGUID(iid, &IID_ID2D1TransformNode) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *out = iface; + ID2D1BlendTransform_AddRef(iface); + return S_OK; + } + + WARN("Unsupported interface %s.\n", debugstr_guid(iid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_blend_transform_AddRef(ID2D1BlendTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BlendTransform(iface); + ULONG refcount = InterlockedIncrement(&transform->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_blend_transform_Release(ID2D1BlendTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BlendTransform(iface); + ULONG refcount = InterlockedDecrement(&transform->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + free(transform); + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_blend_transform_GetInputCount(ID2D1BlendTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BlendTransform(iface); + + TRACE("iface %p.\n", iface); + + return transform->input_count; +} + +static HRESULT STDMETHODCALLTYPE d2d_blend_transform_SetOutputBuffer(ID2D1BlendTransform *iface, + D2D1_BUFFER_PRECISION precision, D2D1_CHANNEL_DEPTH depth) +{ + FIXME("iface %p, precision %u, depth %u stub.\n", iface, precision, depth); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_blend_transform_SetCached(ID2D1BlendTransform *iface, + BOOL is_cached) +{ + FIXME("iface %p, is_cached %d stub.\n", iface, is_cached); +} + +static void STDMETHODCALLTYPE d2d_blend_transform_SetDescription(ID2D1BlendTransform *iface, + const D2D1_BLEND_DESCRIPTION *description) +{ + struct d2d_transform *transform = impl_from_ID2D1BlendTransform(iface); + + TRACE("iface %p, description %p.\n", iface, description); + + transform->blend_desc = *description; +} + +static void STDMETHODCALLTYPE d2d_blend_transform_GetDescription(ID2D1BlendTransform *iface, + D2D1_BLEND_DESCRIPTION *description) +{ + struct d2d_transform *transform = impl_from_ID2D1BlendTransform(iface); + + TRACE("iface %p, description %p.\n", iface, description); + + *description = transform->blend_desc; +} + +static const ID2D1BlendTransformVtbl d2d_blend_transform_vtbl = +{ + d2d_blend_transform_QueryInterface, + d2d_blend_transform_AddRef, + d2d_blend_transform_Release, + d2d_blend_transform_GetInputCount, + d2d_blend_transform_SetOutputBuffer, + d2d_blend_transform_SetCached, + d2d_blend_transform_SetDescription, + d2d_blend_transform_GetDescription, +}; + +static HRESULT d2d_blend_transform_create(UINT32 input_count, const D2D1_BLEND_DESCRIPTION *blend_desc, + ID2D1BlendTransform **transform) +{ + struct d2d_transform *object; + + *transform = NULL; + + if (!input_count) + return E_INVALIDARG; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1TransformNode_iface.lpVtbl = (ID2D1TransformNodeVtbl *)&d2d_blend_transform_vtbl; + object->refcount = 1; + object->input_count = input_count; + object->blend_desc = *blend_desc; + + *transform = (ID2D1BlendTransform *)&object->ID2D1TransformNode_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_border_transform_QueryInterface(ID2D1BorderTransform *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1BorderTransform) + || IsEqualGUID(iid, &IID_ID2D1ConcreteTransform) + || IsEqualGUID(iid, &IID_ID2D1TransformNode) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *out = iface; + ID2D1BorderTransform_AddRef(iface); + return S_OK; + } + + WARN("Unsupported interface %s.\n", debugstr_guid(iid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_border_transform_AddRef(ID2D1BorderTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BorderTransform(iface); + ULONG refcount = InterlockedIncrement(&transform->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_border_transform_Release(ID2D1BorderTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BorderTransform(iface); + ULONG refcount = InterlockedDecrement(&transform->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + free(transform); + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_border_transform_GetInputCount(ID2D1BorderTransform *iface) +{ + TRACE("iface %p.\n", iface); + + return 1; +} + +static HRESULT STDMETHODCALLTYPE d2d_border_transform_SetOutputBuffer( + ID2D1BorderTransform *iface, D2D1_BUFFER_PRECISION precision, D2D1_CHANNEL_DEPTH depth) +{ + FIXME("iface %p, precision %u, depth %u stub.\n", iface, precision, depth); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_border_transform_SetCached( + ID2D1BorderTransform *iface, BOOL is_cached) +{ + FIXME("iface %p, is_cached %d stub.\n", iface, is_cached); +} + +static void STDMETHODCALLTYPE d2d_border_transform_SetExtendModeX( + ID2D1BorderTransform *iface, D2D1_EXTEND_MODE mode) +{ + struct d2d_transform *transform = impl_from_ID2D1BorderTransform(iface); + + TRACE("iface %p.\n", iface); + + switch (mode) + { + case D2D1_EXTEND_MODE_CLAMP: + case D2D1_EXTEND_MODE_WRAP: + case D2D1_EXTEND_MODE_MIRROR: + transform->border.mode_x = mode; + break; + default: + ; + } +} + +static void STDMETHODCALLTYPE d2d_border_transform_SetExtendModeY( + ID2D1BorderTransform *iface, D2D1_EXTEND_MODE mode) +{ + struct d2d_transform *transform = impl_from_ID2D1BorderTransform(iface); + + TRACE("iface %p.\n", iface); + + switch (mode) + { + case D2D1_EXTEND_MODE_CLAMP: + case D2D1_EXTEND_MODE_WRAP: + case D2D1_EXTEND_MODE_MIRROR: + transform->border.mode_y = mode; + break; + default: + ; + } +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_border_transform_GetExtendModeX( + ID2D1BorderTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BorderTransform(iface); + + TRACE("iface %p.\n", iface); + + return transform->border.mode_x; +} + +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_border_transform_GetExtendModeY( + ID2D1BorderTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BorderTransform(iface); + + TRACE("iface %p.\n", iface); + + return transform->border.mode_y; +} + +static const ID2D1BorderTransformVtbl d2d_border_transform_vtbl = +{ + d2d_border_transform_QueryInterface, + d2d_border_transform_AddRef, + d2d_border_transform_Release, + d2d_border_transform_GetInputCount, + d2d_border_transform_SetOutputBuffer, + d2d_border_transform_SetCached, + d2d_border_transform_SetExtendModeX, + d2d_border_transform_SetExtendModeY, + d2d_border_transform_GetExtendModeX, + d2d_border_transform_GetExtendModeY, +}; + +static HRESULT d2d_border_transform_create(D2D1_EXTEND_MODE mode_x, D2D1_EXTEND_MODE mode_y, + ID2D1BorderTransform **transform) +{ + struct d2d_transform *object; + + *transform = NULL; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1TransformNode_iface.lpVtbl = (ID2D1TransformNodeVtbl *)&d2d_border_transform_vtbl; + object->refcount = 1; + object->border.mode_x = mode_x; + object->border.mode_y = mode_y; + + *transform = (ID2D1BorderTransform *)&object->ID2D1TransformNode_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_bounds_adjustment_transform_QueryInterface( + ID2D1BoundsAdjustmentTransform *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1BoundsAdjustmentTransform) + || IsEqualGUID(iid, &IID_ID2D1TransformNode) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *out = iface; + ID2D1BoundsAdjustmentTransform_AddRef(iface); + return S_OK; + } + + WARN("Unsupported interface %s.\n", debugstr_guid(iid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_bounds_adjustment_transform_AddRef( + ID2D1BoundsAdjustmentTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BoundsAdjustmentTransform(iface); + ULONG refcount = InterlockedIncrement(&transform->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_bounds_adjustment_transform_Release( + ID2D1BoundsAdjustmentTransform *iface) +{ + struct d2d_transform *transform = impl_from_ID2D1BoundsAdjustmentTransform(iface); + ULONG refcount = InterlockedDecrement(&transform->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + free(transform); + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_bounds_adjustment_transform_GetInputCount( + ID2D1BoundsAdjustmentTransform *iface) +{ + TRACE("iface %p.\n", iface); + + return 1; +} + +static void STDMETHODCALLTYPE d2d_bounds_adjustment_transform_SetOutputBounds( + ID2D1BoundsAdjustmentTransform *iface, const D2D1_RECT_L *bounds) +{ + struct d2d_transform *transform = impl_from_ID2D1BoundsAdjustmentTransform(iface); + + TRACE("iface %p.\n", iface); + + transform->bounds = *bounds; +} + +static void STDMETHODCALLTYPE d2d_bounds_adjustment_transform_GetOutputBounds( + ID2D1BoundsAdjustmentTransform *iface, D2D1_RECT_L *bounds) +{ + struct d2d_transform *transform = impl_from_ID2D1BoundsAdjustmentTransform(iface); + + TRACE("iface %p.\n", iface); + + *bounds = transform->bounds; +} + +static const ID2D1BoundsAdjustmentTransformVtbl d2d_bounds_adjustment_transform_vtbl = +{ + d2d_bounds_adjustment_transform_QueryInterface, + d2d_bounds_adjustment_transform_AddRef, + d2d_bounds_adjustment_transform_Release, + d2d_bounds_adjustment_transform_GetInputCount, + d2d_bounds_adjustment_transform_SetOutputBounds, + d2d_bounds_adjustment_transform_GetOutputBounds, +}; + +static HRESULT d2d_bounds_adjustment_transform_create(const D2D1_RECT_L *rect, + ID2D1BoundsAdjustmentTransform **transform) +{ + struct d2d_transform *object; + + *transform = NULL; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1TransformNode_iface.lpVtbl = (ID2D1TransformNodeVtbl *)&d2d_bounds_adjustment_transform_vtbl; + object->refcount = 1; + object->bounds = *rect; + + *transform = (ID2D1BoundsAdjustmentTransform *)&object->ID2D1TransformNode_iface; + + return S_OK; +} + +static struct d2d_transform_node * d2d_transform_graph_get_node(const struct d2d_transform_graph *graph, + ID2D1TransformNode *object) +{ + struct d2d_transform_node *node; + + LIST_FOR_EACH_ENTRY(node, &graph->nodes, struct d2d_transform_node, entry) + { + if (node->object == object) + return node; + } + + return NULL; +} + +static HRESULT d2d_transform_graph_add_node(struct d2d_transform_graph *graph, + ID2D1TransformNode *object) +{ + struct d2d_transform_node *node; + + if (!(node = calloc(1, sizeof(*node)))) + return E_OUTOFMEMORY; + node->input_count = ID2D1TransformNode_GetInputCount(object); + if (!(node->inputs = calloc(node->input_count, sizeof(*node->inputs)))) + { + free(node); + return E_OUTOFMEMORY; + } + + node->object = object; + ID2D1TransformNode_AddRef(node->object); + list_add_tail(&graph->nodes, &node->entry); + + return S_OK; +} + +static void d2d_transform_node_disconnect(struct d2d_transform_node *node) +{ + struct d2d_transform_node *output = node->output; + unsigned int i; + + if (!output) + return; + + for (i = 0; i < output->input_count; ++i) + { + if (output->inputs[i] == node) + { + output->inputs[i] = NULL; + break; + } + } +} + +static void d2d_transform_graph_delete_node(struct d2d_transform_graph *graph, + struct d2d_transform_node *node) +{ + unsigned int i; + + list_remove(&node->entry); + ID2D1TransformNode_Release(node->object); + + for (i = 0; i < graph->input_count; ++i) + { + if (graph->inputs[i].node == node) + memset(&graph->inputs[i].node, 0, sizeof(graph->inputs[i].node)); + } + + if (graph->output == node) + graph->output = NULL; + + if (node->render_info) + ID2D1DrawInfo_Release(&node->render_info->ID2D1DrawInfo_iface); + + d2d_transform_node_disconnect(node); + + free(node->inputs); + free(node); +} + +static void d2d_transform_graph_clear(struct d2d_transform_graph *graph) +{ + struct d2d_transform_node *node, *node_next; + + LIST_FOR_EACH_ENTRY_SAFE(node, node_next, &graph->nodes, struct d2d_transform_node, entry) + { + d2d_transform_graph_delete_node(graph, node); + } + graph->passthrough = false; +} + +static inline struct d2d_transform_graph *impl_from_ID2D1TransformGraph(ID2D1TransformGraph *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_transform_graph, ID2D1TransformGraph_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_QueryInterface(ID2D1TransformGraph *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1TransformGraph) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1TransformGraph_AddRef(iface); + *out = iface; + return S_OK; + } + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_transform_graph_AddRef(ID2D1TransformGraph *iface) +{ + struct d2d_transform_graph *graph =impl_from_ID2D1TransformGraph(iface); + ULONG refcount = InterlockedIncrement(&graph->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_transform_graph_Release(ID2D1TransformGraph *iface) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + ULONG refcount = InterlockedDecrement(&graph->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + d2d_transform_graph_clear(graph); + free(graph->inputs); + free(graph); + } + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_transform_graph_GetInputCount(ID2D1TransformGraph *iface) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + + TRACE("iface %p.\n", iface); + + return graph->input_count; +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetSingleTransformNode(ID2D1TransformGraph *iface, + ID2D1TransformNode *object) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + struct d2d_transform_node *node; + unsigned int i, input_count; + HRESULT hr; + + TRACE("iface %p, object %p.\n", iface, object); + + d2d_transform_graph_clear(graph); + if (FAILED(hr = d2d_transform_graph_add_node(graph, object))) + return hr; + + node = d2d_transform_graph_get_node(graph, object); + graph->output = node; + + input_count = ID2D1TransformNode_GetInputCount(object); + if (graph->input_count != input_count) + return E_INVALIDARG; + + for (i = 0; i < graph->input_count; ++i) + { + graph->inputs[i].node = node; + graph->inputs[i].index = i; + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_AddNode(ID2D1TransformGraph *iface, + ID2D1TransformNode *object) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + + TRACE("iface %p, object %p.\n", iface, object); + + if (d2d_transform_graph_get_node(graph, object)) + return E_INVALIDARG; + + return d2d_transform_graph_add_node(graph, object); +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_RemoveNode(ID2D1TransformGraph *iface, + ID2D1TransformNode *object) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + struct d2d_transform_node *node; + + TRACE("iface %p, object %p.\n", iface, object); + + if (!(node = d2d_transform_graph_get_node(graph, object))) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + d2d_transform_graph_delete_node(graph, node); + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetOutputNode(ID2D1TransformGraph *iface, + ID2D1TransformNode *object) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + struct d2d_transform_node *node; + + TRACE("iface %p, object %p.\n", iface, object); + + if (!(node = d2d_transform_graph_get_node(graph, object))) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + graph->output = node; + graph->passthrough = false; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_ConnectNode(ID2D1TransformGraph *iface, + ID2D1TransformNode *from_node, ID2D1TransformNode *to_node, UINT32 index) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + struct d2d_transform_node *from, *to; + + TRACE("iface %p, from_node %p, to_node %p, index %u.\n", iface, from_node, to_node, index); + + if (!(from = d2d_transform_graph_get_node(graph, from_node))) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + if (!(to = d2d_transform_graph_get_node(graph, to_node))) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + if (index >= to->input_count) + return E_INVALIDARG; + + d2d_transform_node_disconnect(from); + to->inputs[index] = from; + from->output = to; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_ConnectToEffectInput(ID2D1TransformGraph *iface, + UINT32 input_index, ID2D1TransformNode *object, UINT32 node_index) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + struct d2d_transform_node *node; + unsigned int count; + + TRACE("iface %p, input_index %u, object %p, node_index %u.\n", iface, input_index, object, node_index); + + if (!(node = d2d_transform_graph_get_node(graph, object))) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + if (input_index >= graph->input_count) + return E_INVALIDARG; + + count = ID2D1TransformNode_GetInputCount(object); + if (node_index >= count) + return E_INVALIDARG; + + graph->inputs[input_index].node = node; + graph->inputs[input_index].index = node_index; + graph->passthrough = false; + + return S_OK; +} + +static void STDMETHODCALLTYPE d2d_transform_graph_Clear(ID2D1TransformGraph *iface) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + + TRACE("iface %p.\n", iface); + + d2d_transform_graph_clear(graph); +} + +static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetPassthroughGraph(ID2D1TransformGraph *iface, UINT32 index) +{ + struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface); + + TRACE("iface %p, index %u.\n", iface, index); + + if (index >= graph->input_count) + return E_INVALIDARG; + + d2d_transform_graph_clear(graph); + + graph->passthrough = true; + graph->passthrough_input = index; + + return S_OK; +} + +static const ID2D1TransformGraphVtbl d2d_transform_graph_vtbl = +{ + d2d_transform_graph_QueryInterface, + d2d_transform_graph_AddRef, + d2d_transform_graph_Release, + d2d_transform_graph_GetInputCount, + d2d_transform_graph_SetSingleTransformNode, + d2d_transform_graph_AddNode, + d2d_transform_graph_RemoveNode, + d2d_transform_graph_SetOutputNode, + d2d_transform_graph_ConnectNode, + d2d_transform_graph_ConnectToEffectInput, + d2d_transform_graph_Clear, + d2d_transform_graph_SetPassthroughGraph, +}; + +static HRESULT d2d_transform_graph_create(UINT32 input_count, struct d2d_transform_graph **graph) +{ + struct d2d_transform_graph *object; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1TransformGraph_iface.lpVtbl = &d2d_transform_graph_vtbl; + object->refcount = 1; + list_init(&object->nodes); + + if (!(object->inputs = calloc(input_count, sizeof(*object->inputs)))) + { + free(object); + return E_OUTOFMEMORY; + } + object->input_count = input_count; + + *graph = object; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_impl_QueryInterface(ID2D1EffectImpl *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1EffectImpl) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1EffectImpl_AddRef(iface); + *out = iface; + return S_OK; + } + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_impl_AddRef(ID2D1EffectImpl *iface) +{ + return 2; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_impl_Release(ID2D1EffectImpl *iface) +{ + return 1; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_impl_Initialize(ID2D1EffectImpl *iface, + ID2D1EffectContext *context, ID2D1TransformGraph *graph) +{ + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_impl_PrepareForRender(ID2D1EffectImpl *iface, D2D1_CHANGE_TYPE type) +{ + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_impl_SetGraph(ID2D1EffectImpl *iface, ID2D1TransformGraph *graph) +{ + return S_OK; +} + +static const ID2D1EffectImplVtbl d2d_effect_impl_vtbl = +{ + d2d_effect_impl_QueryInterface, + d2d_effect_impl_AddRef, + d2d_effect_impl_Release, + d2d_effect_impl_Initialize, + d2d_effect_impl_PrepareForRender, + d2d_effect_impl_SetGraph, +}; + +static HRESULT STDMETHODCALLTYPE builtin_factory_stub(IUnknown **effect_impl) +{ + static ID2D1EffectImpl builtin_stub = { &d2d_effect_impl_vtbl }; + + *effect_impl = (IUnknown *)&builtin_stub; + + return S_OK; +} + +static const WCHAR _2d_affine_transform_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR _3d_perspective_transform_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR composite_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR crop_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR shadow_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR grayscale_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR color_matrix_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + \ + "; + +static const WCHAR flood_description[] = +L" \ + \ + \ + \ + \ + \ + \ + \ + "; + +void d2d_effects_init_builtins(struct d2d_factory *factory) +{ + static const struct builtin_description + { + const CLSID *clsid; + const WCHAR *description; + } + builtin_effects[] = + { + { &CLSID_D2D12DAffineTransform, _2d_affine_transform_description }, + { &CLSID_D2D13DPerspectiveTransform, _3d_perspective_transform_description}, + { &CLSID_D2D1Composite, composite_description }, + { &CLSID_D2D1Crop, crop_description }, + { &CLSID_D2D1Shadow, shadow_description }, + { &CLSID_D2D1Grayscale, grayscale_description }, + { &CLSID_D2D1ColorMatrix, color_matrix_description }, + { &CLSID_D2D1Flood, flood_description }, + }; + unsigned int i; + HRESULT hr; + + for (i = 0; i < ARRAY_SIZE(builtin_effects); ++i) + { + if (FAILED(hr = d2d_factory_register_builtin_effect(factory, builtin_effects[i].clsid, builtin_effects[i].description, + NULL, 0, builtin_factory_stub))) + { + WARN("Failed to register the effect %s, hr %#lx.\n", wine_dbgstr_guid(builtin_effects[i].clsid), hr); + } + } +} + +/* Same syntax is used for value and default values. */ +static HRESULT d2d_effect_parse_float_array(D2D1_PROPERTY_TYPE type, const WCHAR *value, + float *vec) +{ + unsigned int i, num_components; + WCHAR *end_ptr; + + /* Type values are sequential. */ + switch (type) + { + case D2D1_PROPERTY_TYPE_VECTOR2: + case D2D1_PROPERTY_TYPE_VECTOR3: + case D2D1_PROPERTY_TYPE_VECTOR4: + num_components = (type - D2D1_PROPERTY_TYPE_VECTOR2) + 2; + break; + case D2D1_PROPERTY_TYPE_MATRIX_3X2: + num_components = 6; + break; + case D2D1_PROPERTY_TYPE_MATRIX_4X3: + case D2D1_PROPERTY_TYPE_MATRIX_4X4: + case D2D1_PROPERTY_TYPE_MATRIX_5X4: + num_components = (type - D2D1_PROPERTY_TYPE_MATRIX_4X3) * 4 + 12; + break; + default: + return E_UNEXPECTED; + } + + if (*(value++) != '(') return E_INVALIDARG; + + for (i = 0; i < num_components; ++i) + { + vec[i] = wcstof(value, &end_ptr); + if (value == end_ptr) return E_INVALIDARG; + value = end_ptr; + + /* Trailing characters after last component are ignored. */ + if (i == num_components - 1) continue; + if (*(value++) != ',') return E_INVALIDARG; + } + + return S_OK; +} + +static HRESULT d2d_effect_properties_internal_add(struct d2d_effect_properties *props, + const WCHAR *name, UINT32 index, BOOL subprop, D2D1_PROPERTY_TYPE type, const WCHAR *value) +{ + static const UINT32 sizes[] = + { + [D2D1_PROPERTY_TYPE_UNKNOWN] = 0, + [D2D1_PROPERTY_TYPE_STRING] = 0, + [D2D1_PROPERTY_TYPE_BOOL] = sizeof(BOOL), + [D2D1_PROPERTY_TYPE_UINT32] = sizeof(UINT32), + [D2D1_PROPERTY_TYPE_INT32] = sizeof(INT32), + [D2D1_PROPERTY_TYPE_FLOAT] = sizeof(float), + [D2D1_PROPERTY_TYPE_VECTOR2] = sizeof(D2D_VECTOR_2F), + [D2D1_PROPERTY_TYPE_VECTOR3] = sizeof(D2D_VECTOR_3F), + [D2D1_PROPERTY_TYPE_VECTOR4] = sizeof(D2D_VECTOR_4F), + [D2D1_PROPERTY_TYPE_BLOB] = 0, + [D2D1_PROPERTY_TYPE_IUNKNOWN] = sizeof(IUnknown *), + [D2D1_PROPERTY_TYPE_ENUM] = sizeof(UINT32), + [D2D1_PROPERTY_TYPE_ARRAY] = sizeof(UINT32), + [D2D1_PROPERTY_TYPE_CLSID] = sizeof(CLSID), + [D2D1_PROPERTY_TYPE_MATRIX_3X2] = sizeof(D2D_MATRIX_3X2_F), + [D2D1_PROPERTY_TYPE_MATRIX_4X3] = sizeof(D2D_MATRIX_4X3_F), + [D2D1_PROPERTY_TYPE_MATRIX_4X4] = sizeof(D2D_MATRIX_4X4_F), + [D2D1_PROPERTY_TYPE_MATRIX_5X4] = sizeof(D2D_MATRIX_5X4_F), + [D2D1_PROPERTY_TYPE_COLOR_CONTEXT] = sizeof(ID2D1ColorContext *), + }; + struct d2d_effect_property *p; + HRESULT hr; + + assert(type >= D2D1_PROPERTY_TYPE_STRING && type <= D2D1_PROPERTY_TYPE_COLOR_CONTEXT); + + if (!d2d_array_reserve((void **)&props->properties, &props->size, props->count + 1, + sizeof(*props->properties))) + { + return E_OUTOFMEMORY; + } + + /* TODO: we could save some space for properties that have both getter and setter. */ + if (!d2d_array_reserve((void **)&props->data.ptr, &props->data.size, + props->data.count + sizes[type], sizeof(*props->data.ptr))) + { + return E_OUTOFMEMORY; + } + props->data.count += sizes[type]; + + p = &props->properties[props->count++]; + memset(p, 0, sizeof(*p)); + p->index = index; + if (p->index < 0x80000000) + { + props->custom_count++; + /* FIXME: this should probably be controlled by subproperty */ + p->readonly = FALSE; + } + else if (subprop) + p->readonly = TRUE; + else + p->readonly = index != D2D1_PROPERTY_CACHED && index != D2D1_PROPERTY_PRECISION; + p->name = wcsdup(name); + p->type = type; + if (p->type == D2D1_PROPERTY_TYPE_STRING) + { + p->data.ptr = wcsdup(value); + p->size = value ? (wcslen(value) + 1) * sizeof(WCHAR) : sizeof(WCHAR); + } + else if (p->type == D2D1_PROPERTY_TYPE_BLOB) + { + p->data.ptr = NULL; + p->size = 0; + } + else + { + void *src = NULL; + UINT32 _uint32; + float _vec[20]; + CLSID _clsid; + BOOL _bool; + + p->data.offset = props->offset; + p->size = sizes[type]; + props->offset += p->size; + + if (value) + { + switch (p->type) + { + case D2D1_PROPERTY_TYPE_UINT32: + case D2D1_PROPERTY_TYPE_INT32: + _uint32 = wcstoul(value, NULL, 0); + src = &_uint32; + break; + case D2D1_PROPERTY_TYPE_ENUM: + _uint32 = wcstoul(value, NULL, 10); + src = &_uint32; + break; + case D2D1_PROPERTY_TYPE_BOOL: + if (!wcscmp(value, L"true")) _bool = TRUE; + else if (!wcscmp(value, L"false")) _bool = FALSE; + else return E_INVALIDARG; + src = &_bool; + break; + case D2D1_PROPERTY_TYPE_CLSID: + CLSIDFromString(value, &_clsid); + src = &_clsid; + break; + case D2D1_PROPERTY_TYPE_VECTOR2: + case D2D1_PROPERTY_TYPE_VECTOR3: + case D2D1_PROPERTY_TYPE_VECTOR4: + case D2D1_PROPERTY_TYPE_MATRIX_3X2: + case D2D1_PROPERTY_TYPE_MATRIX_4X3: + case D2D1_PROPERTY_TYPE_MATRIX_4X4: + case D2D1_PROPERTY_TYPE_MATRIX_5X4: + if (FAILED(hr = d2d_effect_parse_float_array(p->type, value, _vec))) + { + WARN("Failed to parse float array %s for type %u.\n", + wine_dbgstr_w(value), p->type); + return hr; + } + src = _vec; + break; + case D2D1_PROPERTY_TYPE_IUNKNOWN: + case D2D1_PROPERTY_TYPE_COLOR_CONTEXT: + break; + default: + FIXME("Initial value for property type %u is not handled.\n", p->type); + } + + if (src && p->size) memcpy(props->data.ptr + p->data.offset, src, p->size); + } + else if (p->size) + memset(props->data.ptr + p->data.offset, 0, p->size); + } + + return S_OK; +} + +HRESULT d2d_effect_properties_add(struct d2d_effect_properties *props, const WCHAR *name, + UINT32 index, D2D1_PROPERTY_TYPE type, const WCHAR *value) +{ + return d2d_effect_properties_internal_add(props, name, index, FALSE, type, value); +} + +HRESULT d2d_effect_subproperties_add(struct d2d_effect_properties *props, const WCHAR *name, + UINT32 index, D2D1_PROPERTY_TYPE type, const WCHAR *value) +{ + return d2d_effect_properties_internal_add(props, name, index, TRUE, type, value); +} + +static HRESULT d2d_effect_duplicate_properties(struct d2d_effect *effect, + struct d2d_effect_properties *dst, const struct d2d_effect_properties *src) +{ + HRESULT hr; + size_t i; + + *dst = *src; + dst->effect = effect; + + if (!(dst->data.ptr = malloc(dst->data.size))) + return E_OUTOFMEMORY; + memcpy(dst->data.ptr, src->data.ptr, dst->data.size); + + if (!(dst->properties = calloc(dst->size, sizeof(*dst->properties)))) + return E_OUTOFMEMORY; + + for (i = 0; i < dst->count; ++i) + { + struct d2d_effect_property *d = &dst->properties[i]; + const struct d2d_effect_property *s = &src->properties[i]; + + *d = *s; + d->name = wcsdup(s->name); + if (d->type == D2D1_PROPERTY_TYPE_STRING) + d->data.ptr = wcsdup((WCHAR *)s->data.ptr); + + if (s->subproperties) + { + if (!(d->subproperties = calloc(1, sizeof(*d->subproperties)))) + return E_OUTOFMEMORY; + if (FAILED(hr = d2d_effect_duplicate_properties(effect, d->subproperties, s->subproperties))) + return hr; + } + } + + return S_OK; +} + +static struct d2d_effect_property * d2d_effect_properties_get_property_by_index( + const struct d2d_effect_properties *properties, UINT32 index) +{ + unsigned int i; + + for (i = 0; i < properties->count; ++i) + { + if (properties->properties[i].index == index) + return &properties->properties[i]; + } + + return NULL; +} + +struct d2d_effect_property * d2d_effect_properties_get_property_by_name( + const struct d2d_effect_properties *properties, const WCHAR *name) +{ + unsigned int i; + + for (i = 0; i < properties->count; ++i) + { + if (!wcscmp(properties->properties[i].name, name)) + return &properties->properties[i]; + } + + return NULL; +} + +static UINT32 d2d_effect_properties_get_value_size(const struct d2d_effect_properties *properties, + UINT32 index) +{ + struct d2d_effect *effect = properties->effect; + struct d2d_effect_property *prop; + UINT32 size; + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return 0; + + if (prop->get_function) + { + if (FAILED(prop->get_function((IUnknown *)effect->impl, NULL, 0, &size))) return 0; + return size; + } + + return prop->size; +} + +static HRESULT d2d_effect_return_string(const WCHAR *str, WCHAR *buffer, UINT32 buffer_size) +{ + UINT32 size = str ? wcslen(str) : 0; + if (size >= buffer_size) return D2DERR_INSUFFICIENT_BUFFER; + if (str) memcpy(buffer, str, (size + 1) * sizeof(*buffer)); + else *buffer = 0; + return S_OK; +} + +static HRESULT d2d_effect_property_get_value(const struct d2d_effect_properties *properties, + const struct d2d_effect_property *prop, D2D1_PROPERTY_TYPE type, BYTE *value, UINT32 size) +{ + struct d2d_effect *effect = properties->effect; + UINT32 actual_size; + + memset(value, 0, size); + + if (type != D2D1_PROPERTY_TYPE_UNKNOWN && prop->type != type) return E_INVALIDARG; + /* Do not check sizes for variable-length properties. */ + if (prop->type != D2D1_PROPERTY_TYPE_STRING + && prop->type != D2D1_PROPERTY_TYPE_BLOB + && prop->size != size) + { + return E_INVALIDARG; + } + + if (prop->get_function) + return prop->get_function((IUnknown *)effect->impl, value, size, &actual_size); + + switch (prop->type) + { + case D2D1_PROPERTY_TYPE_BLOB: + memset(value, 0, size); + break; + case D2D1_PROPERTY_TYPE_STRING: + return d2d_effect_return_string(prop->data.ptr, (WCHAR *)value, size / sizeof(WCHAR)); + default: + memcpy(value, properties->data.ptr + prop->data.offset, size); + break; + } + + return S_OK; +} + +HRESULT d2d_effect_property_get_uint32_value(const struct d2d_effect_properties *properties, + const struct d2d_effect_property *prop, UINT32 *value) +{ + return d2d_effect_property_get_value(properties, prop, D2D1_PROPERTY_TYPE_UINT32, + (BYTE *)value, sizeof(*value)); +} + +static HRESULT d2d_effect_property_set_value(struct d2d_effect_properties *properties, + struct d2d_effect_property *prop, D2D1_PROPERTY_TYPE type, const BYTE *value, UINT32 size) +{ + struct d2d_effect *effect = properties->effect; + if (prop->readonly || !effect) return E_INVALIDARG; + if (type != D2D1_PROPERTY_TYPE_UNKNOWN && prop->type != type) return E_INVALIDARG; + if (prop->get_function && !prop->set_function) return E_INVALIDARG; + if (prop->index < 0x80000000 && !prop->set_function) return E_INVALIDARG; + + if (prop->set_function) + return prop->set_function((IUnknown *)effect->impl, value, size); + + if (prop->size != size) return E_INVALIDARG; + + switch (prop->type) + { + case D2D1_PROPERTY_TYPE_BOOL: + case D2D1_PROPERTY_TYPE_UINT32: + case D2D1_PROPERTY_TYPE_ENUM: + memcpy(properties->data.ptr + prop->data.offset, value, size); + break; + default: + FIXME("Unhandled type %u.\n", prop->type); + } + + return S_OK; +} + +void d2d_effect_properties_cleanup(struct d2d_effect_properties *props) +{ + struct d2d_effect_property *p; + size_t i; + + for (i = 0; i < props->count; ++i) + { + p = &props->properties[i]; + free(p->name); + if (p->type == D2D1_PROPERTY_TYPE_STRING) + free(p->data.ptr); + if (p->subproperties) + { + d2d_effect_properties_cleanup(p->subproperties); + free(p->subproperties); + } + } + free(props->properties); + free(props->data.ptr); +} + +static inline struct d2d_effect_context *impl_from_ID2D1EffectContext(ID2D1EffectContext *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_effect_context, ID2D1EffectContext_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_QueryInterface(ID2D1EffectContext *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1EffectContext) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1EffectContext_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_context_AddRef(ID2D1EffectContext *iface) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + ULONG refcount = InterlockedIncrement(&effect_context->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_context_Release(ID2D1EffectContext *iface) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + ULONG refcount = InterlockedDecrement(&effect_context->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1DeviceContext6_Release(&effect_context->device_context->ID2D1DeviceContext6_iface); + free(effect_context); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_effect_context_GetDpi(ID2D1EffectContext *iface, float *dpi_x, float *dpi_y) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + ID2D1DeviceContext6_GetDpi(&effect_context->device_context->ID2D1DeviceContext6_iface, dpi_x, dpi_y); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateEffect(ID2D1EffectContext *iface, + REFCLSID clsid, ID2D1Effect **effect) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + + TRACE("iface %p, clsid %s, effect %p.\n", iface, debugstr_guid(clsid), effect); + + return ID2D1DeviceContext6_CreateEffect(&effect_context->device_context->ID2D1DeviceContext6_iface, + clsid, effect); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_GetMaximumSupportedFeatureLevel(ID2D1EffectContext *iface, + const D3D_FEATURE_LEVEL *levels, UINT32 level_count, D3D_FEATURE_LEVEL *max_level) +{ + FIXME("iface %p, levels %p, level_count %u, max_level %p stub!\n", iface, levels, level_count, max_level); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateTransformNodeFromEffect(ID2D1EffectContext *iface, + ID2D1Effect *effect, ID2D1TransformNode **node) +{ + FIXME("iface %p, effect %p, node %p stub!\n", iface, effect, node); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateBlendTransform(ID2D1EffectContext *iface, + UINT32 num_inputs, const D2D1_BLEND_DESCRIPTION *description, ID2D1BlendTransform **transform) +{ + TRACE("iface %p, num_inputs %u, description %p, transform %p,\n", iface, num_inputs, description, transform); + + return d2d_blend_transform_create(num_inputs, description, transform); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateBorderTransform(ID2D1EffectContext *iface, + D2D1_EXTEND_MODE mode_x, D2D1_EXTEND_MODE mode_y, ID2D1BorderTransform **transform) +{ + TRACE("iface %p, mode_x %#x, mode_y %#x, transform %p.\n", iface, mode_x, mode_y, transform); + + return d2d_border_transform_create(mode_x, mode_y, transform); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateOffsetTransform(ID2D1EffectContext *iface, + D2D1_POINT_2L offset, ID2D1OffsetTransform **transform) +{ + TRACE("iface %p, offset %s, transform %p.\n", iface, debug_d2d_point_2l(&offset), transform); + + return d2d_offset_transform_create(offset, transform); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateBoundsAdjustmentTransform(ID2D1EffectContext *iface, + const D2D1_RECT_L *output_rect, ID2D1BoundsAdjustmentTransform **transform) +{ + TRACE("iface %p, output_rect %s, transform %p.\n", iface, debug_d2d_rect_l(output_rect), transform); + + return d2d_bounds_adjustment_transform_create(output_rect, transform); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_LoadPixelShader(ID2D1EffectContext *iface, + REFGUID shader_id, const BYTE *buffer, UINT32 buffer_size) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + struct d2d_device *device = effect_context->device_context->device; + ID3D11PixelShader *shader; + HRESULT hr; + + TRACE("iface %p, shader_id %s, buffer %p, buffer_size %u.\n", + iface, debugstr_guid(shader_id), buffer, buffer_size); + + if (d2d_device_get_indexed_object(&device->shaders, shader_id, NULL)) + return S_OK; + + if (FAILED(hr = ID3D11Device1_CreatePixelShader(effect_context->device_context->d3d_device, + buffer, buffer_size, NULL, &shader))) + { + WARN("Failed to create a pixel shader, hr %#lx.\n", hr); + return hr; + } + + hr = d2d_device_add_indexed_object(&device->shaders, shader_id, (IUnknown *)shader); + ID3D11PixelShader_Release(shader); + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_LoadVertexShader(ID2D1EffectContext *iface, + REFGUID shader_id, const BYTE *buffer, UINT32 buffer_size) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + struct d2d_device *device = effect_context->device_context->device; + ID3D11VertexShader *shader; + HRESULT hr; + + TRACE("iface %p, shader_id %s, buffer %p, buffer_size %u.\n", + iface, debugstr_guid(shader_id), buffer, buffer_size); + + if (d2d_device_get_indexed_object(&device->shaders, shader_id, NULL)) + return S_OK; + + if (FAILED(hr = ID3D11Device1_CreateVertexShader(effect_context->device_context->d3d_device, + buffer, buffer_size, NULL, &shader))) + { + WARN("Failed to create vertex shader, hr %#lx.\n", hr); + return hr; + } + + hr = d2d_device_add_indexed_object(&device->shaders, shader_id, (IUnknown *)shader); + ID3D11VertexShader_Release(shader); + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_LoadComputeShader(ID2D1EffectContext *iface, + REFGUID shader_id, const BYTE *buffer, UINT32 buffer_size) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + struct d2d_device *device = effect_context->device_context->device; + ID3D11ComputeShader *shader; + HRESULT hr; + + TRACE("iface %p, shader_id %s, buffer %p, buffer_size %u.\n", + iface, debugstr_guid(shader_id), buffer, buffer_size); + + if (d2d_device_get_indexed_object(&device->shaders, shader_id, NULL)) + return S_OK; + + if (FAILED(hr = ID3D11Device1_CreateComputeShader(effect_context->device_context->d3d_device, + buffer, buffer_size, NULL, &shader))) + { + WARN("Failed to create a compute shader, hr %#lx.\n", hr); + return hr; + } + + hr = d2d_device_add_indexed_object(&device->shaders, shader_id, (IUnknown *)shader); + ID3D11ComputeShader_Release(shader); + + return hr; +} + +static BOOL STDMETHODCALLTYPE d2d_effect_context_IsShaderLoaded(ID2D1EffectContext *iface, REFGUID shader_id) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + struct d2d_device *device = effect_context->device_context->device; + + TRACE("iface %p, shader_id %s.\n", iface, debugstr_guid(shader_id)); + + return d2d_device_get_indexed_object(&device->shaders, shader_id, NULL); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateResourceTexture(ID2D1EffectContext *iface, + const GUID *id, const D2D1_RESOURCE_TEXTURE_PROPERTIES *texture_properties, + const BYTE *data, const UINT32 *strides, UINT32 data_size, ID2D1ResourceTexture **texture) +{ + FIXME("iface %p, id %s, texture_properties %p, data %p, strides %p, data_size %u, texture %p stub!\n", + iface, debugstr_guid(id), texture_properties, data, strides, data_size, texture); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_FindResourceTexture(ID2D1EffectContext *iface, + const GUID *id, ID2D1ResourceTexture **texture) +{ + FIXME("iface %p, id %s, texture %p stub!\n", iface, debugstr_guid(id), texture); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateVertexBuffer(ID2D1EffectContext *iface, + const D2D1_VERTEX_BUFFER_PROPERTIES *buffer_properties, const GUID *id, + const D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES *custom_buffer_properties, + ID2D1VertexBuffer **buffer) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + struct d2d_device_context *context = effect_context->device_context; + HRESULT hr; + + FIXME("iface %p, buffer_properties %p, id %s, custom_buffer_properties %p, buffer %p stub!\n", + iface, buffer_properties, debugstr_guid(id), custom_buffer_properties, buffer); + + if (id && d2d_device_get_indexed_object(&context->vertex_buffers, id, (IUnknown **)buffer)) + return S_OK; + + if (SUCCEEDED(hr = d2d_vertex_buffer_create(buffer))) + { + if (id) + hr = d2d_device_add_indexed_object(&context->vertex_buffers, id, (IUnknown *)*buffer); + } + + if (FAILED(hr)) + *buffer = NULL; + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_FindVertexBuffer(ID2D1EffectContext *iface, + const GUID *id, ID2D1VertexBuffer **buffer) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + struct d2d_device_context *context = effect_context->device_context; + + TRACE("iface %p, id %s, buffer %p.\n", iface, debugstr_guid(id), buffer); + + if (!d2d_device_get_indexed_object(&context->vertex_buffers, id, (IUnknown **)buffer)) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateColorContext(ID2D1EffectContext *iface, + D2D1_COLOR_SPACE space, const BYTE *profile, UINT32 profile_size, ID2D1ColorContext **color_context) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + + TRACE("iface %p, space %#x, profile %p, profile_size %u, color_context %p.\n", + iface, space, profile, profile_size, color_context); + + return ID2D1DeviceContext6_CreateColorContext(&effect_context->device_context->ID2D1DeviceContext6_iface, + space, profile, profile_size, color_context); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateColorContextFromFilename(ID2D1EffectContext *iface, + const WCHAR *filename, ID2D1ColorContext **color_context) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + + TRACE("iface %p, filename %s, color_context %p.\n", iface, debugstr_w(filename), color_context); + + return ID2D1DeviceContext6_CreateColorContextFromFilename(&effect_context->device_context->ID2D1DeviceContext6_iface, + filename, color_context); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CreateColorContextFromWicColorContext(ID2D1EffectContext *iface, + IWICColorContext *wic_color_context, ID2D1ColorContext **color_context) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + + TRACE("iface %p, wic_color_context %p, color_context %p.\n", iface, wic_color_context, color_context); + + return ID2D1DeviceContext6_CreateColorContextFromWicColorContext(&effect_context->device_context->ID2D1DeviceContext6_iface, + wic_color_context, color_context); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_context_CheckFeatureSupport(ID2D1EffectContext *iface, + D2D1_FEATURE feature, void *data, UINT32 data_size) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + D3D11_FEATURE d3d11_feature; + + TRACE("iface %p, feature %#x, data %p, data_size %u.\n", iface, feature, data, data_size); + + /* Data structures are compatible. */ + switch (feature) + { + case D2D1_FEATURE_DOUBLES: d3d11_feature = D3D11_FEATURE_DOUBLES; break; + case D2D1_FEATURE_D3D10_X_HARDWARE_OPTIONS: d3d11_feature = D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS; break; + default: + WARN("Unexpected feature index %d.\n", feature); + return E_INVALIDARG; + } + + return ID3D11Device1_CheckFeatureSupport(effect_context->device_context->d3d_device, + d3d11_feature, data, data_size); +} + +static BOOL STDMETHODCALLTYPE d2d_effect_context_IsBufferPrecisionSupported(ID2D1EffectContext *iface, + D2D1_BUFFER_PRECISION precision) +{ + struct d2d_effect_context *effect_context = impl_from_ID2D1EffectContext(iface); + + TRACE("iface %p, precision %u.\n", iface, precision); + + return ID2D1DeviceContext6_IsBufferPrecisionSupported(&effect_context->device_context->ID2D1DeviceContext6_iface, + precision); +} + +static const ID2D1EffectContextVtbl d2d_effect_context_vtbl = +{ + d2d_effect_context_QueryInterface, + d2d_effect_context_AddRef, + d2d_effect_context_Release, + d2d_effect_context_GetDpi, + d2d_effect_context_CreateEffect, + d2d_effect_context_GetMaximumSupportedFeatureLevel, + d2d_effect_context_CreateTransformNodeFromEffect, + d2d_effect_context_CreateBlendTransform, + d2d_effect_context_CreateBorderTransform, + d2d_effect_context_CreateOffsetTransform, + d2d_effect_context_CreateBoundsAdjustmentTransform, + d2d_effect_context_LoadPixelShader, + d2d_effect_context_LoadVertexShader, + d2d_effect_context_LoadComputeShader, + d2d_effect_context_IsShaderLoaded, + d2d_effect_context_CreateResourceTexture, + d2d_effect_context_FindResourceTexture, + d2d_effect_context_CreateVertexBuffer, + d2d_effect_context_FindVertexBuffer, + d2d_effect_context_CreateColorContext, + d2d_effect_context_CreateColorContextFromFilename, + d2d_effect_context_CreateColorContextFromWicColorContext, + d2d_effect_context_CheckFeatureSupport, + d2d_effect_context_IsBufferPrecisionSupported, +}; + +void d2d_effect_context_init(struct d2d_effect_context *effect_context, struct d2d_device_context *device_context) +{ + effect_context->ID2D1EffectContext_iface.lpVtbl = &d2d_effect_context_vtbl; + effect_context->refcount = 1; + effect_context->device_context = device_context; + ID2D1DeviceContext6_AddRef(&device_context->ID2D1DeviceContext6_iface); +} + +static inline struct d2d_effect *impl_from_ID2D1Effect(ID2D1Effect *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_effect, ID2D1Effect_iface); +} + +static void d2d_effect_cleanup(struct d2d_effect *effect) +{ + unsigned int i; + + for (i = 0; i < effect->input_count; ++i) + { + if (effect->inputs[i]) + ID2D1Image_Release(effect->inputs[i]); + } + free(effect->inputs); + ID2D1EffectContext_Release(&effect->effect_context->ID2D1EffectContext_iface); + if (effect->graph) + ID2D1TransformGraph_Release(&effect->graph->ID2D1TransformGraph_iface); + d2d_effect_properties_cleanup(&effect->properties); + if (effect->impl) + ID2D1EffectImpl_Release(effect->impl); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_QueryInterface(ID2D1Effect *iface, REFIID iid, void **out) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1Effect) + || IsEqualGUID(iid, &IID_ID2D1Properties) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Effect_AddRef(iface); + *out = iface; + return S_OK; + } + + if (IsEqualGUID(iid, &IID_ID2D1Image) + || IsEqualGUID(iid, &IID_ID2D1Resource)) + { + ID2D1Image_AddRef(&effect->ID2D1Image_iface); + *out = &effect->ID2D1Image_iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_AddRef(ID2D1Effect *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + ULONG refcount = InterlockedIncrement(&effect->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_Release(ID2D1Effect *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + ULONG refcount = InterlockedDecrement(&effect->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + d2d_effect_cleanup(effect); + free(effect); + } + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetPropertyCount(ID2D1Effect *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1Properties_GetPropertyCount(&effect->properties.ID2D1Properties_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetPropertyName(ID2D1Effect *iface, UINT32 index, + WCHAR *name, UINT32 name_count) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %u, name %p, name_count %u.\n", iface, index, name, name_count); + + return ID2D1Properties_GetPropertyName(&effect->properties.ID2D1Properties_iface, + index, name, name_count); +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetPropertyNameLength(ID2D1Effect *iface, UINT32 index) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %u.\n", iface, index); + + return ID2D1Properties_GetPropertyNameLength(&effect->properties.ID2D1Properties_iface, index); +} + +static D2D1_PROPERTY_TYPE STDMETHODCALLTYPE d2d_effect_GetType(ID2D1Effect *iface, UINT32 index) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %#x.\n", iface, index); + + return ID2D1Properties_GetType(&effect->properties.ID2D1Properties_iface, index); +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetPropertyIndex(ID2D1Effect *iface, const WCHAR *name) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, name %s.\n", iface, debugstr_w(name)); + + return ID2D1Properties_GetPropertyIndex(&effect->properties.ID2D1Properties_iface, name); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_SetValueByName(ID2D1Effect *iface, const WCHAR *name, + D2D1_PROPERTY_TYPE type, const BYTE *value, UINT32 value_size) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, name %s, type %u, value %p, value_size %u.\n", iface, debugstr_w(name), + type, value, value_size); + + return ID2D1Properties_SetValueByName(&effect->properties.ID2D1Properties_iface, name, + type, value, value_size); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_SetValue(ID2D1Effect *iface, UINT32 index, D2D1_PROPERTY_TYPE type, + const BYTE *value, UINT32 value_size) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %#x, type %u, value %p, value_size %u.\n", iface, index, type, value, value_size); + + return ID2D1Properties_SetValue(&effect->properties.ID2D1Properties_iface, index, type, + value, value_size); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetValueByName(ID2D1Effect *iface, const WCHAR *name, + D2D1_PROPERTY_TYPE type, BYTE *value, UINT32 value_size) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, name %s, type %#x, value %p, value_size %u.\n", iface, debugstr_w(name), type, + value, value_size); + + return ID2D1Properties_GetValueByName(&effect->properties.ID2D1Properties_iface, name, type, + value, value_size); +} + +static HRESULT d2d_effect_get_value(struct d2d_effect *effect, UINT32 index, D2D1_PROPERTY_TYPE type, + BYTE *value, UINT32 value_size) +{ + return ID2D1Properties_GetValue(&effect->properties.ID2D1Properties_iface, index, type, value, value_size); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetValue(ID2D1Effect *iface, UINT32 index, D2D1_PROPERTY_TYPE type, + BYTE *value, UINT32 value_size) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %#x, type %u, value %p, value_size %u.\n", iface, index, type, value, value_size); + + return d2d_effect_get_value(effect, index, type, value, value_size); +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetValueSize(ID2D1Effect *iface, UINT32 index) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %#x.\n", iface, index); + + return ID2D1Properties_GetValueSize(&effect->properties.ID2D1Properties_iface, index); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetSubProperties(ID2D1Effect *iface, UINT32 index, + ID2D1Properties **props) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %u, props %p.\n", iface, index, props); + + return ID2D1Properties_GetSubProperties(&effect->properties.ID2D1Properties_iface, index, props); +} + +static void STDMETHODCALLTYPE d2d_effect_SetInput(ID2D1Effect *iface, UINT32 index, ID2D1Image *input, BOOL invalidate) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %u, input %p, invalidate %#x.\n", iface, index, input, invalidate); + + if (index >= effect->input_count) + return; + + ID2D1Image_AddRef(input); + if (effect->inputs[index]) + ID2D1Image_Release(effect->inputs[index]); + effect->inputs[index] = input; +} + +static HRESULT d2d_effect_set_input_count(struct d2d_effect *effect, UINT32 count) +{ + bool initialized = effect->inputs != NULL; + HRESULT hr = S_OK; + unsigned int i; + + if (count == effect->input_count) + return S_OK; + + if (count < effect->input_count) + { + for (i = count; i < effect->input_count; ++i) + { + if (effect->inputs[i]) + ID2D1Image_Release(effect->inputs[i]); + } + } + else + { + if (!d2d_array_reserve((void **)&effect->inputs, &effect->inputs_size, + count, sizeof(*effect->inputs))) + { + ERR("Failed to resize inputs array.\n"); + return E_OUTOFMEMORY; + } + + memset(&effect->inputs[effect->input_count], 0, sizeof(*effect->inputs) * (count - effect->input_count)); + } + effect->input_count = count; + + if (initialized) + { + ID2D1TransformGraph_Release(&effect->graph->ID2D1TransformGraph_iface); + effect->graph = NULL; + + if (SUCCEEDED(hr = d2d_transform_graph_create(count, &effect->graph))) + { + if (FAILED(hr = ID2D1EffectImpl_SetGraph(effect->impl, &effect->graph->ID2D1TransformGraph_iface))) + WARN("Failed to set a new transform graph, hr %#lx.\n", hr); + } + } + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_SetInputCount(ID2D1Effect *iface, UINT32 count) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + unsigned int min_inputs, max_inputs; + + TRACE("iface %p, count %u.\n", iface, count); + + d2d_effect_get_value(effect, D2D1_PROPERTY_MIN_INPUTS, D2D1_PROPERTY_TYPE_UINT32, + (BYTE *)&min_inputs, sizeof(min_inputs)); + d2d_effect_get_value(effect, D2D1_PROPERTY_MAX_INPUTS, D2D1_PROPERTY_TYPE_UINT32, + (BYTE *)&max_inputs, sizeof(max_inputs)); + + if (count < min_inputs || count > max_inputs) + return E_INVALIDARG; + + return d2d_effect_set_input_count(effect, count); +} + +static void STDMETHODCALLTYPE d2d_effect_GetInput(ID2D1Effect *iface, UINT32 index, ID2D1Image **input) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, index %u, input %p.\n", iface, index, input); + + if (index < effect->input_count && effect->inputs[index]) + ID2D1Image_AddRef(*input = effect->inputs[index]); + else + *input = NULL; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetInputCount(ID2D1Effect *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p.\n", iface); + + return effect->input_count; +} + +static void STDMETHODCALLTYPE d2d_effect_GetOutput(ID2D1Effect *iface, ID2D1Image **output) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + + TRACE("iface %p, output %p.\n", iface, output); + + ID2D1Image_AddRef(*output = &effect->ID2D1Image_iface); +} + +static const ID2D1EffectVtbl d2d_effect_vtbl = +{ + d2d_effect_QueryInterface, + d2d_effect_AddRef, + d2d_effect_Release, + d2d_effect_GetPropertyCount, + d2d_effect_GetPropertyName, + d2d_effect_GetPropertyNameLength, + d2d_effect_GetType, + d2d_effect_GetPropertyIndex, + d2d_effect_SetValueByName, + d2d_effect_SetValue, + d2d_effect_GetValueByName, + d2d_effect_GetValue, + d2d_effect_GetValueSize, + d2d_effect_GetSubProperties, + d2d_effect_SetInput, + d2d_effect_SetInputCount, + d2d_effect_GetInput, + d2d_effect_GetInputCount, + d2d_effect_GetOutput, +}; + +static inline struct d2d_effect *impl_from_ID2D1Image(ID2D1Image *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_effect, ID2D1Image_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_image_QueryInterface(ID2D1Image *iface, REFIID iid, void **out) +{ + struct d2d_effect *effect = impl_from_ID2D1Image(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + return d2d_effect_QueryInterface(&effect->ID2D1Effect_iface, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_effect_image_AddRef(ID2D1Image *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Image(iface); + + TRACE("iface %p.\n", iface); + + return d2d_effect_AddRef(&effect->ID2D1Effect_iface); +} + +static ULONG STDMETHODCALLTYPE d2d_effect_image_Release(ID2D1Image *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Image(iface); + + TRACE("iface %p.\n", iface); + + return d2d_effect_Release(&effect->ID2D1Effect_iface); +} + +static void STDMETHODCALLTYPE d2d_effect_image_GetFactory(ID2D1Image *iface, ID2D1Factory **factory) +{ + struct d2d_effect *effect = impl_from_ID2D1Image(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = effect->effect_context->device_context->factory); +} + +static const ID2D1ImageVtbl d2d_effect_image_vtbl = +{ + d2d_effect_image_QueryInterface, + d2d_effect_image_AddRef, + d2d_effect_image_Release, + d2d_effect_image_GetFactory, +}; + +static inline struct d2d_effect_properties *impl_from_ID2D1Properties(ID2D1Properties *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_effect_properties, ID2D1Properties_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_QueryInterface(ID2D1Properties *iface, + REFIID riid, void **obj) +{ + if (IsEqualGUID(riid, &IID_ID2D1Properties) || + IsEqualGUID(riid, &IID_IUnknown)) + { + *obj = iface; + ID2D1Properties_AddRef(iface); + return S_OK; + } + + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_properties_AddRef(ID2D1Properties *iface) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + + if (properties->effect) + return ID2D1Effect_AddRef(&properties->effect->ID2D1Effect_iface); + + return InterlockedIncrement(&properties->refcount); +} + +static ULONG STDMETHODCALLTYPE d2d_effect_properties_Release(ID2D1Properties *iface) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + ULONG refcount; + + if (properties->effect) + return ID2D1Effect_Release(&properties->effect->ID2D1Effect_iface); + + refcount = InterlockedDecrement(&properties->refcount); + + if (!refcount) + { + d2d_effect_properties_cleanup(properties); + free(properties); + } + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_properties_GetPropertyCount(ID2D1Properties *iface) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + + TRACE("iface %p.\n", iface); + + return properties->custom_count; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_GetPropertyName(ID2D1Properties *iface, + UINT32 index, WCHAR *name, UINT32 name_count) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, index %u, name %p, name_count %u.\n", iface, index, name, name_count); + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return D2DERR_INVALID_PROPERTY; + + return d2d_effect_return_string(prop->name, name, name_count); +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_properties_GetPropertyNameLength(ID2D1Properties *iface, + UINT32 index) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, index %u.\n", iface, index); + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return D2DERR_INVALID_PROPERTY; + + return wcslen(prop->name); +} + +static D2D1_PROPERTY_TYPE STDMETHODCALLTYPE d2d_effect_properties_GetType(ID2D1Properties *iface, + UINT32 index) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, index %#x.\n", iface, index); + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return D2D1_PROPERTY_TYPE_UNKNOWN; + + return prop->type; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_properties_GetPropertyIndex(ID2D1Properties *iface, + const WCHAR *name) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, name %s.\n", iface, debugstr_w(name)); + + if (!(prop = d2d_effect_properties_get_property_by_name(properties, name))) + return D2D1_INVALID_PROPERTY_INDEX; + + return prop->index; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_SetValueByName(ID2D1Properties *iface, + const WCHAR *name, D2D1_PROPERTY_TYPE type, const BYTE *value, UINT32 value_size) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, name %s, type %u, value %p, value_size %u.\n", iface, debugstr_w(name), + type, value, value_size); + + if (!(prop = d2d_effect_properties_get_property_by_name(properties, name))) + return D2DERR_INVALID_PROPERTY; + + return d2d_effect_property_set_value(properties, prop, type, value, value_size); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_SetValue(ID2D1Properties *iface, + UINT32 index, D2D1_PROPERTY_TYPE type, const BYTE *value, UINT32 value_size) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, index %#x, type %u, value %p, value_size %u.\n", iface, index, type, value, value_size); + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return D2DERR_INVALID_PROPERTY; + + return d2d_effect_property_set_value(properties, prop, type, value, value_size); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_GetValueByName(ID2D1Properties *iface, + const WCHAR *name, D2D1_PROPERTY_TYPE type, BYTE *value, UINT32 value_size) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, name %s, type %#x, value %p, value_size %u.\n", iface, debugstr_w(name), type, + value, value_size); + + if (!(prop = d2d_effect_properties_get_property_by_name(properties, name))) + return D2DERR_INVALID_PROPERTY; + + return d2d_effect_property_get_value(properties, prop, type, value, value_size); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_GetValue(ID2D1Properties *iface, + UINT32 index, D2D1_PROPERTY_TYPE type, BYTE *value, UINT32 value_size) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, index %#x, type %u, value %p, value_size %u.\n", iface, index, type, value, value_size); + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return D2DERR_INVALID_PROPERTY; + + return d2d_effect_property_get_value(properties, prop, type, value, value_size); +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_properties_GetValueSize(ID2D1Properties *iface, + UINT32 index) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + + TRACE("iface %p, index %#x.\n", iface, index); + + return d2d_effect_properties_get_value_size(properties, index); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_properties_GetSubProperties(ID2D1Properties *iface, + UINT32 index, ID2D1Properties **props) +{ + struct d2d_effect_properties *properties = impl_from_ID2D1Properties(iface); + struct d2d_effect_property *prop; + + TRACE("iface %p, index %u, props %p.\n", iface, index, props); + + if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) + return D2DERR_INVALID_PROPERTY; + + if (!prop->subproperties) return D2DERR_NO_SUBPROPERTIES; + + *props = &prop->subproperties->ID2D1Properties_iface; + ID2D1Properties_AddRef(*props); + return S_OK; +} + +static const ID2D1PropertiesVtbl d2d_effect_properties_vtbl = +{ + d2d_effect_properties_QueryInterface, + d2d_effect_properties_AddRef, + d2d_effect_properties_Release, + d2d_effect_properties_GetPropertyCount, + d2d_effect_properties_GetPropertyName, + d2d_effect_properties_GetPropertyNameLength, + d2d_effect_properties_GetType, + d2d_effect_properties_GetPropertyIndex, + d2d_effect_properties_SetValueByName, + d2d_effect_properties_SetValue, + d2d_effect_properties_GetValueByName, + d2d_effect_properties_GetValue, + d2d_effect_properties_GetValueSize, + d2d_effect_properties_GetSubProperties, +}; + +void d2d_effect_init_properties(struct d2d_effect *effect, + struct d2d_effect_properties *properties) +{ + properties->ID2D1Properties_iface.lpVtbl = &d2d_effect_properties_vtbl; + properties->effect = effect; + properties->refcount = 1; +} + +static struct d2d_render_info *impl_from_ID2D1DrawInfo(ID2D1DrawInfo *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_render_info, ID2D1DrawInfo_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_QueryInterface(ID2D1DrawInfo *iface, REFIID iid, + void **obj) +{ + TRACE("iface %p, iid %s, obj %p.\n", iface, debugstr_guid(iid), obj); + + if (IsEqualGUID(iid, &IID_ID2D1DrawInfo) + || IsEqualGUID(iid, &IID_ID2D1RenderInfo) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *obj = iface; + ID2D1DrawInfo_AddRef(iface); + return S_OK; + } + + WARN("Unsupported interface %s.\n", debugstr_guid(iid)); + + *obj = NULL; + + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_draw_info_AddRef(ID2D1DrawInfo *iface) +{ + struct d2d_render_info *render_info = impl_from_ID2D1DrawInfo(iface); + ULONG refcount = InterlockedIncrement(&render_info->refcount); + + TRACE("iface %p refcount %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_draw_info_Release(ID2D1DrawInfo *iface) +{ + struct d2d_render_info *render_info = impl_from_ID2D1DrawInfo(iface); + ULONG refcount = InterlockedDecrement(&render_info->refcount); + + TRACE("iface %p refcount %lu.\n", iface, refcount); + + if (!refcount) + free(render_info); + + return refcount; +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetInputDescription(ID2D1DrawInfo *iface, + UINT32 index, D2D1_INPUT_DESCRIPTION description) +{ + FIXME("iface %p, index %u stub.\n", iface, index); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetOutputBuffer(ID2D1DrawInfo *iface, + D2D1_BUFFER_PRECISION precision, D2D1_CHANNEL_DEPTH depth) +{ + FIXME("iface %p, precision %u, depth %u stub.\n", iface, precision, depth); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_draw_info_SetCached(ID2D1DrawInfo *iface, BOOL is_cached) +{ + FIXME("iface %p, is_cached %d stub.\n", iface, is_cached); +} + +static void STDMETHODCALLTYPE d2d_draw_info_SetInstructionCountHint(ID2D1DrawInfo *iface, + UINT32 count) +{ + FIXME("iface %p, count %u stub.\n", iface, count); +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetPixelShaderConstantBuffer(ID2D1DrawInfo *iface, + const BYTE *buffer, UINT32 size) +{ + FIXME("iface %p, buffer %p, size %u stub.\n", iface, buffer, size); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetResourceTexture(ID2D1DrawInfo *iface, + UINT32 index, ID2D1ResourceTexture *texture) +{ + FIXME("iface %p, index %u, texture %p stub.\n", iface, index, texture); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetVertexShaderConstantBuffer(ID2D1DrawInfo *iface, + const BYTE *buffer, UINT32 size) +{ + FIXME("iface %p, buffer %p, size %u stub.\n", iface, buffer, size); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetPixelShader(ID2D1DrawInfo *iface, + REFGUID id, D2D1_PIXEL_OPTIONS options) +{ + struct d2d_render_info *render_info = impl_from_ID2D1DrawInfo(iface); + + TRACE("iface %p, id %s, options %u.\n", iface, debugstr_guid(id), options); + + render_info->mask |= D2D_RENDER_INFO_PIXEL_SHADER; + render_info->pixel_shader = *id; + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_draw_info_SetVertexProcessing(ID2D1DrawInfo *iface, + ID2D1VertexBuffer *buffer, D2D1_VERTEX_OPTIONS options, + const D2D1_BLEND_DESCRIPTION *description, const D2D1_VERTEX_RANGE *range, + const GUID *shader) +{ + FIXME("iface %p, buffer %p, options %#x, description %p, range %p, shader %s stub.\n", + iface, buffer, options, description, range, debugstr_guid(shader)); + + return E_NOTIMPL; +} + +static const ID2D1DrawInfoVtbl d2d_draw_info_vtbl = +{ + d2d_draw_info_QueryInterface, + d2d_draw_info_AddRef, + d2d_draw_info_Release, + d2d_draw_info_SetInputDescription, + d2d_draw_info_SetOutputBuffer, + d2d_draw_info_SetCached, + d2d_draw_info_SetInstructionCountHint, + d2d_draw_info_SetPixelShaderConstantBuffer, + d2d_draw_info_SetResourceTexture, + d2d_draw_info_SetVertexShaderConstantBuffer, + d2d_draw_info_SetPixelShader, + d2d_draw_info_SetVertexProcessing, +}; + +static HRESULT d2d_effect_render_info_create(struct d2d_render_info **obj) +{ + struct d2d_render_info *object; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + object->ID2D1DrawInfo_iface.lpVtbl = &d2d_draw_info_vtbl; + object->refcount = 1; + + *obj = object; + + return S_OK; +} + +static bool d2d_transform_node_needs_render_info(const struct d2d_transform_node *node) +{ + static const GUID *iids[] = + { + &IID_ID2D1SourceTransform, + &IID_ID2D1ComputeTransform, + &IID_ID2D1DrawTransform, + }; + unsigned int i; + IUnknown *obj; + + for (i = 0; i < ARRAY_SIZE(iids); ++i) + { + if (SUCCEEDED(ID2D1TransformNode_QueryInterface(node->object, iids[i], (void **)&obj))) + { + IUnknown_Release(obj); + return true; + } + } + + return false; +} + +static HRESULT d2d_effect_transform_graph_initialize_nodes(struct d2d_transform_graph *graph) +{ + ID2D1DrawTransform *draw_transform; + struct d2d_transform_node *node; + HRESULT hr; + + LIST_FOR_EACH_ENTRY(node, &graph->nodes, struct d2d_transform_node, entry) + { + if (d2d_transform_node_needs_render_info(node)) + { + if (FAILED(hr = d2d_effect_render_info_create(&node->render_info))) + return hr; + } + + if (SUCCEEDED(ID2D1TransformNode_QueryInterface(node->object, &IID_ID2D1DrawTransform, + (void **)&draw_transform))) + { + hr = ID2D1DrawTransform_SetDrawInfo(draw_transform, &node->render_info->ID2D1DrawInfo_iface); + ID2D1DrawTransform_Release(draw_transform); + if (FAILED(hr)) + { + WARN("Failed to set draw info, hr %#lx.\n", hr); + return hr; + } + } + else + { + FIXME("Unsupported node %p.\n", node); + return E_NOTIMPL; + } + } + + return S_OK; +} + +HRESULT d2d_effect_create(struct d2d_device_context *context, const CLSID *effect_id, + ID2D1Effect **effect) +{ + struct d2d_effect_context *effect_context; + const struct d2d_effect_registration *reg; + struct d2d_effect *object; + UINT32 input_count; + WCHAR clsidW[39]; + HRESULT hr; + + if (!(reg = d2d_factory_get_registered_effect(context->factory, effect_id))) + { + WARN("Effect id %s not found.\n", wine_dbgstr_guid(effect_id)); + return D2DERR_EFFECT_IS_NOT_REGISTERED; + } + + if (!(effect_context = calloc(1, sizeof(*effect_context)))) + return E_OUTOFMEMORY; + d2d_effect_context_init(effect_context, context); + + if (!(object = calloc(1, sizeof(*object)))) + { + ID2D1EffectContext_Release(&effect_context->ID2D1EffectContext_iface); + return E_OUTOFMEMORY; + } + + object->ID2D1Effect_iface.lpVtbl = &d2d_effect_vtbl; + object->ID2D1Image_iface.lpVtbl = &d2d_effect_image_vtbl; + object->refcount = 1; + object->effect_context = effect_context; + + /* Create properties */ + d2d_effect_duplicate_properties(object, &object->properties, reg->properties); + + StringFromGUID2(effect_id, clsidW, ARRAY_SIZE(clsidW)); + d2d_effect_properties_add(&object->properties, L"CLSID", D2D1_PROPERTY_CLSID, D2D1_PROPERTY_TYPE_CLSID, clsidW); + d2d_effect_properties_add(&object->properties, L"Cached", D2D1_PROPERTY_CACHED, D2D1_PROPERTY_TYPE_BOOL, L"false"); + d2d_effect_properties_add(&object->properties, L"Precision", D2D1_PROPERTY_PRECISION, D2D1_PROPERTY_TYPE_ENUM, L"0"); + + /* Sync instance input count with default input count from the description. */ + d2d_effect_get_value(object, D2D1_PROPERTY_INPUTS, D2D1_PROPERTY_TYPE_ARRAY, (BYTE *)&input_count, sizeof(input_count)); + d2d_effect_set_input_count(object, input_count); + + if (FAILED(hr = d2d_transform_graph_create(input_count, &object->graph))) + { + ID2D1EffectContext_Release(&effect_context->ID2D1EffectContext_iface); + return hr; + } + + if (FAILED(hr = reg->factory((IUnknown **)&object->impl))) + { + WARN("Failed to create implementation object, hr %#lx.\n", hr); + ID2D1Effect_Release(&object->ID2D1Effect_iface); + return hr; + } + + if (FAILED(hr = ID2D1EffectImpl_Initialize(object->impl, &effect_context->ID2D1EffectContext_iface, + &object->graph->ID2D1TransformGraph_iface))) + { + WARN("Failed to initialize effect, hr %#lx.\n", hr); + ID2D1Effect_Release(&object->ID2D1Effect_iface); + return hr; + } + + if (FAILED(hr = d2d_effect_transform_graph_initialize_nodes(object->graph))) + { + WARN("Failed to initialize graph nodes, hr %#lx.\n", hr); + ID2D1Effect_Release(&object->ID2D1Effect_iface); + return hr; + } + + *effect = &object->ID2D1Effect_iface; + + TRACE("Created effect %p.\n", *effect); + + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/factory.c b/WineFix/lib/d2d1/src/factory.c new file mode 100644 index 0000000..b35041e --- /dev/null +++ b/WineFix/lib/d2d1/src/factory.c @@ -0,0 +1,1713 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define D2D1_INIT_GUID +#include "d2d1_private.h" + +#include "xmllite.h" +#include "wine/list.h" + +WINE_DECLARE_DEBUG_CHANNEL(winediag); +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +/* Define newer D2D1 GUIDs not in Wine 9.0 libdxguid */ +DEFINE_GUID(IID_ID2D1Factory4, 0xbd4ec2d2, 0x0662, 0x4bee, 0xba, 0x8e, 0x6f, 0x29, 0xf0, 0x32, 0xe0, 0x96); +DEFINE_GUID(IID_ID2D1Factory5, 0xc4349994, 0x838e, 0x4b0f, 0x8c, 0xab, 0x44, 0x99, 0x7d, 0x9e, 0xea, 0xcc); +DEFINE_GUID(IID_ID2D1Factory6, 0xf9976f46, 0xf642, 0x44c1, 0x97, 0xca, 0xda, 0x32, 0xea, 0x2a, 0x26, 0x35); +DEFINE_GUID(IID_ID2D1Factory7, 0xbdc2bdd3, 0xb96c, 0x4de6, 0xbd, 0xf7, 0x99, 0xd4, 0x74, 0x54, 0x54, 0xde); +DEFINE_GUID(IID_ID2D1Device3, 0x852f2087, 0x802c, 0x4037, 0xab, 0x60, 0xff, 0x2e, 0x7e, 0xe6, 0xfc, 0x01); +DEFINE_GUID(IID_ID2D1Device4, 0xd7bdb159, 0x5683, 0x4a46, 0xbc, 0x9c, 0x72, 0xdc, 0x72, 0x0b, 0x85, 0x8b); +DEFINE_GUID(IID_ID2D1Device5, 0xd55ba0a4, 0x6405, 0x4694, 0xae, 0xf5, 0x08, 0xee, 0x1a, 0x43, 0x58, 0xb4); +DEFINE_GUID(IID_ID2D1Device6, 0x7bfef914, 0x2d75, 0x4bad, 0xbe, 0x87, 0xe1, 0x8d, 0xdb, 0x07, 0x7b, 0x6d); +DEFINE_GUID(IID_ID2D1DeviceContext5, 0x7836d248, 0x68cc, 0x4df6, 0xb9, 0xe8, 0xde, 0x99, 0x1b, 0xf6, 0x2e, 0xb7); +DEFINE_GUID(IID_ID2D1DeviceContext6, 0x985f7e37, 0x4ed0, 0x4a19, 0x98, 0xa3, 0x15, 0xb0, 0xed, 0xfd, 0xe3, 0x06); + +struct d2d_settings d2d_settings = +{ + ~0u, /* No ID2D1Factory version limit by default. */ +}; + +static void d2d_effect_registration_cleanup(struct d2d_effect_registration *reg) +{ + ID2D1Properties_Release(®->properties->ID2D1Properties_iface); + free(reg); +} + +static inline struct d2d_factory *impl_from_ID2D1Factory7(ID2D1Factory7 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Factory7_iface); +} + +static inline struct d2d_factory *impl_from_ID2D1Multithread(ID2D1Multithread *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_factory, ID2D1Multithread_iface); +} + +static BOOL WINAPI d2d_factory_builtins_initonce(INIT_ONCE *once, void *param, void **context) +{ + d2d_effects_init_builtins(param); + + return TRUE; +} + +static void d2d_factory_init_builtin_effects(struct d2d_factory *factory) +{ + InitOnceExecuteOnce(&factory->init_builtins, d2d_factory_builtins_initonce, factory, NULL); +} + +void d2d_factory_register_effect(struct d2d_factory *factory, struct d2d_effect_registration *effect) +{ + list_add_tail(&factory->effects, &effect->entry); +} + +struct d2d_effect_registration * d2d_factory_get_registered_effect(ID2D1Factory *iface, + const GUID *id) +{ + struct d2d_factory *factory = unsafe_impl_from_ID2D1Factory(iface); + struct d2d_effect_registration *reg; + + d2d_factory_init_builtin_effects(factory); + + LIST_FOR_EACH_ENTRY(reg, &factory->effects, struct d2d_effect_registration, entry) + { + if (IsEqualGUID(id, ®->id)) return reg; + } + + return NULL; +} + +static HRESULT d2d_factory_reload_sysmetrics(struct d2d_factory *factory) +{ + HDC hdc; + + if (!(hdc = GetDC(NULL))) + { + factory->dpi_x = factory->dpi_y = 96.0f; + return E_FAIL; + } + + factory->dpi_x = GetDeviceCaps(hdc, LOGPIXELSX); + factory->dpi_y = GetDeviceCaps(hdc, LOGPIXELSY); + + ReleaseDC(NULL, hdc); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_QueryInterface(ID2D1Factory7 *iface, REFIID iid, void **out) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if ((IsEqualGUID(iid, &IID_ID2D1Factory7) && d2d_settings.max_version_factory >= 7) + || (IsEqualGUID(iid, &IID_ID2D1Factory6) && d2d_settings.max_version_factory >= 6) + || (IsEqualGUID(iid, &IID_ID2D1Factory5) && d2d_settings.max_version_factory >= 5) + || (IsEqualGUID(iid, &IID_ID2D1Factory4) && d2d_settings.max_version_factory >= 4) + || (IsEqualGUID(iid, &IID_ID2D1Factory3) && d2d_settings.max_version_factory >= 3) + || (IsEqualGUID(iid, &IID_ID2D1Factory2) && d2d_settings.max_version_factory >= 2) + || (IsEqualGUID(iid, &IID_ID2D1Factory1) && d2d_settings.max_version_factory >= 1) + || IsEqualGUID(iid, &IID_ID2D1Factory) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Factory7_AddRef(iface); + *out = iface; + return S_OK; + } + else if (IsEqualGUID(iid, &IID_ID2D1Multithread)) + { + ID2D1Factory7_AddRef(iface); + *out = &factory->ID2D1Multithread_iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_factory_AddRef(ID2D1Factory7 *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + ULONG refcount = InterlockedIncrement(&factory->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_factory_Release(ID2D1Factory7 *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + ULONG refcount = InterlockedDecrement(&factory->refcount); + struct d2d_effect_registration *reg, *reg2; + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + if (factory->device) + ID3D10Device1_Release(factory->device); + LIST_FOR_EACH_ENTRY_SAFE(reg, reg2, &factory->effects, struct d2d_effect_registration, entry) + { + d2d_effect_registration_cleanup(reg); + } + DeleteCriticalSection(&factory->cs); + free(factory); + } + + return refcount; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ReloadSystemMetrics(ID2D1Factory7 *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + + TRACE("iface %p.\n", iface); + + return d2d_factory_reload_sysmetrics(factory); +} + +static void STDMETHODCALLTYPE d2d_factory_GetDesktopDpi(ID2D1Factory7 *iface, float *dpi_x, float *dpi_y) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + *dpi_x = factory->dpi_x; + *dpi_y = factory->dpi_y; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRectangleGeometry(ID2D1Factory7 *iface, + const D2D1_RECT_F *rect, ID2D1RectangleGeometry **geometry) +{ + struct d2d_geometry *object; + HRESULT hr; + + TRACE("iface %p, rect %s, geometry %p.\n", iface, debug_d2d_rect_f(rect), geometry); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_rectangle_geometry_init(object, (ID2D1Factory *)iface, rect))) + { + WARN("Failed to initialise rectangle geometry, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created rectangle geometry %p.\n", object); + *geometry = (ID2D1RectangleGeometry *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRoundedRectangleGeometry(ID2D1Factory7 *iface, + const D2D1_ROUNDED_RECT *rounded_rect, ID2D1RoundedRectangleGeometry **geometry) +{ + struct d2d_geometry *object; + HRESULT hr; + + TRACE("iface %p, rounded_rect %s, geometry %p.\n", iface, debug_d2d_rounded_rect(rounded_rect), geometry); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_rounded_rectangle_geometry_init(object, (ID2D1Factory *)iface, rounded_rect))) + { + WARN("Failed to initialise rounded rectangle geometry, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created rounded rectangle geometry %p.\n", object); + *geometry = (ID2D1RoundedRectangleGeometry *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateEllipseGeometry(ID2D1Factory7 *iface, + const D2D1_ELLIPSE *ellipse, ID2D1EllipseGeometry **geometry) +{ + struct d2d_geometry *object; + HRESULT hr; + + TRACE("iface %p, ellipse %s, geometry %p.\n", iface, debug_d2d_ellipse(ellipse), geometry); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_ellipse_geometry_init(object, (ID2D1Factory *)iface, ellipse))) + { + WARN("Failed to initialise ellipse geometry, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created ellipse geometry %p.\n", object); + *geometry = (ID2D1EllipseGeometry *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateGeometryGroup(ID2D1Factory7 *iface, + D2D1_FILL_MODE fill_mode, ID2D1Geometry **geometries, UINT32 geometry_count, ID2D1GeometryGroup **group) +{ + struct d2d_geometry *object; + HRESULT hr; + + TRACE("iface %p, fill_mode %#x, geometries %p, geometry_count %u, group %p.\n", + iface, fill_mode, geometries, geometry_count, group); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_geometry_group_init(object, (ID2D1Factory *)iface, fill_mode, geometries, geometry_count))) + { + WARN("Failed to initialise geometry group, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created geometry group %p.\n", object); + *group = (ID2D1GeometryGroup *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateTransformedGeometry(ID2D1Factory7 *iface, + ID2D1Geometry *src_geometry, const D2D1_MATRIX_3X2_F *transform, + ID2D1TransformedGeometry **transformed_geometry) +{ + struct d2d_geometry *object; + + TRACE("iface %p, src_geometry %p, transform %p, transformed_geometry %p.\n", + iface, src_geometry, transform, transformed_geometry); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + d2d_transformed_geometry_init(object, (ID2D1Factory *)iface, src_geometry, transform); + + TRACE("Created transformed geometry %p.\n", object); + *transformed_geometry = (ID2D1TransformedGeometry *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry(ID2D1Factory7 *iface, + ID2D1PathGeometry **geometry) +{ + struct d2d_geometry *object; + + TRACE("iface %p, geometry %p.\n", iface, geometry); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + d2d_path_geometry_init(object, (ID2D1Factory *)iface); + + TRACE("Created path geometry %p.\n", object); + *geometry = (ID2D1PathGeometry *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle(ID2D1Factory7 *iface, + const D2D1_STROKE_STYLE_PROPERTIES *desc, const float *dashes, UINT32 dash_count, + ID2D1StrokeStyle **stroke_style) +{ + struct d2d_stroke_style *object; + D2D1_STROKE_STYLE_PROPERTIES1 desc1; + HRESULT hr; + + TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n", + iface, desc, dashes, dash_count, stroke_style); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + desc1.startCap = desc->startCap; + desc1.endCap = desc->endCap; + desc1.dashCap = desc->dashCap; + desc1.lineJoin = desc->lineJoin; + desc1.miterLimit = desc->miterLimit; + desc1.dashStyle = desc->dashStyle; + desc1.dashOffset = desc->dashOffset; + desc1.transformType = D2D1_STROKE_TRANSFORM_TYPE_NORMAL; + + if (FAILED(hr = d2d_stroke_style_init(object, (ID2D1Factory *)iface, &desc1, dashes, dash_count))) + { + WARN("Failed to initialise stroke style, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created stroke style %p.\n", object); + *stroke_style = (ID2D1StrokeStyle *)&object->ID2D1StrokeStyle1_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock(ID2D1Factory7 *iface, + const D2D1_DRAWING_STATE_DESCRIPTION *desc, IDWriteRenderingParams *text_rendering_params, + ID2D1DrawingStateBlock **state_block) +{ + D2D1_DRAWING_STATE_DESCRIPTION1 state_desc; + struct d2d_state_block *object; + + TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n", + iface, desc, text_rendering_params, state_block); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (desc) + { + memcpy(&state_desc, desc, sizeof(*desc)); + state_desc.primitiveBlend = D2D1_PRIMITIVE_BLEND_SOURCE_OVER; + state_desc.unitMode = D2D1_UNIT_MODE_DIPS; + } + + d2d_state_block_init(object, (ID2D1Factory *)iface, desc ? &state_desc : NULL, text_rendering_params); + + TRACE("Created state block %p.\n", object); + *state_block = (ID2D1DrawingStateBlock *)&object->ID2D1DrawingStateBlock1_iface; + + return S_OK; +} + +static HRESULT d2d_factory_get_device(struct d2d_factory *factory, ID3D10Device1 **device) +{ + HRESULT hr = S_OK; + + if (!factory->device && FAILED(hr = D3D10CreateDevice1(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, D3D10_CREATE_DEVICE_BGRA_SUPPORT, + D3D10_FEATURE_LEVEL_10_0, D3D10_1_SDK_VERSION, &factory->device))) + WARN("Failed to create device, hr %#lx.\n", hr); + + *device = factory->device; + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateWicBitmapRenderTarget(ID2D1Factory7 *iface, + IWICBitmap *target, const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1RenderTarget **render_target) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + struct d2d_wic_render_target *object; + ID3D10Device1 *device; + HRESULT hr; + + TRACE("iface %p, target %p, desc %p, render_target %p.\n", iface, target, desc, render_target); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_factory_get_device(factory, &device))) + { + free(object); + return hr; + } + + if (FAILED(hr = d2d_wic_render_target_init(object, (ID2D1Factory1 *)iface, device, target, desc))) + { + WARN("Failed to initialise render target, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created render target %p.\n", object); + *render_target = object->dxgi_target; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateHwndRenderTarget(ID2D1Factory7 *iface, + const D2D1_RENDER_TARGET_PROPERTIES *desc, const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_rt_desc, + ID2D1HwndRenderTarget **render_target) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + struct d2d_hwnd_render_target *object; + ID3D10Device1 *device; + HRESULT hr; + + TRACE("iface %p, desc %p, hwnd_rt_desc %p, render_target %p.\n", iface, desc, hwnd_rt_desc, render_target); + + if (FAILED(hr = d2d_factory_get_device(factory, &device))) + return hr; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_hwnd_render_target_init(object, (ID2D1Factory1 *)iface, device, desc, hwnd_rt_desc))) + { + WARN("Failed to initialise render target, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created render target %p.\n", object); + *render_target = &object->ID2D1HwndRenderTarget_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDxgiSurfaceRenderTarget(ID2D1Factory7 *iface, + IDXGISurface *surface, const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1RenderTarget **render_target) +{ + IDXGIDevice *dxgi_device; + ID2D1Device *device; + HRESULT hr; + + TRACE("iface %p, surface %p, desc %p, render_target %p.\n", iface, surface, desc, render_target); + + if (FAILED(hr = IDXGISurface_GetDevice(surface, &IID_IDXGIDevice, (void **)&dxgi_device))) + { + WARN("Failed to get DXGI device, hr %#lx.\n", hr); + return hr; + } + + hr = ID2D1Factory1_CreateDevice((ID2D1Factory1 *)iface, dxgi_device, &device); + IDXGIDevice_Release(dxgi_device); + if (FAILED(hr)) + { + WARN("Failed to create D2D device, hr %#lx.\n", hr); + return hr; + } + + hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device), surface, + NULL, NULL, desc, (void **)render_target); + ID2D1Device_Release(device); + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDCRenderTarget(ID2D1Factory7 *iface, + const D2D1_RENDER_TARGET_PROPERTIES *desc, ID2D1DCRenderTarget **render_target) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + struct d2d_dc_render_target *object; + ID3D10Device1 *device; + HRESULT hr; + + TRACE("iface %p, desc %p, render_target %p.\n", iface, desc, render_target); + + if (FAILED(hr = d2d_factory_get_device(factory, &device))) + return hr; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_dc_render_target_init(object, (ID2D1Factory1 *)iface, device, desc))) + { + WARN("Failed to initialise render target, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created render target %p.\n", object); + *render_target = &object->ID2D1DCRenderTarget_iface; + + return S_OK; +} + +HRESULT d2d_factory_create_device(ID2D1Factory1 *factory, IDXGIDevice *dxgi_device, + bool allow_get_dxgi_device, REFIID iid, void **device) +{ + struct d2d_device *object; + HRESULT hr; + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_device_init(object, factory, dxgi_device, allow_get_dxgi_device))) + { + ID2D1Device6_Release(&object->ID2D1Device6_iface); + return hr; + } + + TRACE("Create device %p.\n", object); + + hr = ID2D1Device6_QueryInterface(&object->ID2D1Device6_iface, iid, device); + ID2D1Device6_Release(&object->ID2D1Device6_iface); + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device, (void **)device); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle1(ID2D1Factory7 *iface, + const D2D1_STROKE_STYLE_PROPERTIES1 *desc, const float *dashes, UINT32 dash_count, + ID2D1StrokeStyle1 **stroke_style) +{ + struct d2d_stroke_style *object; + HRESULT hr; + + TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n", + iface, desc, dashes, dash_count, stroke_style); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = d2d_stroke_style_init(object, (ID2D1Factory *)iface, + desc, dashes, dash_count))) + { + WARN("Failed to initialise stroke style, hr %#lx.\n", hr); + free(object); + return hr; + } + + TRACE("Created stroke style %p.\n", object); + *stroke_style = &object->ID2D1StrokeStyle1_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry1(ID2D1Factory7 *iface, + ID2D1PathGeometry1 **geometry) +{ + struct d2d_geometry *object; + + TRACE("iface %p, geometry %p.\n", iface, geometry); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + d2d_path_geometry_init(object, (ID2D1Factory *)iface); + + TRACE("Created path geometry %p.\n", object); + *geometry = (ID2D1PathGeometry1 *)&object->ID2D1Geometry_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock1(ID2D1Factory7 *iface, + const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, IDWriteRenderingParams *text_rendering_params, + ID2D1DrawingStateBlock1 **state_block) +{ + struct d2d_state_block *object; + + TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n", + iface, desc, text_rendering_params, state_block); + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + d2d_state_block_init(object, (ID2D1Factory *)iface, desc, text_rendering_params); + + TRACE("Created state block %p.\n", object); + *state_block = &object->ID2D1DrawingStateBlock1_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_CreateGdiMetafile(ID2D1Factory7 *iface, + IStream *stream, ID2D1GdiMetafile **metafile) +{ + FIXME("iface %p, stream %p, metafile %p stub!\n", iface, stream, metafile); + + return E_NOTIMPL; +} + +static HRESULT parse_effect_get_next_xml_node(IXmlReader *reader, XmlNodeType expected_type, + const WCHAR *expected_name, unsigned int *depth) +{ + const WCHAR *node_name; + XmlNodeType node_type; + HRESULT hr; + + assert(expected_type != XmlNodeType_Whitespace); + + while ((hr = IXmlReader_Read(reader, &node_type)) == S_OK) + { + if (node_type == XmlNodeType_Whitespace) + continue; + + if (expected_type != XmlNodeType_None && node_type != expected_type) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + if (expected_name) + { + if (FAILED(hr = IXmlReader_GetLocalName(reader, &node_name, NULL))) + return hr; + + if (wcscmp(node_name, expected_name)) + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + } + + if (depth) + IXmlReader_GetDepth(reader, depth); + return S_OK; + } + + return hr; +} + +static HRESULT parse_effect_skip_element(IXmlReader *reader, unsigned int element_depth) +{ + XmlNodeType node_type; + unsigned int depth; + HRESULT hr; + + if (IXmlReader_IsEmptyElement(reader)) return S_OK; + + while ((hr = IXmlReader_Read(reader, &node_type)) == S_OK) + { + IXmlReader_GetDepth(reader, &depth); + if (node_type == XmlNodeType_EndElement && depth == element_depth + 1) + { + return S_OK; + } + } + + return hr; +} + +static HRESULT parse_effect_get_attribute(IXmlReader *reader, const WCHAR *name, WCHAR **ret) +{ + const WCHAR *value; + + *ret = NULL; + + if (IXmlReader_MoveToAttributeByName(reader, name, NULL) != S_OK) + return E_INVALIDARG; + if (IXmlReader_GetValue(reader, &value, NULL) != S_OK) + return E_INVALIDARG; + if (!(*ret = wcsdup(value))) + return E_OUTOFMEMORY; + + return S_OK; +} + +static HRESULT parse_effect_get_property_type(IXmlReader *reader, D2D1_PROPERTY_TYPE *type) +{ + static const WCHAR *types[] = + { + [D2D1_PROPERTY_TYPE_UNKNOWN] = L"", + [D2D1_PROPERTY_TYPE_STRING] = L"string", + [D2D1_PROPERTY_TYPE_BOOL] = L"bool", + [D2D1_PROPERTY_TYPE_UINT32] = L"uint32", + [D2D1_PROPERTY_TYPE_INT32] = L"int32", + [D2D1_PROPERTY_TYPE_FLOAT] = L"float", + [D2D1_PROPERTY_TYPE_VECTOR2] = L"vector2", + [D2D1_PROPERTY_TYPE_VECTOR3] = L"vector3", + [D2D1_PROPERTY_TYPE_VECTOR4] = L"vector4", + [D2D1_PROPERTY_TYPE_BLOB] = L"blob", + [D2D1_PROPERTY_TYPE_IUNKNOWN] = L"iunknown", + [D2D1_PROPERTY_TYPE_ENUM] = L"enum", + [D2D1_PROPERTY_TYPE_ARRAY] = L"array", + [D2D1_PROPERTY_TYPE_CLSID] = L"clsid", + [D2D1_PROPERTY_TYPE_MATRIX_3X2] = L"matrix3x2", + [D2D1_PROPERTY_TYPE_MATRIX_4X3] = L"matrix4x3", + [D2D1_PROPERTY_TYPE_MATRIX_4X4] = L"matrix4x4", + [D2D1_PROPERTY_TYPE_MATRIX_5X4] = L"matrix5x4", + [D2D1_PROPERTY_TYPE_COLOR_CONTEXT] = L"colorcontext", + }; + unsigned int i; + WCHAR *value; + HRESULT hr; + + if (FAILED(hr = parse_effect_get_attribute(reader, L"type", &value))) return hr; + + *type = D2D1_PROPERTY_TYPE_UNKNOWN; + + for (i = 0; i < ARRAY_SIZE(types); ++i) + { + if (!wcscmp(value, types[i])) + { + *type = i; + break; + } + } + + free(value); + + return *type == D2D1_PROPERTY_TYPE_UNKNOWN ? E_INVALIDARG : S_OK; +} + +static struct d2d_effect_property * parse_effect_get_property(const struct d2d_effect_registration *effect, + const WCHAR *name) +{ + unsigned int i; + + for (i = 0; i < effect->properties->count; ++i) + { + if (!wcscmp(name, effect->properties->properties[i].name)) + return &effect->properties->properties[i]; + } + + return NULL; +} + +static UINT32 parse_effect_get_property_index(struct d2d_effect_properties *props, + const WCHAR *name) +{ + if (!wcscmp(name, L"DisplayName")) return D2D1_PROPERTY_DISPLAYNAME; + if (!wcscmp(name, L"Author")) return D2D1_PROPERTY_AUTHOR; + if (!wcscmp(name, L"Category")) return D2D1_PROPERTY_CATEGORY; + if (!wcscmp(name, L"Description")) return D2D1_PROPERTY_DESCRIPTION; + return props->custom_count; +} + +static HRESULT parse_effect_property(IXmlReader *reader, struct d2d_effect_registration *effect) +{ + WCHAR *name = NULL, *value = NULL; + D2D1_PROPERTY_TYPE type; + unsigned int depth; + UINT32 index; + HRESULT hr; + + if (FAILED(hr = parse_effect_get_attribute(reader, L"name", &name))) + return hr; + + if (FAILED(hr = parse_effect_get_property_type(reader, &type))) + { + free(name); + return hr; + } + + /* Check for duplicates. */ + if (parse_effect_get_property(effect, name)) + hr = E_INVALIDARG; + + parse_effect_get_attribute(reader, L"value", &value); + + if (SUCCEEDED(hr)) + { + /* FIXME: sub properties are ignored */ + IXmlReader_MoveToElement(reader); + IXmlReader_GetDepth(reader, &depth); + hr = parse_effect_skip_element(reader, depth); + } + + if (SUCCEEDED(hr)) + { + index = parse_effect_get_property_index(effect->properties, name); + hr = d2d_effect_properties_add(effect->properties, name, index, type, value); + } + + free(value); + free(name); + + return hr; +} + +static HRESULT parse_effect_inputs(IXmlReader *reader, struct d2d_effect_registration *effect) +{ + struct d2d_effect_property *inputs, *min_inputs, *max_inputs; + struct d2d_effect_properties *subproperties; + UINT32 min_inputs_value, max_inputs_value; + unsigned int depth, input_count = 0; + XmlNodeType node_type; + WCHAR *name, *value; + WCHAR buffW[16]; + HRESULT hr; + + if (FAILED(hr = d2d_effect_properties_add(effect->properties, L"Inputs", + D2D1_PROPERTY_INPUTS, D2D1_PROPERTY_TYPE_ARRAY, NULL))) + return hr; + + if (!(inputs = d2d_effect_properties_get_property_by_name(effect->properties, L"Inputs"))) + return E_FAIL; + if (!(inputs->subproperties = calloc(1, sizeof(*inputs->subproperties)))) + return E_OUTOFMEMORY; + d2d_effect_init_properties(NULL, inputs->subproperties); + subproperties = inputs->subproperties; + + d2d_effect_subproperties_add(subproperties, L"IsReadOnly", D2D1_SUBPROPERTY_ISREADONLY, + D2D1_PROPERTY_TYPE_BOOL, L"true"); + d2d_effect_subproperties_add(subproperties, L"DisplayName", D2D1_SUBPROPERTY_DISPLAYNAME, + D2D1_PROPERTY_TYPE_STRING, L"Inputs"); + + if (SUCCEEDED(parse_effect_get_attribute(reader, L"minimum", &value))) + { + hr = d2d_effect_properties_add(effect->properties, L"MinInputs", D2D1_PROPERTY_MIN_INPUTS, + D2D1_PROPERTY_TYPE_UINT32, value); + free(value); + if (FAILED(hr)) return hr; + } + if (SUCCEEDED(parse_effect_get_attribute(reader, L"maximum", &value))) + { + hr = d2d_effect_properties_add(effect->properties, L"MaxInputs", D2D1_PROPERTY_MAX_INPUTS, + D2D1_PROPERTY_TYPE_UINT32, value); + free(value); + if (FAILED(hr)) return hr; + } + + min_inputs = d2d_effect_properties_get_property_by_name(effect->properties, L"MinInputs"); + max_inputs = d2d_effect_properties_get_property_by_name(effect->properties, L"MaxInputs"); + + if (!IXmlReader_IsEmptyElement(reader)) + { + while (parse_effect_get_next_xml_node(reader, XmlNodeType_None, L"Input", &depth) == S_OK) + { + if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr; + if (node_type == XmlNodeType_EndElement) continue; + if (node_type != XmlNodeType_Element) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + + if (FAILED(hr = parse_effect_get_attribute(reader, L"name", &name))) return hr; + + swprintf(buffW, ARRAY_SIZE(buffW), L"%lu", input_count); + d2d_effect_subproperties_add(subproperties, buffW, input_count, D2D1_PROPERTY_TYPE_STRING, name); + input_count++; + + free(name); + } + *(UINT32 *)(effect->properties->data.ptr + inputs->data.offset) = input_count; + + if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr; + if (node_type != XmlNodeType_EndElement) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + } + + if (min_inputs) + d2d_effect_property_get_uint32_value(effect->properties, min_inputs, &min_inputs_value); + if (max_inputs) + d2d_effect_property_get_uint32_value(effect->properties, max_inputs, &max_inputs_value); + + /* Validate the range */ + if (min_inputs && max_inputs) + { + if (min_inputs_value > max_inputs_value) + { + WARN("Invalid input count range %u - %u.\n", min_inputs_value, max_inputs_value); + return E_INVALIDARG; + } + } + + /* Validate actual input count with specified range. */ + if (min_inputs && min_inputs_value > input_count) + { + WARN("Too few inputs were declared, expected at least %u.\n", min_inputs_value); + return E_INVALIDARG; + } + + if (max_inputs && max_inputs_value < input_count) + { + WARN("Too many inputs were declared, expected at most %u.\n", max_inputs_value); + return E_INVALIDARG; + } + + /* Apply default value to a missing property. If both properties are missing, add them. */ + if (min_inputs != max_inputs) + { + swprintf(buffW, ARRAY_SIZE(buffW), L"%lu", min_inputs ? min_inputs_value : max_inputs_value); + if (min_inputs) + hr = d2d_effect_properties_add(effect->properties, L"MaxInputs", D2D1_PROPERTY_MAX_INPUTS, D2D1_PROPERTY_TYPE_UINT32, buffW); + else + hr = d2d_effect_properties_add(effect->properties, L"MinInputs", D2D1_PROPERTY_MIN_INPUTS, D2D1_PROPERTY_TYPE_UINT32, buffW); + } + else if (!min_inputs) + { + swprintf(buffW, ARRAY_SIZE(buffW), L"%lu", input_count); + hr = d2d_effect_properties_add(effect->properties, L"MinInputs", D2D1_PROPERTY_MIN_INPUTS, D2D1_PROPERTY_TYPE_UINT32, buffW); + if (SUCCEEDED(hr)) + hr = d2d_effect_properties_add(effect->properties, L"MaxInputs", D2D1_PROPERTY_MAX_INPUTS, D2D1_PROPERTY_TYPE_UINT32, buffW); + } + + return hr; +} + +static HRESULT parse_effect_xml(IXmlReader *reader, struct d2d_effect_registration *effect) +{ + const WCHAR *node_name; + XmlNodeType node_type; + unsigned int depth; + HRESULT hr; + + /* Xml declaration node is mandatory. */ + if ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_XmlDeclaration, L"xml", NULL)) != S_OK) + return hr; + + /* Top level "Effect" element. */ + if ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_Element, L"Effect", NULL)) != S_OK) + return hr; + + /* Loop inside effect node */ + while ((hr = parse_effect_get_next_xml_node(reader, XmlNodeType_None, NULL, &depth)) == S_OK) + { + if (FAILED(hr = IXmlReader_GetNodeType(reader, &node_type))) return hr; + if (node_type != XmlNodeType_Element && node_type != XmlNodeType_EndElement) continue; + if (FAILED(hr = IXmlReader_GetLocalName(reader, &node_name, NULL))) return hr; + if (node_type == XmlNodeType_EndElement) break; + + if (!wcscmp(node_name, L"Property")) + hr = parse_effect_property(reader, effect); + else if (!wcscmp(node_name, L"Inputs")) + hr = parse_effect_inputs(reader, effect); + else + { + WARN("Unexpected element %s.\n", debugstr_w(node_name)); + hr = parse_effect_skip_element(reader, depth); + } + + if (FAILED(hr)) + return hr; + } + + return hr; +} + +static HRESULT d2d_factory_register_effect_from_stream(struct d2d_factory *factory, + REFCLSID effect_id, IStream *property_xml, const D2D1_PROPERTY_BINDING *bindings, + UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory, BOOL builtin) +{ + struct d2d_effect_registration *effect; + IXmlReader *reader; + unsigned int i; + HRESULT hr; + + LIST_FOR_EACH_ENTRY_REV(effect, &factory->effects, struct d2d_effect_registration, entry) + { + if (IsEqualGUID(effect_id, &effect->id)) + { + if (effect->builtin) return E_INVALIDARG; + ++effect->registration_count; + return S_OK; + } + } + + if (FAILED(hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL))) + return hr; + + if (FAILED(hr = IXmlReader_SetInput(reader, (IUnknown *)property_xml))) + { + IXmlReader_Release(reader); + return hr; + } + + if (!(effect = calloc(1, sizeof(*effect)))) + { + IXmlReader_Release(reader); + return E_OUTOFMEMORY; + } + if (!(effect->properties = calloc(1, sizeof(*effect->properties)))) + { + IXmlReader_Release(reader); + free(effect); + return E_OUTOFMEMORY; + } + d2d_effect_init_properties(NULL, effect->properties); + effect->builtin = builtin; + + hr = parse_effect_xml(reader, effect); + IXmlReader_Release(reader); + if (FAILED(hr)) + { + WARN("Failed to parse effect xml, hr %#lx.\n", hr); + d2d_effect_registration_cleanup(effect); + return hr; + } + + /* Check required properties. */ + if (!parse_effect_get_property(effect, L"DisplayName") + || !parse_effect_get_property(effect, L"Author") + || !parse_effect_get_property(effect, L"Category") + || !parse_effect_get_property(effect, L"Description") + || !parse_effect_get_property(effect, L"Inputs")) + { + WARN("Missing required properties.\n"); + d2d_effect_registration_cleanup(effect); + return E_INVALIDARG; + } + + /* Bind getter and setter. */ + for (i = 0; i < binding_count; ++i) + { + struct d2d_effect_property *property; + + if (!(property = parse_effect_get_property(effect, bindings[i].propertyName))) + { + WARN("Failed to bind to missing property.\n"); + d2d_effect_registration_cleanup(effect); + return D2DERR_INVALID_PROPERTY; + } + + property->get_function = bindings[i].getFunction; + property->set_function = bindings[i].setFunction; + } + + effect->registration_count = 1; + effect->id = *effect_id; + effect->factory = effect_factory; + + d2d_factory_register_effect(factory, effect); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_RegisterEffectFromStream(ID2D1Factory7 *iface, + REFCLSID effect_id, IStream *property_xml, const D2D1_PROPERTY_BINDING *bindings, + UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + + TRACE("iface %p, effect_id %s, property_xml %p, bindings %p, binding_count %u, effect_factory %p.\n", + iface, debugstr_guid(effect_id), property_xml, bindings, binding_count, effect_factory); + + d2d_factory_init_builtin_effects(factory); + + return d2d_factory_register_effect_from_stream(factory, effect_id, property_xml, bindings, + binding_count, effect_factory, FALSE); +} + +static HRESULT d2d_factory_register_effect_from_string(struct d2d_factory *factory, + REFCLSID effect_id, const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings, + UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory, BOOL builtin) +{ + static const LARGE_INTEGER zero; + IStream *stream; + ULONG size; + HRESULT hr; + + if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &stream))) + return hr; + + size = sizeof(*property_xml) * (wcslen(property_xml) + 1); + if (SUCCEEDED(hr = IStream_Write(stream, property_xml, size, NULL))) + hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL); + + if (SUCCEEDED(hr)) + hr = d2d_factory_register_effect_from_stream(factory, effect_id, stream, bindings, + binding_count, effect_factory, builtin); + + IStream_Release(stream); + return hr; +} + +HRESULT d2d_factory_register_builtin_effect(struct d2d_factory *factory, REFCLSID effect_id, + const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings, UINT32 binding_count, + PD2D1_EFFECT_FACTORY effect_factory) +{ + return d2d_factory_register_effect_from_string(factory, effect_id, property_xml, bindings, + binding_count, effect_factory, TRUE); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_RegisterEffectFromString(ID2D1Factory7 *iface, + REFCLSID effect_id, const WCHAR *property_xml, const D2D1_PROPERTY_BINDING *bindings, + UINT32 binding_count, PD2D1_EFFECT_FACTORY effect_factory) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + + TRACE("iface %p, effect_id %s, property_xml %s, bindings %p, binding_count %u, effect_factory %p.\n", + iface, debugstr_guid(effect_id), debugstr_w(property_xml), bindings, binding_count, effect_factory); + + d2d_factory_init_builtin_effects(factory); + + return d2d_factory_register_effect_from_string(factory, effect_id, property_xml, bindings, + binding_count, effect_factory, FALSE); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_UnregisterEffect(ID2D1Factory7 *iface, REFCLSID effect_id) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + struct d2d_effect_registration *effect; + + TRACE("iface %p, effect_id %s.\n", iface, debugstr_guid(effect_id)); + + d2d_factory_init_builtin_effects(factory); + + LIST_FOR_EACH_ENTRY_REV(effect, &factory->effects, struct d2d_effect_registration, entry) + { + if (IsEqualGUID(effect_id, &effect->id)) + { + if (effect->builtin) break; + if (!--effect->registration_count) + { + list_remove(&effect->entry); + d2d_effect_registration_cleanup(effect); + } + return S_OK; + } + } + + return D2DERR_EFFECT_IS_NOT_REGISTERED; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_GetRegisteredEffects(ID2D1Factory7 *iface, + CLSID *effects, UINT32 effect_count, UINT32 *returned, UINT32 *registered) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + struct d2d_effect_registration *effect; + UINT32 ret, reg; + + TRACE("iface %p, effects %p, effect_count %u, returned %p, registered %p.\n", + iface, effects, effect_count, returned, registered); + + if (!returned) returned = &ret; + if (!registered) registered = ® + + *registered = 0; + *returned = 0; + + d2d_factory_init_builtin_effects(factory); + + LIST_FOR_EACH_ENTRY(effect, &factory->effects, struct d2d_effect_registration, entry) + { + if (effects && effect_count) + { + *effects = effect->id; + effects++; + effect_count--; + *returned += 1; + } + + *registered += 1; + } + + if (!effects) return S_OK; + return *returned == *registered ? S_OK : D2DERR_INSUFFICIENT_BUFFER; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_GetEffectProperties(ID2D1Factory7 *iface, + REFCLSID effect_id, ID2D1Properties **props) +{ + struct d2d_factory *factory = impl_from_ID2D1Factory7(iface); + const struct d2d_effect_registration *reg; + + TRACE("iface %p, effect_id %s, props %p.\n", iface, debugstr_guid(effect_id), props); + + d2d_factory_init_builtin_effects(factory); + + if (!(reg = d2d_factory_get_registered_effect((ID2D1Factory *)iface, effect_id))) + { + WARN("Effect id %s not found.\n", wine_dbgstr_guid(effect_id)); + return HRESULT_FROM_WIN32(ERROR_NOT_FOUND); + } + + *props = ®->properties->ID2D1Properties_iface; + ID2D1Properties_AddRef(*props); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory2_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device1 **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device1, (void **)device); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory3_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device2 **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device2, (void **)device); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory4_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device3 **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device3, (void **)device); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory5_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device4 **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device4, (void **)device); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory6_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device5 **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device5, (void **)device); +} + +static HRESULT STDMETHODCALLTYPE d2d_factory_ID2D1Factory7_CreateDevice(ID2D1Factory7 *iface, + IDXGIDevice *dxgi_device, ID2D1Device6 **device) +{ + TRACE("iface %p, dxgi_device %p, device %p.\n", iface, dxgi_device, device); + + return d2d_factory_create_device((ID2D1Factory1 *)iface, dxgi_device, true, &IID_ID2D1Device6, (void **)device); +} + +static const struct ID2D1Factory7Vtbl d2d_factory_vtbl = +{ + d2d_factory_QueryInterface, + d2d_factory_AddRef, + d2d_factory_Release, + d2d_factory_ReloadSystemMetrics, + d2d_factory_GetDesktopDpi, + d2d_factory_CreateRectangleGeometry, + d2d_factory_CreateRoundedRectangleGeometry, + d2d_factory_CreateEllipseGeometry, + d2d_factory_CreateGeometryGroup, + d2d_factory_CreateTransformedGeometry, + d2d_factory_CreatePathGeometry, + d2d_factory_CreateStrokeStyle, + d2d_factory_CreateDrawingStateBlock, + d2d_factory_CreateWicBitmapRenderTarget, + d2d_factory_CreateHwndRenderTarget, + d2d_factory_CreateDxgiSurfaceRenderTarget, + d2d_factory_CreateDCRenderTarget, + d2d_factory_CreateDevice, + d2d_factory_CreateStrokeStyle1, + d2d_factory_CreatePathGeometry1, + d2d_factory_CreateDrawingStateBlock1, + d2d_factory_CreateGdiMetafile, + d2d_factory_RegisterEffectFromStream, + d2d_factory_RegisterEffectFromString, + d2d_factory_UnregisterEffect, + d2d_factory_GetRegisteredEffects, + d2d_factory_GetEffectProperties, + d2d_factory_ID2D1Factory2_CreateDevice, + d2d_factory_ID2D1Factory3_CreateDevice, + d2d_factory_ID2D1Factory4_CreateDevice, + d2d_factory_ID2D1Factory5_CreateDevice, + d2d_factory_ID2D1Factory6_CreateDevice, + d2d_factory_ID2D1Factory7_CreateDevice, +}; + +static HRESULT STDMETHODCALLTYPE d2d_factory_mt_QueryInterface(ID2D1Multithread *iface, REFIID iid, void **out) +{ + struct d2d_factory *factory = impl_from_ID2D1Multithread(iface); + return d2d_factory_QueryInterface(&factory->ID2D1Factory7_iface, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_factory_mt_AddRef(ID2D1Multithread *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Multithread(iface); + return d2d_factory_AddRef(&factory->ID2D1Factory7_iface); +} + +static ULONG STDMETHODCALLTYPE d2d_factory_mt_Release(ID2D1Multithread *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Multithread(iface); + return d2d_factory_Release(&factory->ID2D1Factory7_iface); +} + +static BOOL STDMETHODCALLTYPE d2d_factory_mt_GetMultithreadProtected(ID2D1Multithread *iface) +{ + return TRUE; +} + +static void STDMETHODCALLTYPE d2d_factory_mt_Enter(ID2D1Multithread *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Multithread(iface); + + TRACE("%p.\n", iface); + + EnterCriticalSection(&factory->cs); +} + +static void STDMETHODCALLTYPE d2d_factory_mt_Leave(ID2D1Multithread *iface) +{ + struct d2d_factory *factory = impl_from_ID2D1Multithread(iface); + + TRACE("%p.\n", iface); + + LeaveCriticalSection(&factory->cs); +} + +static BOOL STDMETHODCALLTYPE d2d_factory_st_GetMultithreadProtected(ID2D1Multithread *iface) +{ + return FALSE; +} + +static void STDMETHODCALLTYPE d2d_factory_st_Enter(ID2D1Multithread *iface) +{ +} + +static void STDMETHODCALLTYPE d2d_factory_st_Leave(ID2D1Multithread *iface) +{ +} + +static const struct ID2D1MultithreadVtbl d2d_factory_multithread_vtbl = +{ + d2d_factory_mt_QueryInterface, + d2d_factory_mt_AddRef, + d2d_factory_mt_Release, + d2d_factory_mt_GetMultithreadProtected, + d2d_factory_mt_Enter, + d2d_factory_mt_Leave, +}; + +static const struct ID2D1MultithreadVtbl d2d_factory_multithread_noop_vtbl = +{ + d2d_factory_mt_QueryInterface, + d2d_factory_mt_AddRef, + d2d_factory_mt_Release, + d2d_factory_st_GetMultithreadProtected, + d2d_factory_st_Enter, + d2d_factory_st_Leave, +}; + +static void d2d_factory_init(struct d2d_factory *factory, D2D1_FACTORY_TYPE factory_type, + const D2D1_FACTORY_OPTIONS *factory_options) +{ + if (factory_options && factory_options->debugLevel != D2D1_DEBUG_LEVEL_NONE) + WARN("Ignoring debug level %#x.\n", factory_options->debugLevel); + + factory->ID2D1Factory7_iface.lpVtbl = &d2d_factory_vtbl; + factory->ID2D1Multithread_iface.lpVtbl = factory_type == D2D1_FACTORY_TYPE_SINGLE_THREADED ? + &d2d_factory_multithread_noop_vtbl : &d2d_factory_multithread_vtbl; + factory->factory_type = factory_type; + factory->refcount = 1; + d2d_factory_reload_sysmetrics(factory); + list_init(&factory->effects); + InitializeCriticalSection(&factory->cs); + InitOnceInitialize(&factory->init_builtins); +} + +HRESULT WINAPI D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type, REFIID iid, + const D2D1_FACTORY_OPTIONS *factory_options, void **factory) +{ + struct d2d_factory *object; + HRESULT hr; + + TRACE("factory_type %#x, iid %s, factory_options %p, factory %p.\n", + factory_type, debugstr_guid(iid), factory_options, factory); + + if (factory_type != D2D1_FACTORY_TYPE_SINGLE_THREADED && + factory_type != D2D1_FACTORY_TYPE_MULTI_THREADED) + { + return E_INVALIDARG; + } + + if (!(object = calloc(1, sizeof(*object)))) + return E_OUTOFMEMORY; + + d2d_factory_init(object, factory_type, factory_options); + + TRACE("Created factory %p.\n", object); + + hr = ID2D1Factory7_QueryInterface(&object->ID2D1Factory7_iface, iid, factory); + ID2D1Factory7_Release(&object->ID2D1Factory7_iface); + + return hr; +} + +void WINAPI D2D1MakeRotateMatrix(float angle, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix) +{ + float theta, sin_theta, cos_theta; + + TRACE("angle %.8e, center %s, matrix %p.\n", angle, debug_d2d_point_2f(¢er), matrix); + + theta = angle * (M_PI / 180.0f); + sin_theta = sinf(theta); + cos_theta = cosf(theta); + + /* translate(center) * rotate(theta) * translate(-center) */ + matrix->_11 = cos_theta; + matrix->_12 = sin_theta; + matrix->_21 = -sin_theta; + matrix->_22 = cos_theta; + matrix->_31 = center.x - center.x * cos_theta + center.y * sin_theta; + matrix->_32 = center.y - center.x * sin_theta - center.y * cos_theta; +} + +void WINAPI D2D1MakeSkewMatrix(float angle_x, float angle_y, D2D1_POINT_2F center, D2D1_MATRIX_3X2_F *matrix) +{ + float tan_x, tan_y; + + TRACE("angle_x %.8e, angle_y %.8e, center %s, matrix %p.\n", angle_x, angle_y, debug_d2d_point_2f(¢er), matrix); + + tan_x = tan(angle_x * (M_PI / 180.0f)); + tan_y = tan(angle_y * (M_PI / 180.0f)); + + /* translate(-center) * skew() * translate(center) */ + matrix->_11 = 1.0f; + matrix->_12 = tan_y; + matrix->_21 = tan_x; + matrix->_22 = 1.0f; + matrix->_31 = -tan_x * center.y; + matrix->_32 = -tan_y * center.x; +} + +BOOL WINAPI D2D1IsMatrixInvertible(const D2D1_MATRIX_3X2_F *matrix) +{ + TRACE("matrix %p.\n", matrix); + + return (matrix->_11 * matrix->_22 - matrix->_21 * matrix->_12) != 0.0f; +} + +BOOL WINAPI D2D1InvertMatrix(D2D1_MATRIX_3X2_F *matrix) +{ + D2D1_MATRIX_3X2_F m = *matrix; + + TRACE("matrix %p.\n", matrix); + + return d2d_matrix_invert(matrix, &m); +} + +float WINAPI D2D1ComputeMaximumScaleFactor(const D2D1_MATRIX_3X2_F *matrix) +{ + const float (*m)[2] = matrix->m; + float a1, a2, c; + + TRACE("matrix %p.\n", matrix); + + /* 2x2 matrix, _31 and _32 are ignored. */ + a1 = m[0][0] * m[0][0] + m[1][0] * m[1][0]; + a2 = m[0][1] * m[0][1] + m[1][1] * m[1][1]; + c = m[0][0] * m[0][1] + m[1][0] * m[1][1]; + + /* Maximum scale factor of matrix M refers to maximum value of |Mv|/|v| over all vectors v, where |.| is + * vector length. That is defined as matrix spectral norm. Spectral norm equals to the maximum of the + * singular values s1, s2 for 2x2 matrix M. + * s_i^2 = e_i where e_i (e1, e2) are eigenvalues of (transpose(M) * M) + * e1 + e2 = trace(transpose(M) * M) = a1 + a2 + * e1 * e2 = det(transpose(M) * M) = a1 * a2 - c ^ 2. */ + return sqrtf(0.5f * (a1 + a2 + sqrtf((a1 - a2) * (a1 - a2) + 4 * c * c))); +} + +HRESULT WINAPI D2D1CreateDevice(IDXGIDevice *dxgi_device, + const D2D1_CREATION_PROPERTIES *properties, ID2D1Device **device) +{ + D2D1_CREATION_PROPERTIES default_properties = {0}; + D2D1_FACTORY_OPTIONS factory_options; + D2D1_FACTORY_TYPE factory_type; + ID3D11Device *d3d_device; + ID2D1Factory1 *factory; + HRESULT hr; + + TRACE("dxgi_device %p, properties %p, device %p.\n", dxgi_device, properties, device); + + if (!properties) + { + if (SUCCEEDED(IDXGIDevice_QueryInterface(dxgi_device, &IID_ID3D11Device, (void **)&d3d_device))) + { + if (!(ID3D11Device_GetCreationFlags(d3d_device) & D3D11_CREATE_DEVICE_SINGLETHREADED)) + default_properties.threadingMode = D2D1_THREADING_MODE_MULTI_THREADED; + ID3D11Device_Release(d3d_device); + } + properties = &default_properties; + } + + switch (properties->threadingMode) + { + case D2D1_THREADING_MODE_SINGLE_THREADED: + factory_type = D2D1_FACTORY_TYPE_SINGLE_THREADED; + break; + case D2D1_THREADING_MODE_MULTI_THREADED: + factory_type = D2D1_FACTORY_TYPE_MULTI_THREADED; + break; + default: + return E_INVALIDARG; + } + + factory_options.debugLevel = properties->debugLevel; + if (FAILED(hr = D2D1CreateFactory(factory_type, &IID_ID2D1Factory1, &factory_options, (void **)&factory))) + return hr; + + hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, device); + ID2D1Factory1_Release(factory); + return hr; +} + +HRESULT WINAPI D2D1CreateDeviceContext(IDXGISurface *dxgi_surface, + const D2D1_CREATION_PROPERTIES *properties, ID2D1DeviceContext **context) +{ + IDXGIDevice *dxgi_device; + ID2D1Device *device; + HRESULT hr; + + TRACE("dxgi_surface %p, properties %p, context %p.\n", dxgi_surface, properties, context); + + if (FAILED(hr = IDXGISurface_GetDevice(dxgi_surface, &IID_IDXGIDevice, (void **)&dxgi_device))) + return hr; + + if (SUCCEEDED(hr = D2D1CreateDevice(dxgi_device, properties, &device))) + { + hr = ID2D1Device_CreateDeviceContext(device, properties ? properties->options : D2D1_DEVICE_CONTEXT_OPTIONS_NONE, context); + ID2D1Device_Release(device); + } + + IDXGIDevice_Release(dxgi_device); + return hr; +} + +void WINAPI D2D1SinCos(float angle, float *s, float *c) +{ + TRACE("angle %.8e, s %p, c %p.\n", angle, s, c); + + *s = sinf(angle); + *c = cosf(angle); +} + +float WINAPI D2D1Tan(float angle) +{ + TRACE("angle %.8e.\n", angle); + + return tanf(angle); +} + +float WINAPI D2D1Vec3Length(float x, float y, float z) +{ + TRACE("x %.8e, y %.8e, z %.8e.\n", x, y, z); + + return sqrtf(x * x + y * y + z * z); +} + +/* See IEC 61966-2-1:1999; also described in the EXT_texture_sRGB OpenGL + * extension, among others. */ +static float srgb_transfer_function(float x) +{ + if (x <= 0.0f) + return 0.0f; + else if (x >= 1.0f) + return 1.0f; + else if (x <= 0.0031308f) + return 12.92f * x; + else + return 1.055f * powf(x, 1.0f / 2.4f) - 0.055f; +} + +static float srgb_inverse_transfer_function(float x) +{ + if (x <= 0.0f) + return 0.0f; + else if (x >= 1.0f) + return 1.0f; + else if (x <= 0.04045f) + return x / 12.92f; + else + return powf((x + 0.055f) / 1.055f, 2.4f); +} + +D2D1_COLOR_F WINAPI D2D1ConvertColorSpace(D2D1_COLOR_SPACE src_colour_space, + D2D1_COLOR_SPACE dst_colour_space, const D2D1_COLOR_F *colour) +{ + D2D1_COLOR_F ret; + + TRACE("src_colour_space %#x, dst_colour_space %#x, colour %s.\n", + src_colour_space, dst_colour_space, debug_d2d_color_f(colour)); + + if (src_colour_space == D2D1_COLOR_SPACE_CUSTOM || dst_colour_space == D2D1_COLOR_SPACE_CUSTOM) + { + ret.r = 0.0f; + ret.g = 0.0f; + ret.b = 0.0f; + ret.a = 0.0f; + + return ret; + } + + if (src_colour_space == dst_colour_space) + return *colour; + + if (src_colour_space == D2D1_COLOR_SPACE_SRGB && dst_colour_space == D2D1_COLOR_SPACE_SCRGB) + { + ret.r = srgb_inverse_transfer_function(colour->r); + ret.g = srgb_inverse_transfer_function(colour->g); + ret.b = srgb_inverse_transfer_function(colour->b); + ret.a = colour->a; + + return ret; + } + + if (src_colour_space == D2D1_COLOR_SPACE_SCRGB && dst_colour_space == D2D1_COLOR_SPACE_SRGB) + { + ret.r = srgb_transfer_function(colour->r); + ret.g = srgb_transfer_function(colour->g); + ret.b = srgb_transfer_function(colour->b); + ret.a = colour->a; + + return ret; + } + + FIXME("Unhandled conversion from source colour space %#x to destination colour space %#x.\n", + src_colour_space, dst_colour_space); + ret.r = 0.0f; + ret.g = 0.0f; + ret.b = 0.0f; + ret.a = 0.0f; + + return ret; +} + +static bool get_config_key_u32(HKEY default_key, HKEY application_key, const char *name, uint32_t *value) +{ + DWORD type, size; + uint32_t data; + + size = sizeof(data); + if (application_key && !RegQueryValueExA(application_key, + name, 0, &type, (BYTE *)&data, &size) && type == REG_DWORD) + goto success; + + size = sizeof(data); + if (default_key && !RegQueryValueExA(default_key, + name, 0, &type, (BYTE *)&data, &size) && type == REG_DWORD) + goto success; + + return false; + +success: + *value = data; + return true; +} + +static void d2d_settings_init(void) +{ + HKEY default_key, tmp_key, application_key = NULL; + char buffer[MAX_PATH + 10]; + DWORD len; + + if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Direct2D", &default_key)) + default_key = NULL; + + len = GetModuleFileNameA(0, buffer, MAX_PATH); + if (len && len < MAX_PATH) + { + char *p, *appname = buffer; + + if ((p = strrchr(appname, '/'))) + appname = p + 1; + if ((p = strrchr(appname, '\\'))) + appname = p + 1; + strcat(appname, "\\Direct2D"); + + if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmp_key)) + { + if (RegOpenKeyA(tmp_key, appname, &application_key)) + application_key = NULL; + RegCloseKey(tmp_key); + } + } + + if (!default_key && !application_key) + return; + + if (get_config_key_u32(default_key, application_key, "max_version_factory", &d2d_settings.max_version_factory)) + ERR_(winediag)("Limiting maximum Direct2D factory version to %#x.\n", d2d_settings.max_version_factory); + + if (application_key) + RegCloseKey(application_key); + if (default_key) + RegCloseKey(default_key); +} + +BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved) +{ + if (reason == DLL_PROCESS_ATTACH) + d2d_settings_init(); + return TRUE; +} diff --git a/WineFix/lib/d2d1/src/geometry.c b/WineFix/lib/d2d1/src/geometry.c new file mode 100644 index 0000000..1a8d01c --- /dev/null +++ b/WineFix/lib/d2d1/src/geometry.c @@ -0,0 +1,6148 @@ +/* + * Copyright 2015 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" +#include + +/* For Unix builds, qsort() expects standard C calling convention, not __cdecl (ms_abi) */ +#ifdef __unix__ +#undef __cdecl +#define __cdecl +#endif + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +#define D2D_FIGURE_FLAG_CLOSED 0x00000001u +#define D2D_FIGURE_FLAG_HOLLOW 0x00000002u + +#define D2D_CDT_EDGE_FLAG_FREED 0x80000000u +#define D2D_CDT_EDGE_FLAG_VISITED(r) (1u << (r)) + +#define D2D_FP_EPS (1.0f / (1 << FLT_MANT_DIG)) + +static const D2D1_MATRIX_3X2_F identity = +{{{ + 1.0f, 0.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, +}}}; + +enum d2d_cdt_edge_next +{ + D2D_EDGE_NEXT_ORIGIN = 0, + D2D_EDGE_NEXT_ROT = 1, + D2D_EDGE_NEXT_SYM = 2, + D2D_EDGE_NEXT_TOR = 3, +}; + +enum d2d_vertex_type +{ + D2D_VERTEX_TYPE_NONE, + D2D_VERTEX_TYPE_LINE, + D2D_VERTEX_TYPE_BEZIER, + D2D_VERTEX_TYPE_SPLIT_BEZIER, + D2D_VERTEX_TYPE_END, +}; + +struct d2d_segment_idx +{ + size_t figure_idx; + size_t vertex_idx; + size_t control_idx; +}; + +struct d2d_figure +{ + D2D1_POINT_2F *vertices; + size_t vertices_size; + enum d2d_vertex_type *vertex_types; + size_t vertex_types_size; + size_t vertex_count; + + D2D1_POINT_2F *bezier_controls; + size_t bezier_controls_size; + size_t bezier_control_count; + + D2D1_POINT_2F *original_bezier_controls; + size_t original_bezier_controls_size; + size_t original_bezier_control_count; + + D2D1_RECT_F bounds; + unsigned int flags; +}; + +struct d2d_cdt_edge_ref +{ + size_t idx; + enum d2d_cdt_edge_next r; +}; + +struct d2d_cdt_edge +{ + struct d2d_cdt_edge_ref next[4]; + size_t vertex[2]; + unsigned int flags; +}; + +struct d2d_cdt +{ + struct d2d_cdt_edge *edges; + size_t edges_size; + size_t edge_count; + size_t free_edge; + + const D2D1_POINT_2F *vertices; +}; + +struct d2d_geometry_intersection +{ + size_t figure_idx; + size_t vertex_idx; + size_t control_idx; + float t; + D2D1_POINT_2F p; +}; + +struct d2d_geometry_intersections +{ + struct d2d_geometry_intersection *intersections; + size_t intersections_size; + size_t intersection_count; +}; + +struct d2d_fp_two_vec2 +{ + float x[2]; + float y[2]; +}; + +struct d2d_fp_fin +{ + float *now, *other; + size_t length; +}; + +static void d2d_curve_vertex_set(struct d2d_curve_vertex *b, + const D2D1_POINT_2F *p, float u, float v, float sign) +{ + b->position = *p; + b->texcoord.u = u; + b->texcoord.v = v; + b->texcoord.sign = sign; +} + +static void d2d_face_set(struct d2d_face *f, UINT16 v0, UINT16 v1, UINT16 v2) +{ + f->v[0] = v0; + f->v[1] = v1; + f->v[2] = v2; +} + +static void d2d_outline_vertex_set(struct d2d_outline_vertex *v, float x, float y, + float prev_x, float prev_y, float next_x, float next_y) +{ + d2d_point_set(&v->position, x, y); + d2d_point_set(&v->prev, prev_x, prev_y); + d2d_point_set(&v->next, next_x, next_y); +} + +static void d2d_curve_outline_vertex_set(struct d2d_curve_outline_vertex *a, const D2D1_POINT_2F *position, + const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2, + float prev_x, float prev_y, float next_x, float next_y) +{ + a->position = *position; + a->p0 = *p0; + a->p1 = *p1; + a->p2 = *p2; + d2d_point_set(&a->prev, prev_x, prev_y); + d2d_point_set(&a->next, next_x, next_y); +} + +static void d2d_fp_two_sum(float *out, float a, float b) +{ + float a_virt, a_round, b_virt, b_round; + + out[1] = a + b; + b_virt = out[1] - a; + a_virt = out[1] - b_virt; + b_round = b - b_virt; + a_round = a - a_virt; + out[0] = a_round + b_round; +} + +static void d2d_fp_fast_two_sum(float *out, float a, float b) +{ + float b_virt; + + out[1] = a + b; + b_virt = out[1] - a; + out[0] = b - b_virt; +} + +static void d2d_fp_two_two_sum(float *out, const float *a, const float *b) +{ + float sum[2]; + + d2d_fp_two_sum(out, a[0], b[0]); + d2d_fp_two_sum(sum, a[1], out[1]); + d2d_fp_two_sum(&out[1], sum[0], b[1]); + d2d_fp_two_sum(&out[2], sum[1], out[2]); +} + +static void d2d_fp_two_diff_tail(float *out, float a, float b, float x) +{ + float a_virt, a_round, b_virt, b_round; + + b_virt = a - x; + a_virt = x + b_virt; + b_round = b_virt - b; + a_round = a - a_virt; + *out = a_round + b_round; +} + +static void d2d_fp_two_two_diff(float *out, const float *a, const float *b) +{ + float sum[2], diff; + + diff = a[0] - b[0]; + d2d_fp_two_diff_tail(out, a[0], b[0], diff); + d2d_fp_two_sum(sum, a[1], diff); + diff = sum[0] - b[1]; + d2d_fp_two_diff_tail(&out[1], sum[0], b[1], diff); + d2d_fp_two_sum(&out[2], sum[1], diff); +} + +static void d2d_fp_split(float *out, float a) +{ + float a_big, c; + + c = a * ((1 << (FLT_MANT_DIG / 2)) + 1.0f); + a_big = c - a; + out[1] = c - a_big; + out[0] = a - out[1]; +} + +static void d2d_fp_two_product_presplit(float *out, float a, float b, const float *b_split) +{ + float a_split[2], err1, err2, err3; + + out[1] = a * b; + d2d_fp_split(a_split, a); + err1 = out[1] - (a_split[1] * b_split[1]); + err2 = err1 - (a_split[0] * b_split[1]); + err3 = err2 - (a_split[1] * b_split[0]); + out[0] = (a_split[0] * b_split[0]) - err3; +} + +static void d2d_fp_two_product(float *out, float a, float b) +{ + float b_split[2]; + + d2d_fp_split(b_split, b); + d2d_fp_two_product_presplit(out, a, b, b_split); +} + +static void d2d_fp_square(float *out, float a) +{ + float a_split[2], err1, err2; + + out[1] = a * a; + d2d_fp_split(a_split, a); + err1 = out[1] - (a_split[1] * a_split[1]); + err2 = err1 - ((a_split[1] + a_split[1]) * a_split[0]); + out[0] = (a_split[0] * a_split[0]) - err2; +} + +static float d2d_fp_estimate(float *a, size_t len) +{ + float out = a[0]; + size_t idx = 1; + + while (idx < len) + out += a[idx++]; + + return out; +} + +static void d2d_fp_fast_expansion_sum_zeroelim(float *out, size_t *out_len, + const float *a, size_t a_len, const float *b, size_t b_len) +{ + float sum[2], q; + size_t a_idx, b_idx, out_idx; + + a_idx = b_idx = 0; + if ((b[b_idx] > a[a_idx]) == (b[b_idx] > -a[a_idx])) + q = a[a_idx++]; + else + q = b[b_idx++]; + out_idx = 0; + if (a_idx < a_len && b_idx < b_len) + { + if ((b[b_idx] > a[a_idx]) == (b[b_idx] > -a[a_idx])) + d2d_fp_fast_two_sum(sum, a[a_idx++], q); + else + d2d_fp_fast_two_sum(sum, b[b_idx++], q); + if (sum[0] != 0.0f) + out[out_idx++] = sum[0]; + q = sum[1]; + while (a_idx < a_len && b_idx < b_len) + { + if ((b[b_idx] > a[a_idx]) == (b[b_idx] > -a[a_idx])) + d2d_fp_two_sum(sum, q, a[a_idx++]); + else + d2d_fp_two_sum(sum, q, b[b_idx++]); + if (sum[0] != 0.0f) + out[out_idx++] = sum[0]; + q = sum[1]; + } + } + while (a_idx < a_len) + { + d2d_fp_two_sum(sum, q, a[a_idx++]); + if (sum[0] != 0.0f) + out[out_idx++] = sum[0]; + q = sum[1]; + } + while (b_idx < b_len) + { + d2d_fp_two_sum(sum, q, b[b_idx++]); + if (sum[0] != 0.0f) + out[out_idx++] = sum[0]; + q = sum[1]; + } + if (q != 0.0f || !out_idx) + out[out_idx++] = q; + + *out_len = out_idx; +} + +static void d2d_fp_scale_expansion_zeroelim(float *out, size_t *out_len, const float *a, size_t a_len, float b) +{ + float product[2], sum[2], b_split[2], q[2], a_curr; + size_t a_idx, out_idx; + + d2d_fp_split(b_split, b); + d2d_fp_two_product_presplit(q, a[0], b, b_split); + out_idx = 0; + if (q[0] != 0.0f) + out[out_idx++] = q[0]; + for (a_idx = 1; a_idx < a_len; ++a_idx) + { + a_curr = a[a_idx]; + d2d_fp_two_product_presplit(product, a_curr, b, b_split); + d2d_fp_two_sum(sum, q[1], product[0]); + if (sum[0] != 0.0f) + out[out_idx++] = sum[0]; + d2d_fp_fast_two_sum(q, product[1], sum[1]); + if (q[0] != 0.0f) + out[out_idx++] = q[0]; + } + if (q[1] != 0.0f || !out_idx) + out[out_idx++] = q[1]; + + *out_len = out_idx; +} + +static void d2d_point_subtract(D2D1_POINT_2F *out, + const D2D1_POINT_2F *a, const D2D1_POINT_2F *b) +{ + out->x = a->x - b->x; + out->y = a->y - b->y; +} + +static void d2d_point_scale(D2D1_POINT_2F *p, float scale) +{ + p->x *= scale; + p->y *= scale; +} + +static void d2d_point_lerp(D2D1_POINT_2F *out, + const D2D1_POINT_2F *a, const D2D1_POINT_2F *b, float t) +{ + out->x = a->x * (1.0f - t) + b->x * t; + out->y = a->y * (1.0f - t) + b->y * t; +} + +static void d2d_point_calculate_bezier(D2D1_POINT_2F *out, const D2D1_POINT_2F *p0, + const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2, float t) +{ + float t_c = 1.0f - t; + + out->x = t_c * (t_c * p0->x + t * p1->x) + t * (t_c * p1->x + t * p2->x); + out->y = t_c * (t_c * p0->y + t * p1->y) + t * (t_c * p1->y + t * p2->y); +} + +static float d2d_point_length(const D2D1_POINT_2F *p) +{ + return sqrtf(d2d_point_dot(p, p)); +} + +static void d2d_point_normalise(D2D1_POINT_2F *p) +{ + float l; + + if ((l = d2d_point_length(p)) != 0.0f) + d2d_point_scale(p, 1.0f / l); +} + +static BOOL d2d_vertex_type_is_bezier(enum d2d_vertex_type t) +{ + return (t == D2D_VERTEX_TYPE_BEZIER || t == D2D_VERTEX_TYPE_SPLIT_BEZIER); +} + +static BOOL d2d_vertex_type_is_split_bezier(enum d2d_vertex_type t) +{ + return t == D2D_VERTEX_TYPE_SPLIT_BEZIER; +} + +/* This implementation is based on the paper "Adaptive Precision + * Floating-Point Arithmetic and Fast Robust Geometric Predicates" and + * associated (Public Domain) code by Jonathan Richard Shewchuk. */ +static float d2d_point_ccw(const D2D1_POINT_2F *a, const D2D1_POINT_2F *b, const D2D1_POINT_2F *c) +{ + static const float err_bound_result = (3.0f + 8.0f * D2D_FP_EPS) * D2D_FP_EPS; + static const float err_bound_a = (3.0f + 16.0f * D2D_FP_EPS) * D2D_FP_EPS; + static const float err_bound_b = (2.0f + 12.0f * D2D_FP_EPS) * D2D_FP_EPS; + static const float err_bound_c = (9.0f + 64.0f * D2D_FP_EPS) * D2D_FP_EPS * D2D_FP_EPS; + float det_d[16], det_c2[12], det_c1[8], det_b[4], temp4[4], temp2a[2], temp2b[2], abxacy[2], abyacx[2]; + size_t det_d_len, det_c2_len, det_c1_len; + float det, det_sum, err_bound; + struct d2d_fp_two_vec2 ab, ac; + + ab.x[1] = b->x - a->x; + ab.y[1] = b->y - a->y; + ac.x[1] = c->x - a->x; + ac.y[1] = c->y - a->y; + + abxacy[1] = ab.x[1] * ac.y[1]; + abyacx[1] = ab.y[1] * ac.x[1]; + det = abxacy[1] - abyacx[1]; + + if (abxacy[1] > 0.0f) + { + if (abyacx[1] <= 0.0f) + return det; + det_sum = abxacy[1] + abyacx[1]; + } + else if (abxacy[1] < 0.0f) + { + if (abyacx[1] >= 0.0f) + return det; + det_sum = -abxacy[1] - abyacx[1]; + } + else + { + return det; + } + + err_bound = err_bound_a * det_sum; + if (det >= err_bound || -det >= err_bound) + return det; + + d2d_fp_two_product(abxacy, ab.x[1], ac.y[1]); + d2d_fp_two_product(abyacx, ab.y[1], ac.x[1]); + d2d_fp_two_two_diff(det_b, abxacy, abyacx); + + det = d2d_fp_estimate(det_b, 4); + err_bound = err_bound_b * det_sum; + if (det >= err_bound || -det >= err_bound) + return det; + + d2d_fp_two_diff_tail(&ab.x[0], b->x, a->x, ab.x[1]); + d2d_fp_two_diff_tail(&ab.y[0], b->y, a->y, ab.y[1]); + d2d_fp_two_diff_tail(&ac.x[0], c->x, a->x, ac.x[1]); + d2d_fp_two_diff_tail(&ac.y[0], c->y, a->y, ac.y[1]); + + if (ab.x[0] == 0.0f && ab.y[0] == 0.0f && ac.x[0] == 0.0f && ac.y[0] == 0.0f) + return det; + + err_bound = err_bound_c * det_sum + err_bound_result * fabsf(det); + det += (ab.x[1] * ac.y[0] + ac.y[1] * ab.x[0]) - (ab.y[1] * ac.x[0] + ac.x[1] * ab.y[0]); + if (det >= err_bound || -det >= err_bound) + return det; + + d2d_fp_two_product(temp2a, ab.x[0], ac.y[1]); + d2d_fp_two_product(temp2b, ab.y[0], ac.x[1]); + d2d_fp_two_two_diff(temp4, temp2a, temp2b); + d2d_fp_fast_expansion_sum_zeroelim(det_c1, &det_c1_len, det_b, 4, temp4, 4); + + d2d_fp_two_product(temp2a, ab.x[1], ac.y[0]); + d2d_fp_two_product(temp2b, ab.y[1], ac.x[0]); + d2d_fp_two_two_diff(temp4, temp2a, temp2b); + d2d_fp_fast_expansion_sum_zeroelim(det_c2, &det_c2_len, det_c1, det_c1_len, temp4, 4); + + d2d_fp_two_product(temp2a, ab.x[0], ac.y[0]); + d2d_fp_two_product(temp2b, ab.y[0], ac.x[0]); + d2d_fp_two_two_diff(temp4, temp2a, temp2b); + d2d_fp_fast_expansion_sum_zeroelim(det_d, &det_d_len, det_c2, det_c2_len, temp4, 4); + + return det_d[det_d_len - 1]; +} + +/* Determine whether the point q is within the given tolerance of the line + * segment defined by p0 and p1, with the given stroke width and transform. + * Note that we don't care about the tolerance with respect to end-points or + * joins here; those are handled separately. */ +static BOOL d2d_point_on_line_segment(const D2D1_POINT_2F *q, const D2D1_POINT_2F *p0, + const D2D1_POINT_2F *p1, const D2D1_MATRIX_3X2_F *transform, float stroke_width, float tolerance) +{ + D2D1_POINT_2F v_n, v_p, v_q, v_r; + float l; + + d2d_point_subtract(&v_p, p1, p0); + if ((l = d2d_point_length(&v_p)) == 0.0f) + return FALSE; + + /* After (shear) transformation, the line segment is a parallelogram + * defined by p⃑' and n⃑': + * + * p⃑ = P₁ - P₀ + * n⃑ = wp̂⟂ + * p⃑' = p⃑T + * n⃑' = n⃑T */ + l = stroke_width / l; + d2d_point_set(&v_r, transform->_31, transform->_32); + d2d_point_transform(&v_n, transform, -v_p.y * l, v_p.x * l); + d2d_point_subtract(&v_n, &v_n, &v_r); + d2d_point_transform(&v_p, transform, v_p.x, v_p.y); + d2d_point_subtract(&v_p, &v_p, &v_r); + + /* Decompose the vector q⃑ = Q - P₀T into a linear combination of + * p⃑' and n⃑': + * + * lq⃑ = xp⃑' + yn⃑' */ + d2d_point_transform(&v_q, transform, p0->x, p0->y); + d2d_point_subtract(&v_q, q, &v_q); + l = v_p.x * v_n.y - v_p.y * v_n.x; + v_r.x = v_q.x * v_n.y - v_q.y * v_n.x; + v_r.y = v_q.x * v_p.y - v_q.y * v_p.x; + + if (l < 0.0f) + { + l *= -1.0f; + v_r.x *= -1.0f; + } + + /* Check where Q projects onto p⃑'. */ + if (v_r.x < 0.0f || v_r.x > l) + return FALSE; + + /* Check where Q projects onto n⃑'. */ + if (fabs(v_r.y) < l) + return TRUE; + + /* Q lies outside the segment. Check whether the distance to the edge is + * within the tolerance. + * + * P₀' = P₀T + n⃑' + * q⃑' = Q - P₀' + * = q⃑ - n⃑' + * + * The distance is then q⃑' · p̂'⟂. */ + + if (v_r.y > 0.0f) + d2d_point_scale(&v_n, -1.0f); + d2d_point_subtract(&v_q, &v_q, &v_n); + + /* Check where Q projects onto p⃑' + n⃑'. */ + l = d2d_point_dot(&v_q, &v_p); + if (l < 0.0f || l > d2d_point_dot(&v_p, &v_p)) + return FALSE; + + v_n.x = -v_p.y; + v_n.y = v_p.x; + d2d_point_normalise(&v_n); + + return fabsf(d2d_point_dot(&v_q, &v_n)) < tolerance; +} + +/* Approximate the Bézier segment with a (wide) line segment. If the point + * lies outside the approximation, we're done. If the width of the + * approximation is less than the tolerance and the point lies inside, we're + * also done. If neither of those is the case, we subdivide the Bézier segment + * and try again. */ +static BOOL d2d_point_on_bezier_segment(const D2D1_POINT_2F *q, const D2D1_POINT_2F *p0, + const D2D1_BEZIER_SEGMENT *b, const D2D1_MATRIX_3X2_F *transform, float stroke_width, float tolerance) +{ + float d1, d2, d3, d4, d, l, m, w, w2; + D2D1_POINT_2F t[7], start, end, v_p; + D2D1_BEZIER_SEGMENT b0, b1; + + m = 1.0f; + w = stroke_width * 0.5f; + + d2d_point_subtract(&v_p, &b->point3, p0); + /* If the endpoints coincide, use the line through the control points as + * the direction vector. That choice is somewhat arbitrary; other choices + * with tighter error bounds exist. */ + if ((l = d2d_point_dot(&v_p, &v_p)) == 0.0f) + { + d2d_point_subtract(&v_p, &b->point2, &b->point1); + /* If the control points also coincide, the curve is in fact a line. */ + if ((l = d2d_point_dot(&v_p, &v_p)) == 0.0f) + { + d2d_point_subtract(&v_p, &b->point1, p0); + end.x = p0->x + 0.75f * v_p.x; + end.y = p0->y + 0.75f * v_p.y; + + return d2d_point_on_line_segment(q, p0, &end, transform, w, tolerance); + } + m = 0.0f; + } + l = sqrtf(l); + d2d_point_scale(&v_p, 1.0f / l); + m *= l; + + /* Calculate the width w2 of the approximation. */ + + end.x = p0->x + v_p.x; + end.y = p0->y + v_p.y; + /* Here, d1 and d2 are the maximum (signed) distance of the control points + * from the line through the start and end points. */ + d1 = d2d_point_ccw(p0, &end, &b->point1); + d2 = d2d_point_ccw(p0, &end, &b->point2); + /* It can be shown that if the control points of a cubic Bézier curve lie + * on the same side of the line through the endpoints, the distance of the + * curve itself to that line will be within 3/4 of the distance of the + * control points to that line; if the control points lie on opposite + * sides, that distance will be within 4/9 of the distance of the + * corresponding control point. We're taking that as a given here. */ + if (d1 * d2 > 0.0f) + { + d1 *= 0.75f; + d2 *= 0.75f; + } + else + { + d1 = (d1 * 4.0f) / 9.0f; + d2 = (d2 * 4.0f) / 9.0f; + } + w2 = max(fabsf(d1), fabsf(d2)); + + /* Project the control points onto the line through the endpoints of the + * curve. We will use these to calculate the endpoints of the + * approximation. */ + d2d_point_subtract(&t[1], &b->point1, p0); + d1 = d2d_point_dot(&v_p, &t[1]); + d2d_point_subtract(&t[2], &b->point2, p0); + d2 = d2d_point_dot(&v_p, &t[2]); + + /* Calculate the start point of the approximation. Like further above, the + * actual curve is somewhat closer to the endpoints than the control + * points are. */ + d = min(min(d1, d2), 0); + if (d1 * d2 > 0.0f) + d *= 0.75f; + else + d = (d * 4.0f) / 9.0f; + /* Account for the stroke width and tolerance around the endpoints by + * adjusting the endpoints here. This matters because there are no joins + * in the original geometry for the places where we subdivide the original + * curve. We do this here because it's easy; alternatively we could + * explicitly test for this when subdividing the curve further below. */ + d -= min(w + tolerance, w2); + start.x = p0->x + d * v_p.x; + start.y = p0->y + d * v_p.y; + + /* Calculate the end point of the approximation. */ + d1 -= m; + d2 -= m; + d = max(max(d1, d2), 0); + if (d1 * d2 > 0.0f) + d = m + d * 0.75f; + else + d = m + (d * 4.0f) / 9.0f; + d += min(w2, w + tolerance); + end.x = p0->x + d * v_p.x; + end.y = p0->y + d * v_p.y; + + /* Calculate the error bounds of the approximation. We do this in + * transformed space because we need these to be relative to the given + * tolerance. */ + + d2d_point_transform(&t[0], transform, p0->x, p0->y); + d2d_point_transform(&t[1], transform, b->point1.x, b->point1.y); + d2d_point_transform(&t[2], transform, b->point2.x, b->point2.y); + d2d_point_transform(&t[3], transform, b->point3.x, b->point3.y); + d2d_point_transform(&t[4], transform, start.x, start.y); + d2d_point_transform(&t[5], transform, end.x, end.y); + + d2d_point_subtract(&t[6], &t[5], &t[4]); + l = d2d_point_length(&t[6]); + /* Here, d1 and d2 are the maximum (signed) distance of the control points + * from the line through the start and end points. */ + d1 = d2d_point_ccw(&t[4], &t[5], &t[1]) / l; + d2 = d2d_point_ccw(&t[4], &t[5], &t[2]) / l; + if (d1 * d2 > 0.0f) + { + d1 *= 0.75f; + d2 *= 0.75f; + } + else + { + d1 = (d1 * 4.0f) / 9.0f; + d2 = (d2 * 4.0f) / 9.0f; + } + l = max(max(d1, d2), 0) - min(min(d1, d2), 0); + + /* d3 and d4 are the (unsigned) distance of the endpoints of the + * approximation from the original endpoints. */ + d2d_point_subtract(&t[6], &t[4], &t[0]); + d3 = d2d_point_length(&t[6]); + d2d_point_subtract(&t[6], &t[5], &t[3]); + d4 = d2d_point_length(&t[6]); + l = max(max(d3, d4), l); + + /* If the error of the approximation is less than the tolerance, and Q + * lies on the approximation, the distance of Q to the stroked curve is + * definitely within the tolerance. */ + if (l <= tolerance && d2d_point_on_line_segment(q, &start, &end, transform, w, tolerance - l)) + return TRUE; + /* On the other hand, if the distance of Q to the stroked curve is more + * than the sum of the tolerance and d, the distance of Q to the stroked + * curve can't possibly be within the tolerance. */ + if (!d2d_point_on_line_segment(q, &start, &end, transform, w + w2, tolerance)) + return FALSE; + + /* Subdivide the curve. Note that simply splitting the segment in half + * here works and is easy, but may not be optimal. We could potentially + * reduce the number of iterations we need to do by splitting based on + * curvature or segment length. */ + d2d_point_lerp(&t[0], &b->point1, &b->point2, 0.5f); + + b1.point3 = b->point3; + d2d_point_lerp(&b1.point2, &b->point3, &b->point2, 0.5f); + d2d_point_lerp(&b1.point1, &t[0], &b1.point2, 0.5f); + + d2d_point_lerp(&b0.point1, p0, &b->point1, 0.5f); + d2d_point_lerp(&b0.point2, &t[0], &b0.point1, 0.5f); + d2d_point_lerp(&b0.point3, &b0.point2, &b1.point1, 0.5f); + + return d2d_point_on_bezier_segment(q, p0, &b0, transform, stroke_width, tolerance) + || d2d_point_on_bezier_segment(q, &b0.point3, &b1, transform, stroke_width, tolerance); +} + +static void d2d_rect_union(D2D1_RECT_F *l, const D2D1_RECT_F *r) +{ + l->left = min(l->left, r->left); + l->top = min(l->top, r->top); + l->right = max(l->right, r->right); + l->bottom = max(l->bottom, r->bottom); +} + +static BOOL d2d_rect_check_overlap(const D2D_RECT_F *p, const D2D_RECT_F *q) +{ + return p->left < q->right && p->top < q->bottom && p->right > q->left && p->bottom > q->top; +} + +static void d2d_rect_get_bezier_bounds(D2D_RECT_F *bounds, const D2D1_POINT_2F *p0, + const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2) +{ + D2D1_POINT_2F p; + float root; + + bounds->left = p0->x; + bounds->top = p0->y; + bounds->right = p0->x; + bounds->bottom = p0->y; + + d2d_rect_expand(bounds, p2); + + /* f(t) = (1 - t)²P₀ + 2(1 - t)tP₁ + t²P₂ + * f'(t) = 2(1 - t)(P₁ - P₀) + 2t(P₂ - P₁) + * = 2(P₂ - 2P₁ + P₀)t + 2(P₁ - P₀) + * + * f'(t) = 0 + * t = (P₀ - P₁) / (P₂ - 2P₁ + P₀) */ + root = (p0->x - p1->x) / (p2->x - 2.0f * p1->x + p0->x); + if (root > 0.0f && root < 1.0f) + { + d2d_point_calculate_bezier(&p, p0, p1, p2, root); + d2d_rect_expand(bounds, &p); + } + + root = (p0->y - p1->y) / (p2->y - 2.0f * p1->y + p0->y); + if (root > 0.0f && root < 1.0f) + { + d2d_point_calculate_bezier(&p, p0, p1, p2, root); + d2d_rect_expand(bounds, &p); + } +} + +static void d2d_rect_get_bezier_segment_bounds(D2D_RECT_F *bounds, const D2D1_POINT_2F *p0, + const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2, float start, float end) +{ + D2D1_POINT_2F q[3], r[2]; + + d2d_point_lerp(&r[0], p0, p1, start); + d2d_point_lerp(&r[1], p1, p2, start); + d2d_point_lerp(&q[0], &r[0], &r[1], start); + + end = (end - start) / (1.0f - start); + d2d_point_lerp(&q[1], &q[0], &r[1], end); + d2d_point_lerp(&r[0], &r[1], p2, end); + d2d_point_lerp(&q[2], &q[1], &r[0], end); + + d2d_rect_get_bezier_bounds(bounds, &q[0], &q[1], &q[2]); +} + +static BOOL d2d_figure_insert_vertex(struct d2d_figure *figure, size_t idx, D2D1_POINT_2F vertex) +{ + if (!d2d_array_reserve((void **)&figure->vertices, &figure->vertices_size, + figure->vertex_count + 1, sizeof(*figure->vertices))) + { + ERR("Failed to grow vertices array.\n"); + return FALSE; + } + + if (!d2d_array_reserve((void **)&figure->vertex_types, &figure->vertex_types_size, + figure->vertex_count + 1, sizeof(*figure->vertex_types))) + { + ERR("Failed to grow vertex types array.\n"); + return FALSE; + } + + memmove(&figure->vertices[idx + 1], &figure->vertices[idx], + (figure->vertex_count - idx) * sizeof(*figure->vertices)); + memmove(&figure->vertex_types[idx + 1], &figure->vertex_types[idx], + (figure->vertex_count - idx) * sizeof(*figure->vertex_types)); + figure->vertices[idx] = vertex; + figure->vertex_types[idx] = D2D_VERTEX_TYPE_NONE; + d2d_rect_expand(&figure->bounds, &vertex); + ++figure->vertex_count; + return TRUE; +} + +static bool d2d_figure_add_vertex(struct d2d_figure *figure, D2D1_POINT_2F vertex) +{ + size_t last = figure->vertex_count - 1; + + if (figure->vertex_count && figure->vertex_types[last] == D2D_VERTEX_TYPE_LINE + && !memcmp(&figure->vertices[last], &vertex, sizeof(vertex))) + return true; + + if (!d2d_array_reserve((void **)&figure->vertices, &figure->vertices_size, + figure->vertex_count + 1, sizeof(*figure->vertices))) + { + ERR("Failed to grow vertices array.\n"); + return false; + } + + if (!d2d_array_reserve((void **)&figure->vertex_types, &figure->vertex_types_size, + figure->vertex_count + 1, sizeof(*figure->vertex_types))) + { + ERR("Failed to grow vertex types array.\n"); + return false; + } + + figure->vertices[figure->vertex_count] = vertex; + figure->vertex_types[figure->vertex_count] = D2D_VERTEX_TYPE_NONE; + d2d_rect_expand(&figure->bounds, &vertex); + ++figure->vertex_count; + return true; +} + +static BOOL d2d_figure_insert_bezier_controls(struct d2d_figure *figure, + size_t idx, size_t count, const D2D1_POINT_2F *p) +{ + if (!d2d_array_reserve((void **)&figure->bezier_controls, &figure->bezier_controls_size, + figure->bezier_control_count + count, sizeof(*figure->bezier_controls))) + { + ERR("Failed to grow bezier controls array.\n"); + return FALSE; + } + + memmove(&figure->bezier_controls[idx + count], &figure->bezier_controls[idx], + (figure->bezier_control_count - idx) * sizeof(*figure->bezier_controls)); + memcpy(&figure->bezier_controls[idx], p, count * sizeof(*figure->bezier_controls)); + figure->bezier_control_count += count; + + return TRUE; +} + +static BOOL d2d_figure_add_bezier_controls(struct d2d_figure *figure, size_t count, const D2D1_POINT_2F *p) +{ + if (!d2d_array_reserve((void **)&figure->bezier_controls, &figure->bezier_controls_size, + figure->bezier_control_count + count, sizeof(*figure->bezier_controls))) + { + ERR("Failed to grow bezier controls array.\n"); + return FALSE; + } + + memcpy(&figure->bezier_controls[figure->bezier_control_count], p, count * sizeof(*figure->bezier_controls)); + figure->bezier_control_count += count; + + return TRUE; +} + +static BOOL d2d_figure_add_original_bezier_controls(struct d2d_figure *figure, size_t count, const D2D1_POINT_2F *p) +{ + if (!d2d_array_reserve((void **)&figure->original_bezier_controls, &figure->original_bezier_controls_size, + figure->original_bezier_control_count + count, sizeof(*figure->original_bezier_controls))) + { + ERR("Failed to grow cubic Bézier controls array.\n"); + return FALSE; + } + + memcpy(&figure->original_bezier_controls[figure->original_bezier_control_count], + p, count * sizeof(*figure->original_bezier_controls)); + figure->original_bezier_control_count += count; + + return TRUE; +} + +/* Calculate the maximum deviation of a cubic Bezier curve from its quadratic approximation. + * This is used to determine if subdivision is needed for accurate representation. */ +static float d2d_bezier_cubic_to_quadratic_error(const D2D1_POINT_2F *p0, + const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2, const D2D1_POINT_2F *p3, + const D2D1_POINT_2F *q) +{ + /* The maximum error typically occurs near t=0.5 for the approximation. + * We compare the cubic Bezier value at t=0.5 with the quadratic approximation at t=0.5. + * + * Cubic Bezier at t=0.5: B(0.5) = 0.125*P0 + 0.375*P1 + 0.375*P2 + 0.125*P3 + * Quadratic Bezier at t=0.5: B(0.5) = 0.25*P0 + 0.5*Q + 0.25*P3 + * + * Optimized: compute the difference directly without intermediate points. */ + float dx, dy; + + /* Compute cubic_mid - quad_mid directly: + * dx = (0.125*P0 + 0.375*P1 + 0.375*P2 + 0.125*P3) - (0.25*P0 + 0.5*Q + 0.25*P3) + * = -0.125*P0 + 0.375*P1 + 0.375*P2 - 0.125*P3 - 0.5*Q + * = 0.375*(P1 + P2) - 0.125*(P0 + P3) - 0.5*Q */ + dx = 0.375f * (p1->x + p2->x) - 0.125f * (p0->x + p3->x) - 0.5f * q->x; + dy = 0.375f * (p1->y + p2->y) - 0.125f * (p0->y + p3->y) - 0.5f * q->y; + + return sqrtf(dx * dx + dy * dy); +} + +/* Subdivide a cubic Bezier curve at t=0.5 using De Casteljau's algorithm. */ +static void d2d_bezier_cubic_subdivide(const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1, + const D2D1_POINT_2F *p2, const D2D1_POINT_2F *p3, + D2D1_BEZIER_SEGMENT *left, D2D1_BEZIER_SEGMENT *right, D2D1_POINT_2F *mid) +{ + D2D1_POINT_2F q0, q1, q2, r0, r1; + + /* First level of subdivision */ + q0.x = (p0->x + p1->x) * 0.5f; + q0.y = (p0->y + p1->y) * 0.5f; + + q1.x = (p1->x + p2->x) * 0.5f; + q1.y = (p1->y + p2->y) * 0.5f; + + q2.x = (p2->x + p3->x) * 0.5f; + q2.y = (p2->y + p3->y) * 0.5f; + + /* Second level of subdivision */ + r0.x = (q0.x + q1.x) * 0.5f; + r0.y = (q0.y + q1.y) * 0.5f; + + r1.x = (q1.x + q2.x) * 0.5f; + r1.y = (q1.y + q2.y) * 0.5f; + + /* Final subdivision point */ + mid->x = (r0.x + r1.x) * 0.5f; + mid->y = (r0.y + r1.y) * 0.5f; + + /* Left cubic segment: p0, q0, r0, mid */ + left->point1 = q0; + left->point2 = r0; + left->point3 = *mid; + + /* Right cubic segment: mid, r1, q2, p3 */ + right->point1 = r1; + right->point2 = q2; + right->point3 = *p3; +} + +/* Check if a cubic Bezier is simple enough for single quadratic approximation. + * Returns false if the curve needs subdivision (inflection, high curvature, or control point deviation). */ +static bool d2d_bezier_cubic_is_simple(const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1, + const D2D1_POINT_2F *p2, const D2D1_POINT_2F *p3) +{ + float ax, ay, bx, by, cx, cy; + float cross1, cross2; + float chord_len, deviation1, deviation2; + float dx, dy; + + /* Check for inflection point using cross products of control polygon edges. */ + + /* Control polygon vectors */ + ax = p1->x - p0->x; + ay = p1->y - p0->y; + bx = p2->x - p1->x; + by = p2->y - p1->y; + cx = p3->x - p2->x; + cy = p3->y - p2->y; + + /* Cross products between consecutive edges */ + cross1 = ax * by - ay * bx; /* (P1-P0) × (P2-P1) */ + cross2 = bx * cy - by * cx; /* (P2-P1) × (P3-P2) */ + + /* If cross products have opposite signs, there's an inflection point */ + if (cross1 * cross2 < -0.1f) + return FALSE; /* Inflection point detected */ + + /* Check control point deviation from chord (P0 to P3). + * If control points deviate too much, the curve is too complex. */ + dx = p3->x - p0->x; + dy = p3->y - p0->y; + chord_len = sqrtf(dx * dx + dy * dy); + + if (chord_len < 1.0f) + return TRUE; /* Very short curve - always simple */ + + /* Distance of P1 from chord P0-P3 */ + deviation1 = fabsf((p1->x - p0->x) * dy - (p1->y - p0->y) * dx) / chord_len; + /* Distance of P2 from chord P0-P3 */ + deviation2 = fabsf((p2->x - p0->x) * dy - (p2->y - p0->y) * dx) / chord_len; + + /* Adaptive threshold based on chord length - tighter for longer segments */ + float max_deviation_ratio = (chord_len > 50.0f) ? 0.15f : 0.20f; + + /* If control points deviate too much from chord, subdivide */ + if (deviation1 > chord_len * max_deviation_ratio || deviation2 > chord_len * max_deviation_ratio) + return FALSE; /* Control points too far from chord - high curvature */ + + /* For very tight bends (high absolute deviation), always subdivide */ + if (deviation1 > 10.0f || deviation2 > 10.0f) + return FALSE; /* Very tight curve - needs subdivision */ + + /* Check if control points pull in opposite directions (S-curve indicator) */ + if (deviation1 > 3.0f && deviation2 > 3.0f) + { + /* Calculate signed distances to detect opposite-side pulling */ + float signed1 = (p1->x - p0->x) * dy - (p1->y - p0->y) * dx; + float signed2 = (p2->x - p0->x) * dy - (p2->y - p0->y) * dx; + if (signed1 * signed2 < 0) + return FALSE; /* S-curve detected */ + } + + return TRUE; /* Simple curve - can approximate */ +} + +/* Recursively convert a cubic Bezier to quadratic Bezier segments with adaptive subdivision. */ +static bool d2d_figure_add_cubic_bezier_recursive(struct d2d_figure *figure, + const D2D1_POINT_2F *p0, const D2D1_BEZIER_SEGMENT *cubic, + float tolerance, unsigned int depth) +{ + D2D1_POINT_2F q, mid; + D2D1_BEZIER_SEGMENT left, right; + D2D1_RECT_F bezier_bounds; + float error; + bool is_simple; + + /* Maximum recursion depth to prevent stack overflow */ + if (depth > 16) + { + WARN("Maximum recursion depth reached for cubic Bezier subdivision - using line segment.\n"); + /* At max depth, just use a line segment as fallback to ensure SOMETHING renders */ + if (!d2d_figure_add_vertex(figure, cubic->point3)) + return false; + return true; + } + + /* Check if cubic has inflection points or loops */ + is_simple = d2d_bezier_cubic_is_simple(p0, &cubic->point1, &cubic->point2, &cubic->point3); + + /* Calculate the quadratic approximation control point. + * + * For a cubic Bezier (P0, P1, P2, P3), we need to find the best quadratic control point Q. + * + * Least-squares optimal formula: Q = (3*P1 + 3*P2 - P0 - P3) / 4 + * - Minimizes geometric error (best performance) + * - Creates tangent discontinuities at subdivision joins (causes spikes) + * + * Simple average formula: Q = (P1 + P2) / 2 + * - Better tangent preservation (eliminates spikes) + * - Higher geometric error (worse performance due to more subdivision) + * + * We use a 50/50 balanced blend: Q = 0.5 * (P1 + P2) / 2 + 0.5 * (3*P1 + 3*P2 - P0 - P3) / 4 + * Simplified: Q = 0.25*(P1+P2) + 0.375*(P1+P2) - 0.125*(P0+P3) + * Further: Q = (5*P1 + 5*P2 - P0 - P3) / 8 + * + * This perfectly balances tangent preservation with performance optimization. + * Combined with 1.0px tolerance, provides maximum speed with good visual quality. + */ + q.x = (5.0f * cubic->point1.x + 5.0f * cubic->point2.x - p0->x - cubic->point3.x) * 0.125f; + q.y = (5.0f * cubic->point1.y + 5.0f * cubic->point2.y - p0->y - cubic->point3.y) * 0.125f; + + /* Calculate approximation error */ + error = d2d_bezier_cubic_to_quadratic_error(p0, &cubic->point1, &cubic->point2, + &cubic->point3, &q); + + /* Subdivide if: error too large OR curve has inflection point */ + if (error <= tolerance && is_simple) + { + figure->vertex_types[figure->vertex_count - 1] = D2D_VERTEX_TYPE_BEZIER; + + d2d_rect_get_bezier_bounds(&bezier_bounds, p0, &q, &cubic->point3); + + if (!d2d_figure_add_bezier_controls(figure, 1, &q)) + return false; + + if (!d2d_figure_add_vertex(figure, cubic->point3)) + return false; + + d2d_rect_union(&figure->bounds, &bezier_bounds); + return true; + } + + /* Error too large - subdivide and recurse */ + d2d_bezier_cubic_subdivide(p0, &cubic->point1, &cubic->point2, &cubic->point3, + &left, &right, &mid); + + if (!d2d_figure_add_cubic_bezier_recursive(figure, p0, &left, tolerance, depth + 1)) + return false; + + /* The midpoint is now the current vertex, continue with right segment */ + if (!d2d_figure_add_cubic_bezier_recursive(figure, &mid, &right, tolerance, depth + 1)) + return false; + + return true; +} + +static bool d2d_figure_begin(struct d2d_figure *figure, D2D1_POINT_2F start_point, + D2D1_FIGURE_BEGIN figure_begin) +{ + if (figure_begin == D2D1_FIGURE_BEGIN_HOLLOW) + figure->flags |= D2D_FIGURE_FLAG_HOLLOW; + + return d2d_figure_add_vertex(figure, start_point); +} + +static void d2d_figure_end(struct d2d_figure *figure, D2D1_FIGURE_END figure_end) +{ + if (memcmp(&figure->vertices[0], &figure->vertices[figure->vertex_count - 1], sizeof(*figure->vertices))) + figure->vertex_types[figure->vertex_count - 1] = D2D_VERTEX_TYPE_LINE; + else + figure->vertex_types[figure->vertex_count - 1] = D2D_VERTEX_TYPE_END; + if (figure_end == D2D1_FIGURE_END_CLOSED) + figure->flags |= D2D_FIGURE_FLAG_CLOSED; +} + +static bool d2d_figure_add_beziers(struct d2d_figure *figure, const D2D1_BEZIER_SEGMENT *beziers, + UINT32 count) +{ + unsigned int i; + + for (i = 0; i < count; ++i) + { + /* Tolerance for cubic-to-quadratic conversion. This value controls the trade-off + * between accuracy and performance. A smaller tolerance produces more quadratic + * segments but better approximates the cubic curve. + * 1.0 pixel provides maximum performance while remaining visually imperceptible. */ + const float tolerance = 1.0f; + const D2D1_POINT_2F *p0 = &figure->vertices[figure->vertex_count - 1]; + + /* Store the original cubic control points */ + if (!d2d_figure_add_original_bezier_controls(figure, 1, &beziers[i].point1) + || !d2d_figure_add_original_bezier_controls(figure, 1, &beziers[i].point2)) + { + return false; + } + + /* Convert cubic Bezier to quadratic segments with adaptive subdivision */ + if (!d2d_figure_add_cubic_bezier_recursive(figure, p0, &beziers[i], tolerance, 0)) + return false; + } + + return true; +} + +static bool d2d_figure_add_lines(struct d2d_figure *figure, const D2D1_POINT_2F *points, + UINT32 count) +{ + unsigned int i; + + for (i = 0; i < count; ++i) + { + figure->vertex_types[figure->vertex_count - 1] = D2D_VERTEX_TYPE_LINE; + if (!d2d_figure_add_vertex(figure, points[i])) + return false; + } + + return true; +} + +static void d2d_figure_cleanup(struct d2d_figure *figure) +{ + free(figure->original_bezier_controls); + free(figure->bezier_controls); + free(figure->vertices); + memset(figure, 0, sizeof(*figure)); +} + +static void d2d_cdt_edge_rot(struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) +{ + dst->idx = src->idx; + dst->r = (src->r + D2D_EDGE_NEXT_ROT) & 3; +} + +static void d2d_cdt_edge_sym(struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) +{ + dst->idx = src->idx; + dst->r = (src->r + D2D_EDGE_NEXT_SYM) & 3; +} + +static void d2d_cdt_edge_tor(struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) +{ + dst->idx = src->idx; + dst->r = (src->r + D2D_EDGE_NEXT_TOR) & 3; +} + +static void d2d_cdt_edge_next_left(const struct d2d_cdt *cdt, + struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) +{ + d2d_cdt_edge_rot(dst, &cdt->edges[src->idx].next[(src->r + D2D_EDGE_NEXT_TOR) & 3]); +} + +static void d2d_cdt_edge_next_origin(const struct d2d_cdt *cdt, + struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) +{ + *dst = cdt->edges[src->idx].next[src->r]; +} + +static void d2d_cdt_edge_prev_origin(const struct d2d_cdt *cdt, + struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) +{ + d2d_cdt_edge_rot(dst, &cdt->edges[src->idx].next[(src->r + D2D_EDGE_NEXT_ROT) & 3]); +} + +static size_t d2d_cdt_edge_origin(const struct d2d_cdt *cdt, const struct d2d_cdt_edge_ref *e) +{ + return cdt->edges[e->idx].vertex[e->r >> 1]; +} + +static size_t d2d_cdt_edge_destination(const struct d2d_cdt *cdt, const struct d2d_cdt_edge_ref *e) +{ + return cdt->edges[e->idx].vertex[!(e->r >> 1)]; +} + +static void d2d_cdt_edge_set_origin(const struct d2d_cdt *cdt, + const struct d2d_cdt_edge_ref *e, size_t vertex) +{ + cdt->edges[e->idx].vertex[e->r >> 1] = vertex; +} + +static void d2d_cdt_edge_set_destination(const struct d2d_cdt *cdt, + const struct d2d_cdt_edge_ref *e, size_t vertex) +{ + cdt->edges[e->idx].vertex[!(e->r >> 1)] = vertex; +} + +static float d2d_cdt_ccw(const struct d2d_cdt *cdt, size_t a, size_t b, size_t c) +{ + return d2d_point_ccw(&cdt->vertices[a], &cdt->vertices[b], &cdt->vertices[c]); +} + +static BOOL d2d_cdt_rightof(const struct d2d_cdt *cdt, size_t p, const struct d2d_cdt_edge_ref *e) +{ + return d2d_cdt_ccw(cdt, p, d2d_cdt_edge_destination(cdt, e), d2d_cdt_edge_origin(cdt, e)) > 0.0f; +} + +static BOOL d2d_cdt_leftof(const struct d2d_cdt *cdt, size_t p, const struct d2d_cdt_edge_ref *e) +{ + return d2d_cdt_ccw(cdt, p, d2d_cdt_edge_origin(cdt, e), d2d_cdt_edge_destination(cdt, e)) > 0.0f; +} + +/* |ax ay| + * |bx by| */ +static void d2d_fp_four_det2x2(float *out, float ax, float ay, float bx, float by) +{ + float axby[2], aybx[2]; + + d2d_fp_two_product(axby, ax, by); + d2d_fp_two_product(aybx, ay, bx); + d2d_fp_two_two_diff(out, axby, aybx); +} + +/* (a->x² + a->y²) * det2x2 */ +static void d2d_fp_sub_det3x3(float *out, size_t *out_len, const struct d2d_fp_two_vec2 *a, const float *det2x2) +{ + size_t axd_len, ayd_len, axxd_len, ayyd_len; + float axd[8], ayd[8], axxd[16], ayyd[16]; + + d2d_fp_scale_expansion_zeroelim(axd, &axd_len, det2x2, 4, a->x[1]); + d2d_fp_scale_expansion_zeroelim(axxd, &axxd_len, axd, axd_len, a->x[1]); + d2d_fp_scale_expansion_zeroelim(ayd, &ayd_len, det2x2, 4, a->y[1]); + d2d_fp_scale_expansion_zeroelim(ayyd, &ayyd_len, ayd, ayd_len, a->y[1]); + d2d_fp_fast_expansion_sum_zeroelim(out, out_len, axxd, axxd_len, ayyd, ayyd_len); +} + +/* det_abt = det_ab * c[0] + * fin += c[0] * (az * b - bz * a + c[1] * det_ab * 2.0f) */ +static void d2d_cdt_incircle_refine1(struct d2d_fp_fin *fin, float *det_abt, size_t *det_abt_len, + const float *det_ab, float a, const float *az, float b, const float *bz, const float *c) +{ + size_t temp48_len, temp32_len, temp16a_len, temp16b_len, temp16c_len, temp8_len; + float temp48[48], temp32[32], temp16a[16], temp16b[16], temp16c[16], temp8[8]; + float *swap; + + d2d_fp_scale_expansion_zeroelim(det_abt, det_abt_len, det_ab, 4, c[0]); + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, det_abt, *det_abt_len, 2.0f * c[1]); + d2d_fp_scale_expansion_zeroelim(temp8, &temp8_len, az, 4, c[0]); + d2d_fp_scale_expansion_zeroelim(temp16b, &temp16b_len, temp8, temp8_len, b); + d2d_fp_scale_expansion_zeroelim(temp8, &temp8_len, bz, 4, c[0]); + d2d_fp_scale_expansion_zeroelim(temp16c, &temp16c_len, temp8, temp8_len, -a); + d2d_fp_fast_expansion_sum_zeroelim(temp32, &temp32_len, temp16a, temp16a_len, temp16b, temp16b_len); + d2d_fp_fast_expansion_sum_zeroelim(temp48, &temp48_len, temp16c, temp16c_len, temp32, temp32_len); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp48, temp48_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; +} + +static void d2d_cdt_incircle_refine2(struct d2d_fp_fin *fin, const struct d2d_fp_two_vec2 *a, + const struct d2d_fp_two_vec2 *b, const float *bz, const struct d2d_fp_two_vec2 *c, const float *cz, + const float *axt_det_bc, size_t axt_det_bc_len, const float *ayt_det_bc, size_t ayt_det_bc_len) +{ + size_t temp64_len, temp48_len, temp32a_len, temp32b_len, temp16a_len, temp16b_len, temp8_len; + float temp64[64], temp48[48], temp32a[32], temp32b[32], temp16a[16], temp16b[16], temp8[8]; + float bct[8], bctt[4], temp4a[4], temp4b[4], temp2a[2], temp2b[2]; + size_t bct_len, bctt_len; + float *swap; + + /* bct = (b->x[0] * c->y[1] + b->x[1] * c->y[0]) - (c->x[0] * b->y[1] + c->x[1] * b->y[0]) */ + /* bctt = b->x[0] * c->y[0] + c->x[0] * b->y[0] */ + if (b->x[0] != 0.0f || b->y[0] != 0.0f || c->x[0] != 0.0f || c->y[0] != 0.0f) + { + d2d_fp_two_product(temp2a, b->x[0], c->y[1]); + d2d_fp_two_product(temp2b, b->x[1], c->y[0]); + d2d_fp_two_two_sum(temp4a, temp2a, temp2b); + d2d_fp_two_product(temp2a, c->x[0], -b->y[1]); + d2d_fp_two_product(temp2b, c->x[1], -b->y[0]); + d2d_fp_two_two_sum(temp4b, temp2a, temp2b); + d2d_fp_fast_expansion_sum_zeroelim(bct, &bct_len, temp4a, 4, temp4b, 4); + + d2d_fp_two_product(temp2a, b->x[0], c->y[0]); + d2d_fp_two_product(temp2b, c->x[0], b->y[0]); + d2d_fp_two_two_diff(bctt, temp2a, temp2b); + bctt_len = 4; + } + else + { + bct[0] = 0.0f; + bct_len = 1; + bctt[0] = 0.0f; + bctt_len = 1; + } + + if (a->x[0] != 0.0f) + { + size_t axt_bct_len, axt_bctt_len; + float axt_bct[16], axt_bctt[8]; + + /* fin += a->x[0] * (axt_det_bc + bct * 2.0f * a->x[1]) */ + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, axt_det_bc, axt_det_bc_len, a->x[0]); + d2d_fp_scale_expansion_zeroelim(axt_bct, &axt_bct_len, bct, bct_len, a->x[0]); + d2d_fp_scale_expansion_zeroelim(temp32a, &temp32a_len, axt_bct, axt_bct_len, 2.0f * a->x[1]); + d2d_fp_fast_expansion_sum_zeroelim(temp48, &temp48_len, temp16a, temp16a_len, temp32a, temp32a_len); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp48, temp48_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; + + if (b->y[0] != 0.0f) + { + /* fin += a->x[0] * cz * b->y[0] */ + d2d_fp_scale_expansion_zeroelim(temp8, &temp8_len, cz, 4, a->x[0]); + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, temp8, temp8_len, b->y[0]); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp16a, temp16a_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; + } + + if (c->y[0] != 0.0f) + { + /* fin -= a->x[0] * bz * c->y[0] */ + d2d_fp_scale_expansion_zeroelim(temp8, &temp8_len, bz, 4, -a->x[0]); + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, temp8, temp8_len, c->y[0]); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp16a, temp16a_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; + } + + /* fin += a->x[0] * (bct * a->x[0] + bctt * (2.0f * a->x[1] + a->x[0])) */ + d2d_fp_scale_expansion_zeroelim(temp32a, &temp32a_len, axt_bct, axt_bct_len, a->x[0]); + d2d_fp_scale_expansion_zeroelim(axt_bctt, &axt_bctt_len, bctt, bctt_len, a->x[0]); + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, axt_bctt, axt_bctt_len, 2.0f * a->x[1]); + d2d_fp_scale_expansion_zeroelim(temp16b, &temp16b_len, axt_bctt, axt_bctt_len, a->x[0]); + d2d_fp_fast_expansion_sum_zeroelim(temp32b, &temp32b_len, temp16a, temp16a_len, temp16b, temp16b_len); + d2d_fp_fast_expansion_sum_zeroelim(temp64, &temp64_len, temp32a, temp32a_len, temp32b, temp32b_len); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp64, temp64_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; + } + + if (a->y[0] != 0.0f) + { + size_t ayt_bct_len, ayt_bctt_len; + float ayt_bct[16], ayt_bctt[8]; + + /* fin += a->y[0] * (ayt_det_bc + bct * 2.0f * a->y[1]) */ + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, ayt_det_bc, ayt_det_bc_len, a->y[0]); + d2d_fp_scale_expansion_zeroelim(ayt_bct, &ayt_bct_len, bct, bct_len, a->y[0]); + d2d_fp_scale_expansion_zeroelim(temp32a, &temp32a_len, ayt_bct, ayt_bct_len, 2.0f * a->y[1]); + d2d_fp_fast_expansion_sum_zeroelim(temp48, &temp48_len, temp16a, temp16a_len, temp32a, temp32a_len); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp48, temp48_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; + + /* fin += a->y[0] * (bct * a->y[0] + bctt * (2.0f * a->y[1] + a->y[0])) */ + d2d_fp_scale_expansion_zeroelim(temp32a, &temp32a_len, ayt_bct, ayt_bct_len, a->y[0]); + d2d_fp_scale_expansion_zeroelim(ayt_bctt, &ayt_bctt_len, bctt, bctt_len, a->y[0]); + d2d_fp_scale_expansion_zeroelim(temp16a, &temp16a_len, ayt_bctt, ayt_bctt_len, 2.0f * a->y[1]); + d2d_fp_scale_expansion_zeroelim(temp16b, &temp16b_len, ayt_bctt, ayt_bctt_len, a->y[0]); + d2d_fp_fast_expansion_sum_zeroelim(temp32b, &temp32b_len, temp16a, temp16a_len, temp16b, temp16b_len); + d2d_fp_fast_expansion_sum_zeroelim(temp64, &temp64_len, temp32a, temp32a_len, temp32b, temp32b_len); + d2d_fp_fast_expansion_sum_zeroelim(fin->other, &fin->length, fin->now, fin->length, temp64, temp64_len); + swap = fin->now; fin->now = fin->other; fin->other = swap; + } +} + +/* Determine if point D is inside or outside the circle defined by points A, + * B, C. As explained in the paper by Guibas and Stolfi, this is equivalent to + * calculating the signed volume of the tetrahedron defined by projecting the + * points onto the paraboloid of revolution x = x² + y², + * λ:(x, y) → (x, y, x² + y²). I.e., D is inside the cirlce if + * + * |λ(A) 1| + * |λ(B) 1| > 0 + * |λ(C) 1| + * |λ(D) 1| + * + * After translating D to the origin, that becomes: + * + * |λ(A-D)| + * |λ(B-D)| > 0 + * |λ(C-D)| + * + * This implementation is based on the paper "Adaptive Precision + * Floating-Point Arithmetic and Fast Robust Geometric Predicates" and + * associated (Public Domain) code by Jonathan Richard Shewchuk. */ +static BOOL d2d_cdt_incircle(const struct d2d_cdt *cdt, size_t a, size_t b, size_t c, size_t d) +{ + static const float err_bound_result = (3.0f + 8.0f * D2D_FP_EPS) * D2D_FP_EPS; + static const float err_bound_a = (10.0f + 96.0f * D2D_FP_EPS) * D2D_FP_EPS; + static const float err_bound_b = (4.0f + 48.0f * D2D_FP_EPS) * D2D_FP_EPS; + static const float err_bound_c = (44.0f + 576.0f * D2D_FP_EPS) * D2D_FP_EPS * D2D_FP_EPS; + + size_t axt_det_bc_len, ayt_det_bc_len, bxt_det_ca_len, byt_det_ca_len, cxt_det_ab_len, cyt_det_ab_len; + float axt_det_bc[8], ayt_det_bc[8], bxt_det_ca[8], byt_det_ca[8], cxt_det_ab[8], cyt_det_ab[8]; + float fin1[1152], fin2[1152], temp64[64], sub_det_a[32], sub_det_b[32], sub_det_c[32]; + float det_bc[4], det_ca[4], det_ab[4], daz[4], dbz[4], dcz[4], temp2a[2], temp2b[2]; + size_t temp64_len, sub_det_a_len, sub_det_b_len, sub_det_c_len; + float dbxdcy, dbydcx, dcxday, dcydax, daxdby, daydbx; + const D2D1_POINT_2F *p = cdt->vertices; + struct d2d_fp_two_vec2 da, db, dc; + float permanent, err_bound, det; + struct d2d_fp_fin fin; + + da.x[1] = p[a].x - p[d].x; + da.y[1] = p[a].y - p[d].y; + db.x[1] = p[b].x - p[d].x; + db.y[1] = p[b].y - p[d].y; + dc.x[1] = p[c].x - p[d].x; + dc.y[1] = p[c].y - p[d].y; + + daz[3] = da.x[1] * da.x[1] + da.y[1] * da.y[1]; + dbxdcy = db.x[1] * dc.y[1]; + dbydcx = db.y[1] * dc.x[1]; + + dbz[3] = db.x[1] * db.x[1] + db.y[1] * db.y[1]; + dcxday = dc.x[1] * da.y[1]; + dcydax = dc.y[1] * da.x[1]; + + dcz[3] = dc.x[1] * dc.x[1] + dc.y[1] * dc.y[1]; + daxdby = da.x[1] * db.y[1]; + daydbx = da.y[1] * db.x[1]; + + det = daz[3] * (dbxdcy - dbydcx) + dbz[3] * (dcxday - dcydax) + dcz[3] * (daxdby - daydbx); + permanent = daz[3] * (fabsf(dbxdcy) + fabsf(dbydcx)) + + dbz[3] * (fabsf(dcxday) + fabsf(dcydax)) + + dcz[3] * (fabsf(daxdby) + fabsf(daydbx)); + err_bound = err_bound_a * permanent; + if (det > err_bound || -det > err_bound) + return det > 0.0f; + + fin.now = fin1; + fin.other = fin2; + + d2d_fp_four_det2x2(det_bc, db.x[1], db.y[1], dc.x[1], dc.y[1]); + d2d_fp_sub_det3x3(sub_det_a, &sub_det_a_len, &da, det_bc); + + d2d_fp_four_det2x2(det_ca, dc.x[1], dc.y[1], da.x[1], da.y[1]); + d2d_fp_sub_det3x3(sub_det_b, &sub_det_b_len, &db, det_ca); + + d2d_fp_four_det2x2(det_ab, da.x[1], da.y[1], db.x[1], db.y[1]); + d2d_fp_sub_det3x3(sub_det_c, &sub_det_c_len, &dc, det_ab); + + d2d_fp_fast_expansion_sum_zeroelim(temp64, &temp64_len, sub_det_a, sub_det_a_len, sub_det_b, sub_det_b_len); + d2d_fp_fast_expansion_sum_zeroelim(fin.now, &fin.length, temp64, temp64_len, sub_det_c, sub_det_c_len); + det = d2d_fp_estimate(fin.now, fin.length); + err_bound = err_bound_b * permanent; + if (det >= err_bound || -det >= err_bound) + return det > 0.0f; + + d2d_fp_two_diff_tail(&da.x[0], p[a].x, p[d].x, da.x[1]); + d2d_fp_two_diff_tail(&da.y[0], p[a].y, p[d].y, da.y[1]); + d2d_fp_two_diff_tail(&db.x[0], p[b].x, p[d].x, db.x[1]); + d2d_fp_two_diff_tail(&db.y[0], p[b].y, p[d].y, db.y[1]); + d2d_fp_two_diff_tail(&dc.x[0], p[c].x, p[d].x, dc.x[1]); + d2d_fp_two_diff_tail(&dc.y[0], p[c].y, p[d].y, dc.y[1]); + if (da.x[0] == 0.0f && db.x[0] == 0.0f && dc.x[0] == 0.0f + && da.y[0] == 0.0f && db.y[0] == 0.0f && dc.y[0] == 0.0f) + return det > 0.0f; + + err_bound = err_bound_c * permanent + err_bound_result * fabsf(det); + det += (daz[3] * ((db.x[1] * dc.y[0] + dc.y[1] * db.x[0]) - (db.y[1] * dc.x[0] + dc.x[1] * db.y[0])) + + 2.0f * (da.x[1] * da.x[0] + da.y[1] * da.y[0]) * (db.x[1] * dc.y[1] - db.y[1] * dc.x[1])) + + (dbz[3] * ((dc.x[1] * da.y[0] + da.y[1] * dc.x[0]) - (dc.y[1] * da.x[0] + da.x[1] * dc.y[0])) + + 2.0f * (db.x[1] * db.x[0] + db.y[1] * db.y[0]) * (dc.x[1] * da.y[1] - dc.y[1] * da.x[1])) + + (dcz[3] * ((da.x[1] * db.y[0] + db.y[1] * da.x[0]) - (da.y[1] * db.x[0] + db.x[1] * da.y[0])) + + 2.0f * (dc.x[1] * dc.x[0] + dc.y[1] * dc.y[0]) * (da.x[1] * db.y[1] - da.y[1] * db.x[1])); + if (det >= err_bound || -det >= err_bound) + return det > 0.0f; + + if (db.x[0] != 0.0f || db.y[0] != 0.0f || dc.x[0] != 0.0f || dc.y[0] != 0.0f) + { + d2d_fp_square(temp2a, da.x[1]); + d2d_fp_square(temp2b, da.y[1]); + d2d_fp_two_two_sum(daz, temp2a, temp2b); + } + if (dc.x[0] != 0.0f || dc.y[0] != 0.0f || da.x[0] != 0.0f || da.y[0] != 0.0f) + { + d2d_fp_square(temp2a, db.x[1]); + d2d_fp_square(temp2b, db.y[1]); + d2d_fp_two_two_sum(dbz, temp2a, temp2b); + } + if (da.x[0] != 0.0f || da.y[0] != 0.0f || db.x[0] != 0.0f || db.y[0] != 0.0f) + { + d2d_fp_square(temp2a, dc.x[1]); + d2d_fp_square(temp2b, dc.y[1]); + d2d_fp_two_two_sum(dcz, temp2a, temp2b); + } + + if (da.x[0] != 0.0f) + d2d_cdt_incircle_refine1(&fin, axt_det_bc, &axt_det_bc_len, det_bc, dc.y[1], dcz, db.y[1], dbz, da.x); + if (da.y[0] != 0.0f) + d2d_cdt_incircle_refine1(&fin, ayt_det_bc, &ayt_det_bc_len, det_bc, db.x[1], dbz, dc.x[1], dcz, da.y); + if (db.x[0] != 0.0f) + d2d_cdt_incircle_refine1(&fin, bxt_det_ca, &bxt_det_ca_len, det_ca, da.y[1], daz, dc.y[1], dcz, db.x); + if (db.y[0] != 0.0f) + d2d_cdt_incircle_refine1(&fin, byt_det_ca, &byt_det_ca_len, det_ca, dc.x[1], dcz, da.x[1], daz, db.y); + if (dc.x[0] != 0.0f) + d2d_cdt_incircle_refine1(&fin, cxt_det_ab, &cxt_det_ab_len, det_ab, db.y[1], dbz, da.y[1], daz, dc.x); + if (dc.y[0] != 0.0f) + d2d_cdt_incircle_refine1(&fin, cyt_det_ab, &cyt_det_ab_len, det_ab, da.x[1], daz, db.x[1], dbz, dc.y); + + if (da.x[0] != 0.0f || da.y[0] != 0.0f) + d2d_cdt_incircle_refine2(&fin, &da, &db, dbz, &dc, dcz, + axt_det_bc, axt_det_bc_len, ayt_det_bc, ayt_det_bc_len); + if (db.x[0] != 0.0f || db.y[0] != 0.0f) + d2d_cdt_incircle_refine2(&fin, &db, &dc, dcz, &da, daz, + bxt_det_ca, bxt_det_ca_len, byt_det_ca, byt_det_ca_len); + if (dc.x[0] != 0.0f || dc.y[0] != 0.0f) + d2d_cdt_incircle_refine2(&fin, &dc, &da, daz, &db, dbz, + cxt_det_ab, cxt_det_ab_len, cyt_det_ab, cyt_det_ab_len); + + return fin.now[fin.length - 1] > 0.0f; +} + +static void d2d_cdt_splice(const struct d2d_cdt *cdt, const struct d2d_cdt_edge_ref *a, + const struct d2d_cdt_edge_ref *b) +{ + struct d2d_cdt_edge_ref ta, tb, alpha, beta; + + ta = cdt->edges[a->idx].next[a->r]; + tb = cdt->edges[b->idx].next[b->r]; + cdt->edges[a->idx].next[a->r] = tb; + cdt->edges[b->idx].next[b->r] = ta; + + d2d_cdt_edge_rot(&alpha, &ta); + d2d_cdt_edge_rot(&beta, &tb); + + ta = cdt->edges[alpha.idx].next[alpha.r]; + tb = cdt->edges[beta.idx].next[beta.r]; + cdt->edges[alpha.idx].next[alpha.r] = tb; + cdt->edges[beta.idx].next[beta.r] = ta; +} + +static BOOL d2d_cdt_create_edge(struct d2d_cdt *cdt, struct d2d_cdt_edge_ref *e) +{ + struct d2d_cdt_edge *edge; + + if (cdt->free_edge != ~0u) + { + e->idx = cdt->free_edge; + cdt->free_edge = cdt->edges[e->idx].next[D2D_EDGE_NEXT_ORIGIN].idx; + } + else + { + if (!d2d_array_reserve((void **)&cdt->edges, &cdt->edges_size, cdt->edge_count + 1, sizeof(*cdt->edges))) + { + ERR("Failed to grow edges array.\n"); + return FALSE; + } + e->idx = cdt->edge_count++; + } + e->r = 0; + + edge = &cdt->edges[e->idx]; + edge->next[D2D_EDGE_NEXT_ORIGIN] = *e; + d2d_cdt_edge_tor(&edge->next[D2D_EDGE_NEXT_ROT], e); + d2d_cdt_edge_sym(&edge->next[D2D_EDGE_NEXT_SYM], e); + d2d_cdt_edge_rot(&edge->next[D2D_EDGE_NEXT_TOR], e); + edge->flags = 0; + + return TRUE; +} + +static void d2d_cdt_destroy_edge(struct d2d_cdt *cdt, const struct d2d_cdt_edge_ref *e) +{ + struct d2d_cdt_edge_ref next, sym, prev; + + d2d_cdt_edge_next_origin(cdt, &next, e); + if (next.idx != e->idx || next.r != e->r) + { + d2d_cdt_edge_prev_origin(cdt, &prev, e); + d2d_cdt_splice(cdt, e, &prev); + } + + d2d_cdt_edge_sym(&sym, e); + + d2d_cdt_edge_next_origin(cdt, &next, &sym); + if (next.idx != sym.idx || next.r != sym.r) + { + d2d_cdt_edge_prev_origin(cdt, &prev, &sym); + d2d_cdt_splice(cdt, &sym, &prev); + } + + cdt->edges[e->idx].flags |= D2D_CDT_EDGE_FLAG_FREED; + cdt->edges[e->idx].next[D2D_EDGE_NEXT_ORIGIN].idx = cdt->free_edge; + cdt->free_edge = e->idx; +} + +static BOOL d2d_cdt_connect(struct d2d_cdt *cdt, struct d2d_cdt_edge_ref *e, + const struct d2d_cdt_edge_ref *a, const struct d2d_cdt_edge_ref *b) +{ + struct d2d_cdt_edge_ref tmp; + + if (!d2d_cdt_create_edge(cdt, e)) + return FALSE; + d2d_cdt_edge_set_origin(cdt, e, d2d_cdt_edge_destination(cdt, a)); + d2d_cdt_edge_set_destination(cdt, e, d2d_cdt_edge_origin(cdt, b)); + d2d_cdt_edge_next_left(cdt, &tmp, a); + d2d_cdt_splice(cdt, e, &tmp); + d2d_cdt_edge_sym(&tmp, e); + d2d_cdt_splice(cdt, &tmp, b); + + return TRUE; +} + +static BOOL d2d_cdt_merge(struct d2d_cdt *cdt, struct d2d_cdt_edge_ref *left_outer, + struct d2d_cdt_edge_ref *left_inner, struct d2d_cdt_edge_ref *right_inner, + struct d2d_cdt_edge_ref *right_outer) +{ + struct d2d_cdt_edge_ref base_edge, tmp; + + /* Create the base edge between both parts. */ + for (;;) + { + if (d2d_cdt_leftof(cdt, d2d_cdt_edge_origin(cdt, right_inner), left_inner)) + { + d2d_cdt_edge_next_left(cdt, left_inner, left_inner); + } + else if (d2d_cdt_rightof(cdt, d2d_cdt_edge_origin(cdt, left_inner), right_inner)) + { + d2d_cdt_edge_sym(&tmp, right_inner); + d2d_cdt_edge_next_origin(cdt, right_inner, &tmp); + } + else + { + break; + } + } + + d2d_cdt_edge_sym(&tmp, right_inner); + if (!d2d_cdt_connect(cdt, &base_edge, &tmp, left_inner)) + return FALSE; + if (d2d_cdt_edge_origin(cdt, left_inner) == d2d_cdt_edge_origin(cdt, left_outer)) + d2d_cdt_edge_sym(left_outer, &base_edge); + if (d2d_cdt_edge_origin(cdt, right_inner) == d2d_cdt_edge_origin(cdt, right_outer)) + *right_outer = base_edge; + + for (;;) + { + struct d2d_cdt_edge_ref left_candidate, right_candidate, sym_base_edge; + BOOL left_valid, right_valid; + + /* Find the left candidate. */ + d2d_cdt_edge_sym(&sym_base_edge, &base_edge); + d2d_cdt_edge_next_origin(cdt, &left_candidate, &sym_base_edge); + if ((left_valid = d2d_cdt_leftof(cdt, d2d_cdt_edge_destination(cdt, &left_candidate), &sym_base_edge))) + { + d2d_cdt_edge_next_origin(cdt, &tmp, &left_candidate); + while (d2d_cdt_edge_destination(cdt, &tmp) != d2d_cdt_edge_destination(cdt, &sym_base_edge) + && d2d_cdt_incircle(cdt, + d2d_cdt_edge_origin(cdt, &sym_base_edge), d2d_cdt_edge_destination(cdt, &sym_base_edge), + d2d_cdt_edge_destination(cdt, &left_candidate), d2d_cdt_edge_destination(cdt, &tmp))) + { + d2d_cdt_destroy_edge(cdt, &left_candidate); + left_candidate = tmp; + d2d_cdt_edge_next_origin(cdt, &tmp, &left_candidate); + } + } + d2d_cdt_edge_sym(&left_candidate, &left_candidate); + + /* Find the right candidate. */ + d2d_cdt_edge_prev_origin(cdt, &right_candidate, &base_edge); + if ((right_valid = d2d_cdt_rightof(cdt, d2d_cdt_edge_destination(cdt, &right_candidate), &base_edge))) + { + d2d_cdt_edge_prev_origin(cdt, &tmp, &right_candidate); + while (d2d_cdt_edge_destination(cdt, &tmp) != d2d_cdt_edge_destination(cdt, &base_edge) + && d2d_cdt_incircle(cdt, + d2d_cdt_edge_origin(cdt, &sym_base_edge), d2d_cdt_edge_destination(cdt, &sym_base_edge), + d2d_cdt_edge_destination(cdt, &right_candidate), d2d_cdt_edge_destination(cdt, &tmp))) + { + d2d_cdt_destroy_edge(cdt, &right_candidate); + right_candidate = tmp; + d2d_cdt_edge_prev_origin(cdt, &tmp, &right_candidate); + } + } + + if (!left_valid && !right_valid) + break; + + /* Connect the appropriate candidate with the base edge. */ + if (!left_valid || (right_valid && d2d_cdt_incircle(cdt, + d2d_cdt_edge_origin(cdt, &left_candidate), d2d_cdt_edge_destination(cdt, &left_candidate), + d2d_cdt_edge_origin(cdt, &right_candidate), d2d_cdt_edge_destination(cdt, &right_candidate)))) + { + if (!d2d_cdt_connect(cdt, &base_edge, &right_candidate, &sym_base_edge)) + return FALSE; + } + else + { + if (!d2d_cdt_connect(cdt, &base_edge, &sym_base_edge, &left_candidate)) + return FALSE; + } + } + + return TRUE; +} + +/* Create a Delaunay triangulation from a set of vertices. This is an + * implementation of the divide-and-conquer algorithm described by Guibas and + * Stolfi. Should be called with at least two vertices. */ +static BOOL d2d_cdt_triangulate(struct d2d_cdt *cdt, size_t start_vertex, size_t vertex_count, + struct d2d_cdt_edge_ref *left_edge, struct d2d_cdt_edge_ref *right_edge) +{ + struct d2d_cdt_edge_ref left_inner, left_outer, right_inner, right_outer, tmp; + size_t cut; + + /* Only two vertices, create a single edge. */ + if (vertex_count == 2) + { + struct d2d_cdt_edge_ref a; + + if (!d2d_cdt_create_edge(cdt, &a)) + return FALSE; + d2d_cdt_edge_set_origin(cdt, &a, start_vertex); + d2d_cdt_edge_set_destination(cdt, &a, start_vertex + 1); + + *left_edge = a; + d2d_cdt_edge_sym(right_edge, &a); + + return TRUE; + } + + /* Three vertices, create a triangle. */ + if (vertex_count == 3) + { + struct d2d_cdt_edge_ref a, b, c; + float det; + + if (!d2d_cdt_create_edge(cdt, &a)) + return FALSE; + if (!d2d_cdt_create_edge(cdt, &b)) + return FALSE; + d2d_cdt_edge_sym(&tmp, &a); + d2d_cdt_splice(cdt, &tmp, &b); + + d2d_cdt_edge_set_origin(cdt, &a, start_vertex); + d2d_cdt_edge_set_destination(cdt, &a, start_vertex + 1); + d2d_cdt_edge_set_origin(cdt, &b, start_vertex + 1); + d2d_cdt_edge_set_destination(cdt, &b, start_vertex + 2); + + det = d2d_cdt_ccw(cdt, start_vertex, start_vertex + 1, start_vertex + 2); + if (det != 0.0f && !d2d_cdt_connect(cdt, &c, &b, &a)) + return FALSE; + + if (det < 0.0f) + { + d2d_cdt_edge_sym(left_edge, &c); + *right_edge = c; + } + else + { + *left_edge = a; + d2d_cdt_edge_sym(right_edge, &b); + } + + return TRUE; + } + + /* More than three vertices, divide. */ + cut = vertex_count / 2; + if (!d2d_cdt_triangulate(cdt, start_vertex, cut, &left_outer, &left_inner)) + return FALSE; + if (!d2d_cdt_triangulate(cdt, start_vertex + cut, vertex_count - cut, &right_inner, &right_outer)) + return FALSE; + /* Merge the left and right parts. */ + if (!d2d_cdt_merge(cdt, &left_outer, &left_inner, &right_inner, &right_outer)) + return FALSE; + + *left_edge = left_outer; + *right_edge = right_outer; + return TRUE; +} + +static int __cdecl d2d_cdt_compare_vertices(const void *a, const void *b) +{ + const D2D1_POINT_2F *p0 = a; + const D2D1_POINT_2F *p1 = b; + float diff = p0->x - p1->x; + + if (diff == 0.0f) + diff = p0->y - p1->y; + + return diff == 0.0f ? 0 : (diff > 0.0f ? 1 : -1); +} + +/* Determine whether a given point is inside the geometry, using the current + * fill mode rule. */ +static BOOL d2d_path_geometry_point_inside(const struct d2d_geometry *geometry, + const D2D1_POINT_2F *probe, BOOL triangles_only) +{ + const D2D1_POINT_2F *p0, *p1; + D2D1_POINT_2F v_p, v_probe; + unsigned int score; + size_t i, j, last; + + for (i = 0, score = 0; i < geometry->u.path.figure_count; ++i) + { + const struct d2d_figure *figure = &geometry->u.path.figures[i]; + + if (probe->x < figure->bounds.left || probe->x > figure->bounds.right + || probe->y < figure->bounds.top || probe->y > figure->bounds.bottom) + continue; + + last = figure->vertex_count - 1; + if (!triangles_only) + { + while (last && figure->vertex_types[last] == D2D_VERTEX_TYPE_NONE) + --last; + } + p0 = &figure->vertices[last]; + for (j = 0; j <= last; ++j) + { + if (!triangles_only && figure->vertex_types[j] == D2D_VERTEX_TYPE_NONE) + continue; + + p1 = &figure->vertices[j]; + d2d_point_subtract(&v_p, p1, p0); + d2d_point_subtract(&v_probe, probe, p0); + + if ((probe->y < p0->y) != (probe->y < p1->y) && v_probe.x < v_p.x * (v_probe.y / v_p.y)) + { + if (geometry->u.path.fill_mode == D2D1_FILL_MODE_ALTERNATE || (probe->y < p0->y)) + ++score; + else + --score; + } + + p0 = p1; + } + } + + return geometry->u.path.fill_mode == D2D1_FILL_MODE_ALTERNATE ? score & 1 : score; +} + +static BOOL d2d_path_geometry_add_fill_face(struct d2d_geometry *geometry, const struct d2d_cdt *cdt, + const struct d2d_cdt_edge_ref *base_edge) +{ + struct d2d_cdt_edge_ref tmp; + struct d2d_face *face; + D2D1_POINT_2F probe; + + if (cdt->edges[base_edge->idx].flags & D2D_CDT_EDGE_FLAG_VISITED(base_edge->r)) + return TRUE; + + if (!d2d_array_reserve((void **)&geometry->fill.faces, &geometry->fill.faces_size, + geometry->fill.face_count + 1, sizeof(*geometry->fill.faces))) + { + ERR("Failed to grow faces array.\n"); + return FALSE; + } + + face = &geometry->fill.faces[geometry->fill.face_count]; + + /* It may seem tempting to use the center of the face as probe origin, but + * multiplying by powers of two works much better for preserving accuracy. */ + + tmp = *base_edge; + cdt->edges[tmp.idx].flags |= D2D_CDT_EDGE_FLAG_VISITED(tmp.r); + face->v[0] = d2d_cdt_edge_origin(cdt, &tmp); + probe.x = cdt->vertices[d2d_cdt_edge_origin(cdt, &tmp)].x * 0.25f; + probe.y = cdt->vertices[d2d_cdt_edge_origin(cdt, &tmp)].y * 0.25f; + + d2d_cdt_edge_next_left(cdt, &tmp, &tmp); + cdt->edges[tmp.idx].flags |= D2D_CDT_EDGE_FLAG_VISITED(tmp.r); + face->v[1] = d2d_cdt_edge_origin(cdt, &tmp); + probe.x += cdt->vertices[d2d_cdt_edge_origin(cdt, &tmp)].x * 0.25f; + probe.y += cdt->vertices[d2d_cdt_edge_origin(cdt, &tmp)].y * 0.25f; + + d2d_cdt_edge_next_left(cdt, &tmp, &tmp); + cdt->edges[tmp.idx].flags |= D2D_CDT_EDGE_FLAG_VISITED(tmp.r); + face->v[2] = d2d_cdt_edge_origin(cdt, &tmp); + probe.x += cdt->vertices[d2d_cdt_edge_origin(cdt, &tmp)].x * 0.50f; + probe.y += cdt->vertices[d2d_cdt_edge_origin(cdt, &tmp)].y * 0.50f; + + if (d2d_cdt_leftof(cdt, face->v[2], base_edge) && d2d_path_geometry_point_inside(geometry, &probe, TRUE)) + ++geometry->fill.face_count; + + return TRUE; +} + +static BOOL d2d_cdt_generate_faces(const struct d2d_cdt *cdt, struct d2d_geometry *geometry) +{ + struct d2d_cdt_edge_ref base_edge; + size_t i; + + for (i = 0; i < cdt->edge_count; ++i) + { + if (cdt->edges[i].flags & D2D_CDT_EDGE_FLAG_FREED) + continue; + + base_edge.idx = i; + base_edge.r = 0; + if (!d2d_path_geometry_add_fill_face(geometry, cdt, &base_edge)) + goto fail; + d2d_cdt_edge_sym(&base_edge, &base_edge); + if (!d2d_path_geometry_add_fill_face(geometry, cdt, &base_edge)) + goto fail; + } + + return TRUE; + +fail: + free(geometry->fill.faces); + geometry->fill.faces = NULL; + geometry->fill.faces_size = 0; + geometry->fill.face_count = 0; + return FALSE; +} + +static BOOL d2d_cdt_fixup(struct d2d_cdt *cdt, const struct d2d_cdt_edge_ref *base_edge) +{ + struct d2d_cdt_edge_ref candidate, next, new_base; + unsigned int count = 0; + + d2d_cdt_edge_next_left(cdt, &next, base_edge); + if (next.idx == base_edge->idx) + { + ERR("Degenerate face.\n"); + return FALSE; + } + + candidate = next; + while (d2d_cdt_edge_destination(cdt, &next) != d2d_cdt_edge_origin(cdt, base_edge)) + { + if (d2d_cdt_incircle(cdt, d2d_cdt_edge_origin(cdt, base_edge), d2d_cdt_edge_destination(cdt, base_edge), + d2d_cdt_edge_destination(cdt, &candidate), d2d_cdt_edge_destination(cdt, &next))) + candidate = next; + d2d_cdt_edge_next_left(cdt, &next, &next); + ++count; + } + + if (count > 1) + { + d2d_cdt_edge_next_left(cdt, &next, &candidate); + if (d2d_cdt_edge_destination(cdt, &next) == d2d_cdt_edge_origin(cdt, base_edge)) + d2d_cdt_edge_next_left(cdt, &next, base_edge); + else + next = *base_edge; + if (!d2d_cdt_connect(cdt, &new_base, &candidate, &next)) + return FALSE; + if (!d2d_cdt_fixup(cdt, &new_base)) + return FALSE; + d2d_cdt_edge_sym(&new_base, &new_base); + if (!d2d_cdt_fixup(cdt, &new_base)) + return FALSE; + } + + return TRUE; +} + +static void d2d_cdt_cut_edges(struct d2d_cdt *cdt, struct d2d_cdt_edge_ref *end_edge, + const struct d2d_cdt_edge_ref *base_edge, size_t start_vertex, size_t end_vertex) +{ + struct d2d_cdt_edge_ref next; + float ccw; + + d2d_cdt_edge_next_left(cdt, &next, base_edge); + if (d2d_cdt_edge_destination(cdt, &next) == end_vertex) + { + *end_edge = next; + return; + } + + ccw = d2d_cdt_ccw(cdt, d2d_cdt_edge_destination(cdt, &next), end_vertex, start_vertex); + if (ccw == 0.0f) + { + *end_edge = next; + return; + } + + if (ccw > 0.0f) + d2d_cdt_edge_next_left(cdt, &next, &next); + + d2d_cdt_edge_sym(&next, &next); + d2d_cdt_cut_edges(cdt, end_edge, &next, start_vertex, end_vertex); + d2d_cdt_destroy_edge(cdt, &next); +} + +static BOOL d2d_cdt_insert_segment(struct d2d_cdt *cdt, struct d2d_geometry *geometry, + const struct d2d_cdt_edge_ref *origin, struct d2d_cdt_edge_ref *edge, size_t end_vertex) +{ + struct d2d_cdt_edge_ref base_edge, current, new_origin, next, target; + size_t current_destination, current_origin; + + for (current = *origin;; current = next) + { + d2d_cdt_edge_next_origin(cdt, &next, ¤t); + + current_destination = d2d_cdt_edge_destination(cdt, ¤t); + if (current_destination == end_vertex) + { + d2d_cdt_edge_sym(edge, ¤t); + return TRUE; + } + + current_origin = d2d_cdt_edge_origin(cdt, ¤t); + if (d2d_cdt_ccw(cdt, end_vertex, current_origin, current_destination) == 0.0f + && (cdt->vertices[current_destination].x > cdt->vertices[current_origin].x) + == (cdt->vertices[end_vertex].x > cdt->vertices[current_origin].x) + && (cdt->vertices[current_destination].y > cdt->vertices[current_origin].y) + == (cdt->vertices[end_vertex].y > cdt->vertices[current_origin].y)) + { + d2d_cdt_edge_sym(&new_origin, ¤t); + return d2d_cdt_insert_segment(cdt, geometry, &new_origin, edge, end_vertex); + } + + if (d2d_cdt_rightof(cdt, end_vertex, &next) && d2d_cdt_leftof(cdt, end_vertex, ¤t)) + { + d2d_cdt_edge_next_left(cdt, &base_edge, ¤t); + + d2d_cdt_edge_sym(&base_edge, &base_edge); + d2d_cdt_cut_edges(cdt, &target, &base_edge, d2d_cdt_edge_origin(cdt, origin), end_vertex); + d2d_cdt_destroy_edge(cdt, &base_edge); + + if (!d2d_cdt_connect(cdt, &base_edge, &target, ¤t)) + return FALSE; + *edge = base_edge; + if (!d2d_cdt_fixup(cdt, &base_edge)) + return FALSE; + d2d_cdt_edge_sym(&base_edge, &base_edge); + if (!d2d_cdt_fixup(cdt, &base_edge)) + return FALSE; + + if (d2d_cdt_edge_origin(cdt, edge) == end_vertex) + return TRUE; + new_origin = *edge; + return d2d_cdt_insert_segment(cdt, geometry, &new_origin, edge, end_vertex); + } + + if (next.idx == origin->idx) + { + ERR("Triangle not found.\n"); + return FALSE; + } + } +} + +static BOOL d2d_cdt_insert_segments(struct d2d_cdt *cdt, struct d2d_geometry *geometry) +{ + size_t start_vertex, end_vertex, i, j, k; + struct d2d_cdt_edge_ref edge, new_edge; + const struct d2d_figure *figure; + const D2D1_POINT_2F *p; + BOOL found; + + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + figure = &geometry->u.path.figures[i]; + + if (figure->flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + + /* Degenerate figure. */ + if (figure->vertex_count < 2) + continue; + + p = bsearch(&figure->vertices[figure->vertex_count - 1], cdt->vertices, + geometry->fill.vertex_count, sizeof(*p), d2d_cdt_compare_vertices); + start_vertex = p - cdt->vertices; + + for (k = 0, found = FALSE; k < cdt->edge_count; ++k) + { + if (cdt->edges[k].flags & D2D_CDT_EDGE_FLAG_FREED) + continue; + + edge.idx = k; + edge.r = 0; + + if (d2d_cdt_edge_origin(cdt, &edge) == start_vertex) + { + found = TRUE; + break; + } + d2d_cdt_edge_sym(&edge, &edge); + if (d2d_cdt_edge_origin(cdt, &edge) == start_vertex) + { + found = TRUE; + break; + } + } + + if (!found) + { + ERR("Edge not found.\n"); + return FALSE; + } + + for (j = 0; j < figure->vertex_count; start_vertex = end_vertex, ++j) + { + p = bsearch(&figure->vertices[j], cdt->vertices, + geometry->fill.vertex_count, sizeof(*p), d2d_cdt_compare_vertices); + end_vertex = p - cdt->vertices; + + if (start_vertex == end_vertex) + continue; + + if (!d2d_cdt_insert_segment(cdt, geometry, &edge, &new_edge, end_vertex)) + return FALSE; + edge = new_edge; + } + } + + return TRUE; +} + +static BOOL d2d_geometry_intersections_add(struct d2d_geometry_intersections *i, + const struct d2d_segment_idx *segment_idx, float t, D2D1_POINT_2F p) +{ + struct d2d_geometry_intersection *intersection; + + if (!d2d_array_reserve((void **)&i->intersections, &i->intersections_size, + i->intersection_count + 1, sizeof(*i->intersections))) + { + ERR("Failed to grow intersections array.\n"); + return FALSE; + } + + intersection = &i->intersections[i->intersection_count++]; + intersection->figure_idx = segment_idx->figure_idx; + intersection->vertex_idx = segment_idx->vertex_idx; + intersection->control_idx = segment_idx->control_idx; + intersection->t = t; + intersection->p = p; + + return TRUE; +} + +static int __cdecl d2d_geometry_intersections_compare(const void *a, const void *b) +{ + const struct d2d_geometry_intersection *i0 = a; + const struct d2d_geometry_intersection *i1 = b; + + if (i0->figure_idx != i1->figure_idx) + return i0->figure_idx - i1->figure_idx; + if (i0->vertex_idx != i1->vertex_idx) + return i0->vertex_idx - i1->vertex_idx; + if (i0->t != i1->t) + return i0->t > i1->t ? 1 : -1; + return 0; +} + +static BOOL d2d_geometry_intersect_line_line(struct d2d_geometry *geometry, + struct d2d_geometry_intersections *intersections, const struct d2d_segment_idx *idx_p, + const struct d2d_segment_idx *idx_q) +{ + D2D1_POINT_2F v_p, v_q, v_qp, intersection; + const D2D1_POINT_2F *p[2], *q[2]; + const struct d2d_figure *figure; + float s, t, det; + size_t next; + + figure = &geometry->u.path.figures[idx_p->figure_idx]; + p[0] = &figure->vertices[idx_p->vertex_idx]; + next = idx_p->vertex_idx + 1; + if (next == figure->vertex_count) + next = 0; + p[1] = &figure->vertices[next]; + + figure = &geometry->u.path.figures[idx_q->figure_idx]; + q[0] = &figure->vertices[idx_q->vertex_idx]; + next = idx_q->vertex_idx + 1; + if (next == figure->vertex_count) + next = 0; + q[1] = &figure->vertices[next]; + + d2d_point_subtract(&v_p, p[1], p[0]); + d2d_point_subtract(&v_q, q[1], q[0]); + d2d_point_subtract(&v_qp, p[0], q[0]); + + det = v_p.x * v_q.y - v_p.y * v_q.x; + if (det == 0.0f) + return TRUE; + + s = (v_q.x * v_qp.y - v_q.y * v_qp.x) / det; + t = (v_p.x * v_qp.y - v_p.y * v_qp.x) / det; + + if (s < 0.0f || s > 1.0f || t < 0.0f || t > 1.0f) + return TRUE; + + intersection.x = p[0]->x + v_p.x * s; + intersection.y = p[0]->y + v_p.y * s; + + if (s > 0.0f && s < 1.0f && !d2d_geometry_intersections_add(intersections, idx_p, s, intersection)) + return FALSE; + + if (t > 0.0f && t < 1.0f && !d2d_geometry_intersections_add(intersections, idx_q, t, intersection)) + return FALSE; + + return TRUE; +} + +static BOOL d2d_geometry_add_bezier_line_intersections(struct d2d_geometry *geometry, + struct d2d_geometry_intersections *intersections, const struct d2d_segment_idx *idx_p, + const D2D1_POINT_2F **p, const struct d2d_segment_idx *idx_q, const D2D1_POINT_2F **q, float s) +{ + D2D1_POINT_2F intersection; + float t; + + d2d_point_calculate_bezier(&intersection, p[0], p[1], p[2], s); + if (fabsf(q[1]->x - q[0]->x) > fabsf(q[1]->y - q[0]->y)) + t = (intersection.x - q[0]->x) / (q[1]->x - q[0]->x); + else + t = (intersection.y - q[0]->y) / (q[1]->y - q[0]->y); + if (t < 0.0f || t > 1.0f) + return TRUE; + + d2d_point_lerp(&intersection, q[0], q[1], t); + + if (s > 0.0f && s < 1.0f && !d2d_geometry_intersections_add(intersections, idx_p, s, intersection)) + return FALSE; + + if (t > 0.0f && t < 1.0f && !d2d_geometry_intersections_add(intersections, idx_q, t, intersection)) + return FALSE; + + return TRUE; +} + +static BOOL d2d_geometry_intersect_bezier_line(struct d2d_geometry *geometry, + struct d2d_geometry_intersections *intersections, + const struct d2d_segment_idx *idx_p, const struct d2d_segment_idx *idx_q) +{ + const D2D1_POINT_2F *p[3], *q[2]; + const struct d2d_figure *figure; + float y[3], root, theta, d, e; + size_t next; + + figure = &geometry->u.path.figures[idx_p->figure_idx]; + p[0] = &figure->vertices[idx_p->vertex_idx]; + p[1] = &figure->bezier_controls[idx_p->control_idx]; + next = idx_p->vertex_idx + 1; + p[2] = &figure->vertices[next]; + + figure = &geometry->u.path.figures[idx_q->figure_idx]; + q[0] = &figure->vertices[idx_q->vertex_idx]; + next = idx_q->vertex_idx + 1; + if (next == figure->vertex_count) + next = 0; + q[1] = &figure->vertices[next]; + + /* Align the line with x-axis. */ + theta = -atan2f(q[1]->y - q[0]->y, q[1]->x - q[0]->x); + y[0] = (p[0]->x - q[0]->x) * sinf(theta) + (p[0]->y - q[0]->y) * cosf(theta); + y[1] = (p[1]->x - q[0]->x) * sinf(theta) + (p[1]->y - q[0]->y) * cosf(theta); + y[2] = (p[2]->x - q[0]->x) * sinf(theta) + (p[2]->y - q[0]->y) * cosf(theta); + + /* Intersect the transformed curve with the x-axis. + * + * f(t) = (1 - t)²P₀ + 2(1 - t)tP₁ + t²P₂ + * = (P₀ - 2P₁ + P₂)t² + 2(P₁ - P₀)t + P₀ + * + * a = P₀ - 2P₁ + P₂ + * b = 2(P₁ - P₀) + * c = P₀ + * + * f(t) = 0 + * t = (-b ± √(b² - 4ac)) / 2a + * = (-2(P₁ - P₀) ± √((2(P₁ - P₀))² - 4((P₀ - 2P₁ + P₂)P₀))) / 2(P₀ - 2P₁ + P₂) + * = (2P₀ - 2P₁ ± √(4P₀² + 4P₁² - 8P₀P₁ - 4P₀² + 8P₀P₁ - 4P₀P₂)) / (2P₀ - 4P₁ + 2P₂) + * = (P₀ - P₁ ± √(P₁² - P₀P₂)) / (P₀ - 2P₁ + P₂) */ + + d = y[0] - 2 * y[1] + y[2]; + if (d == 0.0f) + { + /* P₀ - 2P₁ + P₂ = 0 + * f(t) = (P₀ - 2P₁ + P₂)t² + 2(P₁ - P₀)t + P₀ = 0 + * t = -P₀ / 2(P₁ - P₀) */ + root = -y[0] / (2.0f * (y[1] - y[0])); + if (root < 0.0f || root > 1.0f) + return TRUE; + + return d2d_geometry_add_bezier_line_intersections(geometry, intersections, idx_p, p, idx_q, q, root); + } + + e = y[1] * y[1] - y[0] * y[2]; + if (e < 0.0f) + return TRUE; + + root = (y[0] - y[1] + sqrtf(e)) / d; + if (root >= 0.0f && root <= 1.0f && !d2d_geometry_add_bezier_line_intersections(geometry, + intersections, idx_p, p, idx_q, q, root)) + return FALSE; + + root = (y[0] - y[1] - sqrtf(e)) / d; + if (root >= 0.0f && root <= 1.0f && !d2d_geometry_add_bezier_line_intersections(geometry, + intersections, idx_p, p, idx_q, q, root)) + return FALSE; + + return TRUE; +} + +static BOOL d2d_geometry_intersect_bezier_bezier(struct d2d_geometry *geometry, + struct d2d_geometry_intersections *intersections, + const struct d2d_segment_idx *idx_p, float start_p, float end_p, + const struct d2d_segment_idx *idx_q, float start_q, float end_q) +{ + const D2D1_POINT_2F *p[3], *q[3]; + const struct d2d_figure *figure; + D2D_RECT_F p_bounds, q_bounds; + D2D1_POINT_2F intersection; + float centre_p, centre_q; + size_t next; + + figure = &geometry->u.path.figures[idx_p->figure_idx]; + p[0] = &figure->vertices[idx_p->vertex_idx]; + p[1] = &figure->bezier_controls[idx_p->control_idx]; + next = idx_p->vertex_idx + 1; + p[2] = &figure->vertices[next]; + + figure = &geometry->u.path.figures[idx_q->figure_idx]; + q[0] = &figure->vertices[idx_q->vertex_idx]; + q[1] = &figure->bezier_controls[idx_q->control_idx]; + next = idx_q->vertex_idx + 1; + q[2] = &figure->vertices[next]; + + d2d_rect_get_bezier_segment_bounds(&p_bounds, p[0], p[1], p[2], start_p, end_p); + d2d_rect_get_bezier_segment_bounds(&q_bounds, q[0], q[1], q[2], start_q, end_q); + + if (!d2d_rect_check_overlap(&p_bounds, &q_bounds)) + return TRUE; + + centre_p = (start_p + end_p) / 2.0f; + centre_q = (start_q + end_q) / 2.0f; + + if (end_p - start_p < 1e-3f) + { + d2d_point_calculate_bezier(&intersection, p[0], p[1], p[2], centre_p); + if (start_p > 0.0f && end_p < 1.0f && !d2d_geometry_intersections_add(intersections, + idx_p, centre_p, intersection)) + return FALSE; + if (start_q > 0.0f && end_q < 1.0f && !d2d_geometry_intersections_add(intersections, + idx_q, centre_q, intersection)) + return FALSE; + return TRUE; + } + + if (!d2d_geometry_intersect_bezier_bezier(geometry, intersections, + idx_p, start_p, centre_p, idx_q, start_q, centre_q)) + return FALSE; + if (!d2d_geometry_intersect_bezier_bezier(geometry, intersections, + idx_p, start_p, centre_p, idx_q, centre_q, end_q)) + return FALSE; + if (!d2d_geometry_intersect_bezier_bezier(geometry, intersections, + idx_p, centre_p, end_p, idx_q, start_q, centre_q)) + return FALSE; + if (!d2d_geometry_intersect_bezier_bezier(geometry, intersections, + idx_p, centre_p, end_p, idx_q, centre_q, end_q)) + return FALSE; + + return TRUE; +} + +static BOOL d2d_geometry_apply_intersections(struct d2d_geometry *geometry, + struct d2d_geometry_intersections *intersections) +{ + size_t vertex_offset, control_offset, next, i; + struct d2d_geometry_intersection *inter; + enum d2d_vertex_type vertex_type; + const D2D1_POINT_2F *p[3]; + struct d2d_figure *figure; + D2D1_POINT_2F q[2]; + float t, t_prev; + + for (i = 0; i < intersections->intersection_count; ++i) + { + inter = &intersections->intersections[i]; + if (!i || inter->figure_idx != intersections->intersections[i - 1].figure_idx) + vertex_offset = control_offset = 0; + + figure = &geometry->u.path.figures[inter->figure_idx]; + vertex_type = figure->vertex_types[inter->vertex_idx + vertex_offset]; + if (!d2d_vertex_type_is_bezier(vertex_type)) + { + if (!d2d_figure_insert_vertex(&geometry->u.path.figures[inter->figure_idx], + inter->vertex_idx + vertex_offset + 1, inter->p)) + return FALSE; + ++vertex_offset; + continue; + } + + t = inter->t; + if (i && inter->figure_idx == intersections->intersections[i - 1].figure_idx + && inter->vertex_idx == intersections->intersections[i - 1].vertex_idx) + { + t_prev = intersections->intersections[i - 1].t; + if (t - t_prev < 1e-3f) + { + inter->t = intersections->intersections[i - 1].t; + continue; + } + t = (t - t_prev) / (1.0f - t_prev); + } + + p[0] = &figure->vertices[inter->vertex_idx + vertex_offset]; + p[1] = &figure->bezier_controls[inter->control_idx + control_offset]; + next = inter->vertex_idx + vertex_offset + 1; + p[2] = &figure->vertices[next]; + + d2d_point_lerp(&q[0], p[0], p[1], t); + d2d_point_lerp(&q[1], p[1], p[2], t); + + figure->bezier_controls[inter->control_idx + control_offset] = q[0]; + if (!(d2d_figure_insert_bezier_controls(figure, inter->control_idx + control_offset + 1, 1, &q[1]))) + return FALSE; + ++control_offset; + + if (!(d2d_figure_insert_vertex(figure, inter->vertex_idx + vertex_offset + 1, inter->p))) + return FALSE; + figure->vertex_types[inter->vertex_idx + vertex_offset + 1] = D2D_VERTEX_TYPE_SPLIT_BEZIER; + ++vertex_offset; + } + + return TRUE; +} + +/* Intersect the geometry's segments with themselves. This uses the + * straightforward approach of testing everything against everything, but + * there certainly exist more scalable algorithms for this. */ +static BOOL d2d_geometry_intersect_self(struct d2d_geometry *geometry) +{ + struct d2d_geometry_intersections intersections = {0}; + const struct d2d_figure *figure_p, *figure_q; + struct d2d_segment_idx idx_p, idx_q; + enum d2d_vertex_type type_p, type_q; + BOOL ret = FALSE; + size_t max_q; + + if (!geometry->u.path.figure_count) + return TRUE; + + for (idx_p.figure_idx = 0; idx_p.figure_idx < geometry->u.path.figure_count; ++idx_p.figure_idx) + { + figure_p = &geometry->u.path.figures[idx_p.figure_idx]; + idx_p.control_idx = 0; + for (idx_p.vertex_idx = 0; idx_p.vertex_idx < figure_p->vertex_count; ++idx_p.vertex_idx) + { + if ((type_p = figure_p->vertex_types[idx_p.vertex_idx]) == D2D_VERTEX_TYPE_END) + continue; + + for (idx_q.figure_idx = 0; idx_q.figure_idx <= idx_p.figure_idx; ++idx_q.figure_idx) + { + figure_q = &geometry->u.path.figures[idx_q.figure_idx]; + if (idx_q.figure_idx != idx_p.figure_idx) + { + if (!d2d_rect_check_overlap(&figure_p->bounds, &figure_q->bounds)) + continue; + if ((max_q = figure_q->vertex_count) + && figure_q->vertex_types[max_q - 1] == D2D_VERTEX_TYPE_END) + --max_q; + } + else + { + max_q = idx_p.vertex_idx; + } + + idx_q.control_idx = 0; + for (idx_q.vertex_idx = 0; idx_q.vertex_idx < max_q; ++idx_q.vertex_idx) + { + type_q = figure_q->vertex_types[idx_q.vertex_idx]; + if (d2d_vertex_type_is_bezier(type_q)) + { + if (d2d_vertex_type_is_bezier(type_p)) + { + if (!d2d_geometry_intersect_bezier_bezier(geometry, &intersections, + &idx_p, 0.0f, 1.0f, &idx_q, 0.0f, 1.0f)) + goto done; + } + else + { + if (!d2d_geometry_intersect_bezier_line(geometry, &intersections, &idx_q, &idx_p)) + goto done; + } + ++idx_q.control_idx; + } + else + { + if (d2d_vertex_type_is_bezier(type_p)) + { + if (!d2d_geometry_intersect_bezier_line(geometry, &intersections, &idx_p, &idx_q)) + goto done; + } + else + { + if (!d2d_geometry_intersect_line_line(geometry, &intersections, &idx_p, &idx_q)) + goto done; + } + } + } + } + if (d2d_vertex_type_is_bezier(type_p)) + ++idx_p.control_idx; + } + } + + qsort(intersections.intersections, intersections.intersection_count, + sizeof(*intersections.intersections), d2d_geometry_intersections_compare); + ret = d2d_geometry_apply_intersections(geometry, &intersections); + +done: + free(intersections.intersections); + return ret; +} + +static HRESULT d2d_path_geometry_triangulate(struct d2d_geometry *geometry) +{ + struct d2d_cdt_edge_ref left_edge, right_edge; + size_t vertex_count, i, j; + struct d2d_cdt cdt = {0}; + D2D1_POINT_2F *vertices; +#ifdef __i386__ + unsigned int control_word_x87, mask = 0; +#endif + + for (i = 0, vertex_count = 0; i < geometry->u.path.figure_count; ++i) + { + if (geometry->u.path.figures[i].flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + vertex_count += geometry->u.path.figures[i].vertex_count; + } + + if (vertex_count < 3) + { + WARN("Geometry has %lu vertices.\n", (long)vertex_count); + return S_OK; + } + + if (!(vertices = calloc(vertex_count, sizeof(*vertices)))) + return E_OUTOFMEMORY; + + for (i = 0, j = 0; i < geometry->u.path.figure_count; ++i) + { + if (geometry->u.path.figures[i].flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + memcpy(&vertices[j], geometry->u.path.figures[i].vertices, + geometry->u.path.figures[i].vertex_count * sizeof(*vertices)); + j += geometry->u.path.figures[i].vertex_count; + } + + /* Sort vertices, eliminate duplicates. */ + qsort(vertices, vertex_count, sizeof(*vertices), d2d_cdt_compare_vertices); + for (i = 1; i < vertex_count; ++i) + { + if (!memcmp(&vertices[i - 1], &vertices[i], sizeof(*vertices))) + { + --vertex_count; + memmove(&vertices[i], &vertices[i + 1], (vertex_count - i) * sizeof(*vertices)); + --i; + } + } + + if (vertex_count < 3) + { + WARN("Geometry has %lu vertices after eliminating duplicates.\n", (long)vertex_count); + free(vertices); + return S_OK; + } + + geometry->fill.vertices = vertices; + geometry->fill.vertex_count = vertex_count; + + cdt.free_edge = ~0u; + cdt.vertices = vertices; + +#ifdef __i386__ + control_word_x87 = _controlfp(0, 0); + _controlfp(_PC_24, mask = _MCW_PC); +#endif + if (!d2d_cdt_triangulate(&cdt, 0, vertex_count, &left_edge, &right_edge)) + goto fail; + if (!d2d_cdt_insert_segments(&cdt, geometry)) + goto fail; +#ifdef __i386__ + _controlfp(control_word_x87, _MCW_PC); + mask = 0; +#endif + + if (!d2d_cdt_generate_faces(&cdt, geometry)) + goto fail; + + free(cdt.edges); + return S_OK; + +fail: + geometry->fill.vertices = NULL; + geometry->fill.vertex_count = 0; + free(vertices); + free(cdt.edges); +#ifdef __i386__ + if (mask) _controlfp(control_word_x87, mask); +#endif + return E_FAIL; +} + +static BOOL d2d_path_geometry_add_figure(struct d2d_geometry *geometry) +{ + struct d2d_figure *figure; + + if (!d2d_array_reserve((void **)&geometry->u.path.figures, &geometry->u.path.figures_size, + geometry->u.path.figure_count + 1, sizeof(*geometry->u.path.figures))) + { + ERR("Failed to grow figures array.\n"); + return FALSE; + } + + figure = &geometry->u.path.figures[geometry->u.path.figure_count]; + memset(figure, 0, sizeof(*figure)); + figure->bounds.left = FLT_MAX; + figure->bounds.top = FLT_MAX; + figure->bounds.right = -FLT_MAX; + figure->bounds.bottom = -FLT_MAX; + + ++geometry->u.path.figure_count; + return TRUE; +} + +static BOOL d2d_geometry_outline_add_join(struct d2d_geometry *geometry, + const D2D1_POINT_2F *prev, const D2D1_POINT_2F *p0, const D2D1_POINT_2F *next) +{ + static const D2D1_POINT_2F origin = {0.0f, 0.0f}; + struct d2d_outline_vertex *v; + struct d2d_face *f; + size_t base_idx; + float ccw; + + if (!d2d_array_reserve((void **)&geometry->outline.vertices, &geometry->outline.vertices_size, + geometry->outline.vertex_count + 4, sizeof(*geometry->outline.vertices))) + { + ERR("Failed to grow outline vertices array.\n"); + return FALSE; + } + base_idx = geometry->outline.vertex_count; + v = &geometry->outline.vertices[base_idx]; + + if (!d2d_array_reserve((void **)&geometry->outline.faces, &geometry->outline.faces_size, + geometry->outline.face_count + 2, sizeof(*geometry->outline.faces))) + { + ERR("Failed to grow outline faces array.\n"); + return FALSE; + } + f = &geometry->outline.faces[geometry->outline.face_count]; + + ccw = d2d_point_ccw(&origin, prev, next); + if (ccw == 0.0f) + { + d2d_outline_vertex_set(&v[0], p0->x, p0->y, -prev->x, -prev->y, -prev->x, -prev->y); + d2d_outline_vertex_set(&v[1], p0->x, p0->y, prev->x, prev->y, prev->x, prev->y); + d2d_outline_vertex_set(&v[2], p0->x + 25.0f * -prev->x, p0->y + 25.0f * -prev->y, + prev->x, prev->y, prev->x, prev->y); + d2d_outline_vertex_set(&v[3], p0->x + 25.0f * -prev->x, p0->y + 25.0f * -prev->y, + -prev->x, -prev->y, -prev->x, -prev->y); + } + else if (ccw < 0.0f) + { + d2d_outline_vertex_set(&v[0], p0->x, p0->y, next->x, next->y, -prev->x, -prev->y); + d2d_outline_vertex_set(&v[1], p0->x, p0->y, -next->x, -next->y, -next->x, -next->y); + d2d_outline_vertex_set(&v[2], p0->x, p0->y, -next->x, -next->y, prev->x, prev->y); + d2d_outline_vertex_set(&v[3], p0->x, p0->y, prev->x, prev->y, prev->x, prev->y); + } + else + { + d2d_outline_vertex_set(&v[0], p0->x, p0->y, prev->x, prev->y, -next->x, -next->y); + d2d_outline_vertex_set(&v[1], p0->x, p0->y, -prev->x, -prev->y, -prev->x, -prev->y); + d2d_outline_vertex_set(&v[2], p0->x, p0->y, -prev->x, -prev->y, next->x, next->y); + d2d_outline_vertex_set(&v[3], p0->x, p0->y, next->x, next->y, next->x, next->y); + } + geometry->outline.vertex_count += 4; + + d2d_face_set(&f[0], base_idx + 1, base_idx + 0, base_idx + 2); + d2d_face_set(&f[1], base_idx + 2, base_idx + 0, base_idx + 3); + geometry->outline.face_count += 2; + + return TRUE; +} + +static BOOL d2d_geometry_outline_add_line_segment(struct d2d_geometry *geometry, + const D2D1_POINT_2F *p0, const D2D1_POINT_2F *next) +{ + struct d2d_outline_vertex *v; + D2D1_POINT_2F q_next; + struct d2d_face *f; + size_t base_idx; + + if (!d2d_array_reserve((void **)&geometry->outline.vertices, &geometry->outline.vertices_size, + geometry->outline.vertex_count + 4, sizeof(*geometry->outline.vertices))) + { + ERR("Failed to grow outline vertices array.\n"); + return FALSE; + } + base_idx = geometry->outline.vertex_count; + v = &geometry->outline.vertices[base_idx]; + + if (!d2d_array_reserve((void **)&geometry->outline.faces, &geometry->outline.faces_size, + geometry->outline.face_count + 2, sizeof(*geometry->outline.faces))) + { + ERR("Failed to grow outline faces array.\n"); + return FALSE; + } + f = &geometry->outline.faces[geometry->outline.face_count]; + + d2d_point_subtract(&q_next, next, p0); + d2d_point_normalise(&q_next); + + d2d_outline_vertex_set(&v[0], p0->x, p0->y, q_next.x, q_next.y, q_next.x, q_next.y); + d2d_outline_vertex_set(&v[1], p0->x, p0->y, -q_next.x, -q_next.y, -q_next.x, -q_next.y); + d2d_outline_vertex_set(&v[2], next->x, next->y, q_next.x, q_next.y, q_next.x, q_next.y); + d2d_outline_vertex_set(&v[3], next->x, next->y, -q_next.x, -q_next.y, -q_next.x, -q_next.y); + geometry->outline.vertex_count += 4; + + d2d_face_set(&f[0], base_idx + 0, base_idx + 1, base_idx + 2); + d2d_face_set(&f[1], base_idx + 2, base_idx + 1, base_idx + 3); + geometry->outline.face_count += 2; + + return TRUE; +} + +static BOOL d2d_geometry_outline_add_bezier_segment(struct d2d_geometry *geometry, + const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2) +{ + struct d2d_curve_outline_vertex *b; + D2D1_POINT_2F r0, r1, r2; + D2D1_POINT_2F q0, q1, q2; + struct d2d_face *f; + size_t base_idx; + + if (!d2d_array_reserve((void **)&geometry->outline.beziers, &geometry->outline.beziers_size, + geometry->outline.bezier_count + 7, sizeof(*geometry->outline.beziers))) + { + ERR("Failed to grow outline beziers array.\n"); + return FALSE; + } + base_idx = geometry->outline.bezier_count; + b = &geometry->outline.beziers[base_idx]; + + if (!d2d_array_reserve((void **)&geometry->outline.bezier_faces, &geometry->outline.bezier_faces_size, + geometry->outline.bezier_face_count + 5, sizeof(*geometry->outline.bezier_faces))) + { + ERR("Failed to grow outline faces array.\n"); + return FALSE; + } + f = &geometry->outline.bezier_faces[geometry->outline.bezier_face_count]; + + d2d_point_lerp(&q0, p0, p1, 0.5f); + d2d_point_lerp(&q1, p1, p2, 0.5f); + d2d_point_lerp(&q2, &q0, &q1, 0.5f); + + d2d_point_subtract(&r0, &q0, p0); + d2d_point_subtract(&r1, &q1, &q0); + d2d_point_subtract(&r2, p2, &q1); + + d2d_point_normalise(&r0); + d2d_point_normalise(&r1); + d2d_point_normalise(&r2); + + if (d2d_point_ccw(p0, p1, p2) > 0.0f) + { + d2d_point_scale(&r0, -1.0f); + d2d_point_scale(&r1, -1.0f); + d2d_point_scale(&r2, -1.0f); + } + + d2d_curve_outline_vertex_set(&b[0], p0, p0, p1, p2, r0.x, r0.y, r0.x, r0.y); + d2d_curve_outline_vertex_set(&b[1], p0, p0, p1, p2, -r0.x, -r0.y, -r0.x, -r0.y); + d2d_curve_outline_vertex_set(&b[2], &q0, p0, p1, p2, r0.x, r0.y, r1.x, r1.y); + d2d_curve_outline_vertex_set(&b[3], &q2, p0, p1, p2, -r1.x, -r1.y, -r1.x, -r1.y); + d2d_curve_outline_vertex_set(&b[4], &q1, p0, p1, p2, r1.x, r1.y, r2.x, r2.y); + d2d_curve_outline_vertex_set(&b[5], p2, p0, p1, p2, -r2.x, -r2.y, -r2.x, -r2.y); + d2d_curve_outline_vertex_set(&b[6], p2, p0, p1, p2, r2.x, r2.y, r2.x, r2.y); + geometry->outline.bezier_count += 7; + + d2d_face_set(&f[0], base_idx + 0, base_idx + 1, base_idx + 2); + d2d_face_set(&f[1], base_idx + 2, base_idx + 1, base_idx + 3); + d2d_face_set(&f[2], base_idx + 3, base_idx + 4, base_idx + 2); + d2d_face_set(&f[3], base_idx + 5, base_idx + 4, base_idx + 3); + d2d_face_set(&f[4], base_idx + 5, base_idx + 6, base_idx + 4); + geometry->outline.bezier_face_count += 5; + + return TRUE; +} + +static BOOL d2d_geometry_outline_add_arc_quadrant(struct d2d_geometry *geometry, + const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2) +{ + struct d2d_curve_outline_vertex *a; + D2D1_POINT_2F r0, r1; + struct d2d_face *f; + size_t base_idx; + + if (!d2d_array_reserve((void **)&geometry->outline.arcs, &geometry->outline.arcs_size, + geometry->outline.arc_count + 5, sizeof(*geometry->outline.arcs))) + { + ERR("Failed to grow outline arcs array.\n"); + return FALSE; + } + base_idx = geometry->outline.arc_count; + a = &geometry->outline.arcs[base_idx]; + + if (!d2d_array_reserve((void **)&geometry->outline.arc_faces, &geometry->outline.arc_faces_size, + geometry->outline.arc_face_count + 3, sizeof(*geometry->outline.arc_faces))) + { + ERR("Failed to grow outline faces array.\n"); + return FALSE; + } + f = &geometry->outline.arc_faces[geometry->outline.arc_face_count]; + + d2d_point_subtract(&r0, p1, p0); + d2d_point_subtract(&r1, p2, p1); + + d2d_point_normalise(&r0); + d2d_point_normalise(&r1); + + if (d2d_point_ccw(p0, p1, p2) > 0.0f) + { + d2d_point_scale(&r0, -1.0f); + d2d_point_scale(&r1, -1.0f); + } + + d2d_curve_outline_vertex_set(&a[0], p0, p0, p1, p2, r0.x, r0.y, r0.x, r0.y); + d2d_curve_outline_vertex_set(&a[1], p0, p0, p1, p2, -r0.x, -r0.y, -r0.x, -r0.y); + d2d_curve_outline_vertex_set(&a[2], p1, p0, p1, p2, r0.x, r0.y, r1.x, r1.y); + d2d_curve_outline_vertex_set(&a[3], p2, p0, p1, p2, -r1.x, -r1.y, -r1.x, -r1.y); + d2d_curve_outline_vertex_set(&a[4], p2, p0, p1, p2, r1.x, r1.y, r1.x, r1.y); + geometry->outline.arc_count += 5; + + d2d_face_set(&f[0], base_idx + 0, base_idx + 1, base_idx + 2); + d2d_face_set(&f[1], base_idx + 2, base_idx + 1, base_idx + 3); + d2d_face_set(&f[2], base_idx + 2, base_idx + 4, base_idx + 3); + geometry->outline.arc_face_count += 3; + + return TRUE; +} + +static BOOL d2d_geometry_add_figure_outline(struct d2d_geometry *geometry, + struct d2d_figure *figure, D2D1_FIGURE_END figure_end) +{ + const D2D1_POINT_2F *prev, *p0, *p1, *next, *next_prev; + size_t bezier_idx, i, vertex_count; + enum d2d_vertex_type type; + + if (!(vertex_count = figure->vertex_count)) + return TRUE; + + p0 = &figure->vertices[0]; + if (figure_end == D2D1_FIGURE_END_CLOSED) + { + if (figure->vertex_types[vertex_count - 1] == D2D_VERTEX_TYPE_END && !--vertex_count) + return TRUE; + + /* In case of a CLOSED path, a join between first and last vertex is + * required. */ + if (d2d_vertex_type_is_bezier(figure->vertex_types[vertex_count - 1])) + prev = &figure->bezier_controls[figure->bezier_control_count - 1]; + else + prev = &figure->vertices[vertex_count - 1]; + } + else + { + if (!--vertex_count) + return TRUE; + prev = p0; + } + + for (i = 0, bezier_idx = 0; i < vertex_count; ++i) + { + if ((type = figure->vertex_types[i]) == D2D_VERTEX_TYPE_NONE) + { + prev = next_prev = &figure->vertices[i]; + continue; + } + + /* next: tangent along next segment, at p0. + * p1: next vertex. */ + if (d2d_vertex_type_is_bezier(type)) + { + next_prev = next = &figure->bezier_controls[bezier_idx++]; + /* type BEZIER implies i + 1 < figure->vertex_count. */ + p1 = &figure->vertices[i + 1]; + + if (!d2d_geometry_outline_add_bezier_segment(geometry, p0, next, p1)) + { + ERR("Failed to add bezier segment.\n"); + return FALSE; + } + } + else + { + if (i + 1 == figure->vertex_count) + next = p1 = &figure->vertices[0]; + else + next = p1 = &figure->vertices[i + 1]; + next_prev = p0; + + if (!d2d_geometry_outline_add_line_segment(geometry, p0, p1)) + { + ERR("Failed to add line segment.\n"); + return FALSE; + } + } + + if (i || figure_end == D2D1_FIGURE_END_CLOSED) + { + D2D1_POINT_2F q_next, q_prev; + + d2d_point_subtract(&q_prev, prev, p0); + d2d_point_subtract(&q_next, next, p0); + + d2d_point_normalise(&q_prev); + d2d_point_normalise(&q_next); + + if (!d2d_geometry_outline_add_join(geometry, &q_prev, p0, &q_next)) + { + ERR("Failed to add join.\n"); + return FALSE; + } + } + + p0 = p1; + prev = next_prev; + } + + return TRUE; +} + +static BOOL d2d_geometry_fill_add_arc_triangle(struct d2d_geometry *geometry, + const D2D1_POINT_2F *p0, const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2) +{ + struct d2d_curve_vertex *a; + + if (!d2d_array_reserve((void **)&geometry->fill.arc_vertices, &geometry->fill.arc_vertices_size, + geometry->fill.arc_vertex_count + 3, sizeof(*geometry->fill.arc_vertices))) + return FALSE; + + a = &geometry->fill.arc_vertices[geometry->fill.arc_vertex_count]; + d2d_curve_vertex_set(&a[0], p0, 0.0f, 1.0f, -1.0f); + d2d_curve_vertex_set(&a[1], p1, 1.0f, 1.0f, -1.0f); + d2d_curve_vertex_set(&a[2], p2, 1.0f, 0.0f, -1.0f); + geometry->fill.arc_vertex_count += 3; + + return TRUE; +} + +static void d2d_geometry_cleanup(struct d2d_geometry *geometry) +{ + free(geometry->outline.arc_faces); + free(geometry->outline.arcs); + free(geometry->outline.bezier_faces); + free(geometry->outline.beziers); + free(geometry->outline.faces); + free(geometry->outline.vertices); + free(geometry->fill.arc_vertices); + free(geometry->fill.bezier_vertices); + free(geometry->fill.faces); + free(geometry->fill.vertices); + ID2D1Factory_Release(geometry->factory); +} + +static void d2d_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory, + const D2D1_MATRIX_3X2_F *transform, const struct ID2D1GeometryVtbl *vtbl) +{ + geometry->ID2D1Geometry_iface.lpVtbl = vtbl; + geometry->refcount = 1; + ID2D1Factory_AddRef(geometry->factory = factory); + geometry->transform = *transform; +} + +static inline struct d2d_geometry *impl_from_ID2D1GeometrySink(ID2D1GeometrySink *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, u.path.ID2D1GeometrySink_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_QueryInterface(ID2D1GeometrySink *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1GeometrySink) + || IsEqualGUID(iid, &IID_ID2D1SimplifiedGeometrySink) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1GeometrySink_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_geometry_sink_AddRef(ID2D1GeometrySink *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1Geometry_AddRef(&geometry->ID2D1Geometry_iface); +} + +static ULONG STDMETHODCALLTYPE d2d_geometry_sink_Release(ID2D1GeometrySink *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1Geometry_Release(&geometry->ID2D1Geometry_iface); +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_SetFillMode(ID2D1GeometrySink *iface, D2D1_FILL_MODE mode) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + if (geometry->u.path.state == D2D_GEOMETRY_STATE_CLOSED) + return; + geometry->u.path.fill_mode = mode; +} + +static void d2d_geometry_set_error(struct d2d_geometry *geometry, HRESULT code) +{ + if (geometry->u.path.state == D2D_GEOMETRY_STATE_ERROR) + return; + + geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR; + geometry->u.path.code = code; +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_SetSegmentFlags(ID2D1GeometrySink *iface, D2D1_PATH_SEGMENT flags) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + + TRACE("iface %p, flags %#x.\n", iface, flags); + + if (flags & ~(D2D1_PATH_SEGMENT_FORCE_UNSTROKED | D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN)) + { + d2d_geometry_set_error(geometry, E_INVALIDARG); + return; + } + + if (flags != D2D1_PATH_SEGMENT_NONE) + FIXME("Ignoring flags %#x.\n", flags); +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *iface, + D2D1_POINT_2F start_point, D2D1_FIGURE_BEGIN figure_begin) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + struct d2d_figure *figure; + + TRACE("iface %p, start_point %s, figure_begin %#x.\n", + iface, debug_d2d_point_2f(&start_point), figure_begin); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_OPEN) + { + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + return; + } + + if (!d2d_path_geometry_add_figure(geometry)) + { + ERR("Failed to add figure.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1]; + if (!d2d_figure_begin(figure, start_point, figure_begin)) + { + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + geometry->u.path.state = D2D_GEOMETRY_STATE_FIGURE; +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddLines(ID2D1GeometrySink *iface, + const D2D1_POINT_2F *points, UINT32 count) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + struct d2d_figure *figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1]; + + TRACE("iface %p, points %p, count %u.\n", iface, points, count); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE) + { + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + return; + } + + if (!d2d_figure_add_lines(figure, points, count)) + { + ERR("Failed to add vertex.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + geometry->u.path.segment_count += count; +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddBeziers(ID2D1GeometrySink *iface, + const D2D1_BEZIER_SEGMENT *beziers, UINT32 count) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + struct d2d_figure *figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1]; + + TRACE("iface %p, beziers %p, count %u.\n", iface, beziers, count); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE) + { + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + return; + } + + if (!d2d_figure_add_beziers(figure, beziers, count)) + { + ERR("Failed to add Bézier curves.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + geometry->u.path.segment_count += count; +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_EndFigure(ID2D1GeometrySink *iface, D2D1_FIGURE_END figure_end) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + struct d2d_figure *figure; + + TRACE("iface %p, figure_end %#x.\n", iface, figure_end); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE) + { + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + return; + } + + figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1]; + d2d_figure_end(figure, figure_end); + + if (figure_end == D2D1_FIGURE_END_CLOSED) + ++geometry->u.path.segment_count; + + if (!d2d_geometry_add_figure_outline(geometry, figure, figure_end)) + { + ERR("Failed to add figure outline.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + geometry->u.path.state = D2D_GEOMETRY_STATE_OPEN; +} + +static void d2d_path_geometry_free_figures(struct d2d_geometry *geometry) +{ + size_t i; + + if (!geometry->u.path.figures) + return; + + for (i = 0; i < geometry->u.path.figure_count; ++i) + d2d_figure_cleanup(&geometry->u.path.figures[i]); + + free(geometry->u.path.figures); + geometry->u.path.figures = NULL; + geometry->u.path.figures_size = 0; +} + +static BOOL d2d_geometry_get_bezier_segment_idx(struct d2d_geometry *geometry, struct d2d_segment_idx *idx, BOOL next) +{ + if (next) + { + ++idx->vertex_idx; + ++idx->control_idx; + } + + for (; idx->figure_idx < geometry->u.path.figure_count; ++idx->figure_idx, idx->vertex_idx = idx->control_idx = 0) + { + struct d2d_figure *figure = &geometry->u.path.figures[idx->figure_idx]; + + if (!figure->bezier_control_count || figure->flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + + for (; idx->vertex_idx < figure->vertex_count; ++idx->vertex_idx) + { + if (d2d_vertex_type_is_bezier(figure->vertex_types[idx->vertex_idx])) + return TRUE; + } + } + + return FALSE; +} + +static BOOL d2d_geometry_get_first_bezier_segment_idx(struct d2d_geometry *geometry, struct d2d_segment_idx *idx) +{ + memset(idx, 0, sizeof(*idx)); + + return d2d_geometry_get_bezier_segment_idx(geometry, idx, FALSE); +} + +static BOOL d2d_geometry_get_next_bezier_segment_idx(struct d2d_geometry *geometry, struct d2d_segment_idx *idx) +{ + return d2d_geometry_get_bezier_segment_idx(geometry, idx, TRUE); +} + +static BOOL d2d_geometry_check_bezier_overlap(struct d2d_geometry *geometry, + const struct d2d_segment_idx *idx_p, const struct d2d_segment_idx *idx_q) +{ + const D2D1_POINT_2F *a[3], *b[3], *p[2], *q; + const struct d2d_figure *figure; + D2D1_POINT_2F v_q[3], v_p, v_qp; + unsigned int i, j, score; + float det, t; + + figure = &geometry->u.path.figures[idx_p->figure_idx]; + a[0] = &figure->vertices[idx_p->vertex_idx]; + a[1] = &figure->bezier_controls[idx_p->control_idx]; + a[2] = &figure->vertices[idx_p->vertex_idx + 1]; + + figure = &geometry->u.path.figures[idx_q->figure_idx]; + b[0] = &figure->vertices[idx_q->vertex_idx]; + b[1] = &figure->bezier_controls[idx_q->control_idx]; + b[2] = &figure->vertices[idx_q->vertex_idx + 1]; + + if (d2d_point_ccw(a[0], a[1], a[2]) == 0.0f || d2d_point_ccw(b[0], b[1], b[2]) == 0.0f) + return FALSE; + + d2d_point_subtract(&v_q[0], b[1], b[0]); + d2d_point_subtract(&v_q[1], b[2], b[0]); + d2d_point_subtract(&v_q[2], b[1], b[2]); + + /* Check for intersections between the edges. Strictly speaking we'd only + * need to check 8 of the 9 possible intersections, since if there's any + * intersection there has to be a second intersection as well. */ + for (i = 0; i < 3; ++i) + { + d2d_point_subtract(&v_p, a[(i & 1) + 1], a[i & 2]); + for (j = 0; j < 3; ++j) + { + det = v_p.x * v_q[j].y - v_p.y * v_q[j].x; + if (det == 0.0f) + continue; + + d2d_point_subtract(&v_qp, a[i & 2], b[j & 2]); + t = (v_q[j].x * v_qp.y - v_q[j].y * v_qp.x) / det; + if (t <= 0.0f || t >= 1.0f) + continue; + + t = (v_p.x * v_qp.y - v_p.y * v_qp.x) / det; + if (t <= 0.0f || t >= 1.0f) + continue; + + return TRUE; + } + } + + /* Check if one triangle is contained within the other. */ + for (j = 0, score = 0, q = a[1], p[0] = b[2]; j < 3; ++j) + { + p[1] = b[j]; + d2d_point_subtract(&v_p, p[1], p[0]); + d2d_point_subtract(&v_qp, q, p[0]); + + if ((q->y < p[0]->y) != (q->y < p[1]->y) && v_qp.x < v_p.x * (v_qp.y / v_p.y)) + ++score; + + p[0] = p[1]; + } + + if (score & 1) + return TRUE; + + for (j = 0, score = 0, q = b[1], p[0] = a[2]; j < 3; ++j) + { + p[1] = a[j]; + d2d_point_subtract(&v_p, p[1], p[0]); + d2d_point_subtract(&v_qp, q, p[0]); + + if ((q->y < p[0]->y) != (q->y < p[1]->y) && v_qp.x < v_p.x * (v_qp.y / v_p.y)) + ++score; + + p[0] = p[1]; + } + + return score & 1; +} + +static float d2d_geometry_bezier_ccw(struct d2d_geometry *geometry, const struct d2d_segment_idx *idx) +{ + const struct d2d_figure *figure = &geometry->u.path.figures[idx->figure_idx]; + size_t next = idx->vertex_idx + 1; + + return d2d_point_ccw(&figure->vertices[idx->vertex_idx], + &figure->bezier_controls[idx->control_idx], &figure->vertices[next]); +} + +static BOOL d2d_geometry_split_bezier(struct d2d_geometry *geometry, const struct d2d_segment_idx *idx) +{ + const D2D1_POINT_2F *p[3]; + struct d2d_figure *figure; + D2D1_POINT_2F q[3]; + size_t next; + + figure = &geometry->u.path.figures[idx->figure_idx]; + p[0] = &figure->vertices[idx->vertex_idx]; + p[1] = &figure->bezier_controls[idx->control_idx]; + next = idx->vertex_idx + 1; + p[2] = &figure->vertices[next]; + + d2d_point_lerp(&q[0], p[0], p[1], 0.5f); + d2d_point_lerp(&q[1], p[1], p[2], 0.5f); + d2d_point_lerp(&q[2], &q[0], &q[1], 0.5f); + + figure->bezier_controls[idx->control_idx] = q[0]; + if (!(d2d_figure_insert_bezier_controls(figure, idx->control_idx + 1, 1, &q[1]))) + return FALSE; + if (!(d2d_figure_insert_vertex(figure, idx->vertex_idx + 1, q[2]))) + return FALSE; + figure->vertex_types[idx->vertex_idx + 1] = D2D_VERTEX_TYPE_SPLIT_BEZIER; + + return TRUE; +} + +static HRESULT d2d_geometry_resolve_beziers(struct d2d_geometry *geometry) +{ + struct d2d_segment_idx idx_p, idx_q; + struct d2d_curve_vertex *b; + const D2D1_POINT_2F *p[3]; + struct d2d_figure *figure; + size_t bezier_idx, i; + + if (!d2d_geometry_get_first_bezier_segment_idx(geometry, &idx_p)) + return S_OK; + + /* Split overlapping bezier control triangles. */ + while (d2d_geometry_get_next_bezier_segment_idx(geometry, &idx_p)) + { + d2d_geometry_get_first_bezier_segment_idx(geometry, &idx_q); + while (idx_q.figure_idx < idx_p.figure_idx || idx_q.vertex_idx < idx_p.vertex_idx) + { + while (d2d_geometry_check_bezier_overlap(geometry, &idx_p, &idx_q)) + { + if (fabsf(d2d_geometry_bezier_ccw(geometry, &idx_q)) > fabsf(d2d_geometry_bezier_ccw(geometry, &idx_p))) + { + if (!d2d_geometry_split_bezier(geometry, &idx_q)) + return E_OUTOFMEMORY; + if (idx_p.figure_idx == idx_q.figure_idx) + { + ++idx_p.vertex_idx; + ++idx_p.control_idx; + } + } + else + { + if (!d2d_geometry_split_bezier(geometry, &idx_p)) + return E_OUTOFMEMORY; + } + } + d2d_geometry_get_next_bezier_segment_idx(geometry, &idx_q); + } + } + + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + if (geometry->u.path.figures[i].flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + geometry->fill.bezier_vertex_count += 3 * geometry->u.path.figures[i].bezier_control_count; + } + + if (!(geometry->fill.bezier_vertices = calloc(geometry->fill.bezier_vertex_count, + sizeof(*geometry->fill.bezier_vertices)))) + { + ERR("Failed to allocate bezier vertices array.\n"); + geometry->fill.bezier_vertex_count = 0; + return E_OUTOFMEMORY; + } + + bezier_idx = 0; + d2d_geometry_get_first_bezier_segment_idx(geometry, &idx_p); + for (;;) + { + float sign = -1.0f; + + figure = &geometry->u.path.figures[idx_p.figure_idx]; + p[0] = &figure->vertices[idx_p.vertex_idx]; + p[1] = &figure->bezier_controls[idx_p.control_idx]; + + i = idx_p.vertex_idx + 1; + if (d2d_path_geometry_point_inside(geometry, p[1], FALSE)) + { + sign = 1.0f; + d2d_figure_insert_vertex(figure, i, *p[1]); + /* Inserting a vertex potentially invalidates p[0]. */ + p[0] = &figure->vertices[idx_p.vertex_idx]; + ++i; + } + + if (i == figure->vertex_count) + i = 0; + p[2] = &figure->vertices[i]; + + b = &geometry->fill.bezier_vertices[bezier_idx * 3]; + d2d_curve_vertex_set(&b[0], p[0], 0.0f, 0.0f, sign); + d2d_curve_vertex_set(&b[1], p[1], 0.5f, 0.0f, sign); + d2d_curve_vertex_set(&b[2], p[2], 1.0f, 1.0f, sign); + + if (!d2d_geometry_get_next_bezier_segment_idx(geometry, &idx_p)) + break; + ++bezier_idx; + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + HRESULT hr = E_FAIL; + + TRACE("iface %p.\n", iface); + + if (geometry->u.path.state == D2D_GEOMETRY_STATE_CLOSED) + return D2DERR_WRONG_STATE; + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_OPEN) + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + + if (geometry->u.path.state == D2D_GEOMETRY_STATE_ERROR) + return geometry->u.path.code; + + geometry->u.path.state = D2D_GEOMETRY_STATE_CLOSED; + + if (!d2d_geometry_intersect_self(geometry)) + goto done; + if (FAILED(hr = d2d_geometry_resolve_beziers(geometry))) + goto done; + if (FAILED(hr = d2d_path_geometry_triangulate(geometry))) + goto done; + +done: + if (FAILED(hr)) + { + free(geometry->fill.bezier_vertices); + geometry->fill.bezier_vertices = NULL; + geometry->fill.bezier_vertex_count = 0; + d2d_path_geometry_free_figures(geometry); + d2d_geometry_set_error(geometry, hr); + } + return hr; +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddLine(ID2D1GeometrySink *iface, D2D1_POINT_2F point) +{ + TRACE("iface %p, point %s.\n", iface, debug_d2d_point_2f(&point)); + + d2d_geometry_sink_AddLines(iface, &point, 1); +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddBezier(ID2D1GeometrySink *iface, const D2D1_BEZIER_SEGMENT *bezier) +{ + TRACE("iface %p, bezier %p.\n", iface, bezier); + + d2d_geometry_sink_AddBeziers(iface, bezier, 1); +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBezier(ID2D1GeometrySink *iface, + const D2D1_QUADRATIC_BEZIER_SEGMENT *bezier) +{ + TRACE("iface %p, bezier %p.\n", iface, bezier); + + ID2D1GeometrySink_AddQuadraticBeziers(iface, bezier, 1); +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1GeometrySink *iface, + const D2D1_QUADRATIC_BEZIER_SEGMENT *beziers, UINT32 bezier_count) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + struct d2d_figure *figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1]; + unsigned int i; + + TRACE("iface %p, beziers %p, bezier_count %u.\n", iface, beziers, bezier_count); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE) + { + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + return; + } + + for (i = 0; i < bezier_count; ++i) + { + D2D1_RECT_F bezier_bounds; + D2D1_POINT_2F p[2]; + + /* Construct a cubic curve. */ + d2d_point_lerp(&p[0], &figure->vertices[figure->vertex_count - 1], &beziers[i].point1, 2.0f / 3.0f); + d2d_point_lerp(&p[1], &beziers[i].point2, &beziers[i].point1, 2.0f / 3.0f); + if (!d2d_figure_add_original_bezier_controls(figure, 2, p)) + { + ERR("Failed to add cubic Bézier controls.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + d2d_rect_get_bezier_bounds(&bezier_bounds, &figure->vertices[figure->vertex_count - 1], + &beziers[i].point1, &beziers[i].point2); + + figure->vertex_types[figure->vertex_count - 1] = D2D_VERTEX_TYPE_BEZIER; + if (!d2d_figure_add_bezier_controls(figure, 1, &beziers[i].point1)) + { + ERR("Failed to add bezier.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + if (!d2d_figure_add_vertex(figure, beziers[i].point2)) + { + ERR("Failed to add bezier vertex.\n"); + d2d_geometry_set_error(geometry, E_OUTOFMEMORY); + return; + } + + d2d_rect_union(&figure->bounds, &bezier_bounds); + } + + geometry->u.path.segment_count += bezier_count; +} + +static void STDMETHODCALLTYPE d2d_geometry_sink_AddArc(ID2D1GeometrySink *iface, const D2D1_ARC_SEGMENT *arc) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); + + FIXME("iface %p, arc %p stub!\n", iface, arc); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE) + { + d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE); + return; + } + + if (!d2d_figure_add_vertex(&geometry->u.path.figures[geometry->u.path.figure_count - 1], arc->point)) + { + ERR("Failed to add vertex.\n"); + return; + } + + ++geometry->u.path.segment_count; +} + +static const struct ID2D1GeometrySinkVtbl d2d_geometry_sink_vtbl = +{ + d2d_geometry_sink_QueryInterface, + d2d_geometry_sink_AddRef, + d2d_geometry_sink_Release, + d2d_geometry_sink_SetFillMode, + d2d_geometry_sink_SetSegmentFlags, + d2d_geometry_sink_BeginFigure, + d2d_geometry_sink_AddLines, + d2d_geometry_sink_AddBeziers, + d2d_geometry_sink_EndFigure, + d2d_geometry_sink_Close, + d2d_geometry_sink_AddLine, + d2d_geometry_sink_AddBezier, + d2d_geometry_sink_AddQuadraticBezier, + d2d_geometry_sink_AddQuadraticBeziers, + d2d_geometry_sink_AddArc, +}; + +static inline struct d2d_geometry *impl_from_ID2D1PathGeometry1(ID2D1PathGeometry1 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_QueryInterface(ID2D1PathGeometry1 *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1PathGeometry1) + || IsEqualGUID(iid, &IID_ID2D1PathGeometry) + || IsEqualGUID(iid, &IID_ID2D1Geometry) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1PathGeometry1_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_path_geometry_AddRef(ID2D1PathGeometry1 *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + ULONG refcount = InterlockedIncrement(&geometry->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_path_geometry_Release(ID2D1PathGeometry1 *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + ULONG refcount = InterlockedDecrement(&geometry->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + d2d_path_geometry_free_figures(geometry); + d2d_geometry_cleanup(geometry); + free(geometry); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_path_geometry_GetFactory(ID2D1PathGeometry1 *iface, ID2D1Factory **factory) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = geometry->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetBounds(ID2D1PathGeometry1 *iface, + const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + size_t i; + + TRACE("iface %p, transform %p, bounds %p.\n", iface, transform, bounds); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_CLOSED) + return D2DERR_WRONG_STATE; + + bounds->left = FLT_MAX; + bounds->top = FLT_MAX; + bounds->right = -FLT_MAX; + bounds->bottom = -FLT_MAX; + + if (!transform) + { + if (geometry->u.path.bounds.left > geometry->u.path.bounds.right + && !isinf(geometry->u.path.bounds.left)) + { + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + if (geometry->u.path.figures[i].flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + d2d_rect_union(&geometry->u.path.bounds, &geometry->u.path.figures[i].bounds); + } + if (geometry->u.path.bounds.left > geometry->u.path.bounds.right) + { + geometry->u.path.bounds.left = INFINITY; + geometry->u.path.bounds.right = FLT_MAX; + geometry->u.path.bounds.top = INFINITY; + geometry->u.path.bounds.bottom = FLT_MAX; + } + } + + *bounds = geometry->u.path.bounds; + return S_OK; + } + + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + const struct d2d_figure *figure = &geometry->u.path.figures[i]; + enum d2d_vertex_type type = D2D_VERTEX_TYPE_NONE; + D2D1_RECT_F bezier_bounds; + D2D1_POINT_2F p, p1, p2; + size_t j, bezier_idx; + + if (figure->flags & D2D_FIGURE_FLAG_HOLLOW) + continue; + + for (j = 0; j < figure->vertex_count; ++j) + { + if (figure->vertex_types[j] == D2D_VERTEX_TYPE_NONE) + continue; + + p = figure->vertices[j]; + type = figure->vertex_types[j]; + d2d_point_transform(&p, transform, p.x, p.y); + d2d_rect_expand(bounds, &p); + break; + } + + for (bezier_idx = 0, ++j; j < figure->vertex_count; ++j) + { + enum d2d_vertex_type next_type; + + if ((next_type = figure->vertex_types[j]) == D2D_VERTEX_TYPE_NONE + || d2d_vertex_type_is_split_bezier(next_type)) + continue; + + switch (type) + { + case D2D_VERTEX_TYPE_LINE: + p = figure->vertices[j]; + d2d_point_transform(&p, transform, p.x, p.y); + d2d_rect_expand(bounds, &p); + break; + + case D2D_VERTEX_TYPE_BEZIER: + /* FIXME: This attempts to approximate a cubic Bézier with + * a quadratic one. */ + p1 = figure->original_bezier_controls[bezier_idx++]; + d2d_point_transform(&p1, transform, p1.x, p1.y); + p2 = figure->original_bezier_controls[bezier_idx++]; + d2d_point_transform(&p2, transform, p2.x, p2.y); + p1.x = (p1.x + p2.x) * 0.75f; + p1.y = (p1.y + p2.y) * 0.75f; + p2 = figure->vertices[j]; + d2d_point_transform(&p2, transform, p2.x, p2.y); + p1.x -= (p.x + p2.x) * 0.25f; + p1.y -= (p.y + p2.y) * 0.25f; + + d2d_rect_get_bezier_bounds(&bezier_bounds, &p, &p1, &p2); + d2d_rect_union(bounds, &bezier_bounds); + p = p2; + break; + + default: + FIXME("Unhandled vertex type %#x.\n", type); + p = figure->vertices[j]; + d2d_point_transform(&p, transform, p.x, p.y); + d2d_rect_expand(bounds, &p); + break; + } + + type = next_type; + } + } + + if (bounds->left > bounds->right) + { + bounds->left = INFINITY; + bounds->right = FLT_MAX; + bounds->top = INFINITY; + bounds->bottom = FLT_MAX; + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetWidenedBounds(ID2D1PathGeometry1 *iface, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1PathGeometry1 *iface, + D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, BOOL *contains) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + enum d2d_vertex_type type = D2D_VERTEX_TYPE_NONE; + unsigned int i, j, bezier_idx; + D2D1_BEZIER_SEGMENT b; + D2D1_POINT_2F p, p1; + + TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); + + if (stroke_style) + FIXME("Ignoring stroke style %p.\n", stroke_style); + + if (!transform) + transform = &identity; + + if (tolerance <= 0.0f) + tolerance = D2D1_DEFAULT_FLATTENING_TOLERANCE; + + *contains = FALSE; + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + const struct d2d_figure *figure = &geometry->u.path.figures[i]; + + for (j = 0; j < figure->vertex_count; ++j) + { + if (figure->vertex_types[j] == D2D_VERTEX_TYPE_NONE) + continue; + + p = figure->vertices[j]; + type = figure->vertex_types[j]; + break; + } + + for (bezier_idx = 0, ++j; j < figure->vertex_count; ++j) + { + enum d2d_vertex_type next_type; + + if ((next_type = figure->vertex_types[j]) == D2D_VERTEX_TYPE_NONE + || d2d_vertex_type_is_split_bezier(next_type)) + continue; + + switch (type) + { + case D2D_VERTEX_TYPE_LINE: + p1 = figure->vertices[j]; + *contains = d2d_point_on_line_segment(&point, &p, &p1, transform, stroke_width * 0.5f, tolerance); + p = p1; + break; + + case D2D_VERTEX_TYPE_BEZIER: + b.point1 = figure->original_bezier_controls[bezier_idx++]; + b.point2 = figure->original_bezier_controls[bezier_idx++]; + b.point3 = figure->vertices[j]; + *contains = d2d_point_on_bezier_segment(&point, &p, &b, transform, stroke_width, tolerance); + p = b.point3; + break; + + default: + FIXME("Unhandled vertex type %#x.\n", type); + p = figure->vertices[j]; + break; + } + if (*contains) + return S_OK; + type = next_type; + } + + if (type == D2D_VERTEX_TYPE_LINE) + { + p1 = figure->vertices[0]; + if (figure->flags & D2D_FIGURE_FLAG_CLOSED) + *contains = d2d_point_on_line_segment(&point, &p, &p1, transform, stroke_width * 0.5f, tolerance); + } + + if (*contains) + return S_OK; + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_FillContainsPoint(ID2D1PathGeometry1 *iface, + D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + D2D1_MATRIX_3X2_F g_i; + + TRACE("iface %p, point %s, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); + + if (transform) + { + if (!d2d_matrix_invert(&g_i, transform)) + return D2DERR_UNSUPPORTED_OPERATION; + d2d_point_transform(&point, &g_i, point.x, point.y); + } + + *contains = !!d2d_path_geometry_point_inside(geometry, &point, FALSE); + + TRACE("-> %#x.\n", *contains); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_CompareWithGeometry(ID2D1PathGeometry1 *iface, + ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation) +{ + FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n", + iface, geometry, transform, tolerance, relation); + + return E_NOTIMPL; +} + +static void d2d_geometry_flatten_cubic(ID2D1SimplifiedGeometrySink *sink, const D2D1_POINT_2F *p0, + const D2D1_BEZIER_SEGMENT *b, float tolerance) +{ + D2D1_BEZIER_SEGMENT b0, b1; + D2D1_POINT_2F q; + float d; + + /* It's certainly possible to calculate the maximum deviation of the + * approximation from the curve, but it's a little involved. Instead, note + * that if the control points were evenly spaced and collinear, p1 would + * be exactly between p0 and p2, and p2 would be exactly between p1 and + * p3. The deviation is a decent enough approximation, and much easier to + * calculate. + * + * p1' = (p0 + p2) / 2 + * p2' = (p1 + p3) / 2 + * d = ‖p1 - p1'‖₁ + ‖p2 - p2'‖₁ */ + d2d_point_lerp(&q, p0, &b->point2, 0.5f); + d2d_point_subtract(&q, &b->point1, &q); + d = fabsf(q.x) + fabsf(q.y); + d2d_point_lerp(&q, &b->point1, &b->point3, 0.5f); + d2d_point_subtract(&q, &b->point2, &q); + d += fabsf(q.x) + fabsf(q.y); + if (d < tolerance) + { + ID2D1SimplifiedGeometrySink_AddLines(sink, &b->point3, 1); + return; + } + + d2d_point_lerp(&q, &b->point1, &b->point2, 0.5f); + + b1.point3 = b->point3; + d2d_point_lerp(&b1.point2, &b1.point3, &b->point2, 0.5f); + d2d_point_lerp(&b1.point1, &b1.point2, &q, 0.5f); + + d2d_point_lerp(&b0.point1, p0, &b->point1, 0.5f); + d2d_point_lerp(&b0.point2, &b0.point1, &q, 0.5f); + d2d_point_lerp(&b0.point3, &b0.point2, &b1.point1, 0.5f); + + d2d_geometry_flatten_cubic(sink, p0, &b0, tolerance); + ID2D1SimplifiedGeometrySink_SetSegmentFlags(sink, D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN); + d2d_geometry_flatten_cubic(sink, &b0.point3, &b1, tolerance); + ID2D1SimplifiedGeometrySink_SetSegmentFlags(sink, D2D1_PATH_SEGMENT_NONE); +} + +static void d2d_figure_simplify(const struct d2d_figure *figure, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + enum d2d_vertex_type type = D2D_VERTEX_TYPE_NONE; + D2D1_FIGURE_BEGIN begin; + D2D1_BEZIER_SEGMENT b; + size_t i, bezier_idx; + D2D1_FIGURE_END end; + D2D1_POINT_2F p; + + for (i = 0; i < figure->vertex_count; ++i) + { + if (figure->vertex_types[i] == D2D_VERTEX_TYPE_NONE) + continue; + + p = figure->vertices[i]; + if (transform) + d2d_point_transform(&p, transform, p.x, p.y); + begin = figure->flags & D2D_FIGURE_FLAG_HOLLOW ? D2D1_FIGURE_BEGIN_HOLLOW : D2D1_FIGURE_BEGIN_FILLED; + ID2D1SimplifiedGeometrySink_BeginFigure(sink, p, begin); + type = figure->vertex_types[i]; + break; + } + + for (bezier_idx = 0, ++i; i < figure->vertex_count; ++i) + { + enum d2d_vertex_type next_type; + + if ((next_type = figure->vertex_types[i]) == D2D_VERTEX_TYPE_NONE + || d2d_vertex_type_is_split_bezier(next_type)) + continue; + + switch (type) + { + case D2D_VERTEX_TYPE_LINE: + p = figure->vertices[i]; + if (transform) + d2d_point_transform(&p, transform, p.x, p.y); + ID2D1SimplifiedGeometrySink_AddLines(sink, &p, 1); + break; + + case D2D_VERTEX_TYPE_BEZIER: + b.point1 = figure->original_bezier_controls[bezier_idx++]; + b.point2 = figure->original_bezier_controls[bezier_idx++]; + b.point3 = figure->vertices[i]; + if (transform) + { + d2d_point_transform(&b.point1, transform, b.point1.x, b.point1.y); + d2d_point_transform(&b.point2, transform, b.point2.x, b.point2.y); + d2d_point_transform(&b.point3, transform, b.point3.x, b.point3.y); + } + + if (option == D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES) + d2d_geometry_flatten_cubic(sink, &p, &b, tolerance); + else + ID2D1SimplifiedGeometrySink_AddBeziers(sink, &b, 1); + p = b.point3; + break; + + default: + FIXME("Unhandled vertex type %#x.\n", type); + p = figure->vertices[i]; + if (transform) + d2d_point_transform(&p, transform, p.x, p.y); + ID2D1SimplifiedGeometrySink_AddLines(sink, &p, 1); + break; + } + + type = next_type; + } + + end = figure->flags & D2D_FIGURE_FLAG_CLOSED ? D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN; + ID2D1SimplifiedGeometrySink_EndFigure(sink, end); +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Simplify(ID2D1PathGeometry1 *iface, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + size_t i; + + TRACE("iface %p, option %#x, transform %p, tolerance %.8e, sink %p.\n", + iface, option, transform, tolerance, sink); + + ID2D1SimplifiedGeometrySink_SetFillMode(sink, geometry->u.path.fill_mode); + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + const struct d2d_figure *figure = &geometry->u.path.figures[i]; + + d2d_figure_simplify(figure, option, transform, tolerance, sink); + } + + return S_OK; +} + +static HRESULT d2d_geometry_get_simplified(ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1PathGeometry **ret) +{ + ID2D1PathGeometry *path_geometry = NULL; + ID2D1GeometrySink *geometry_sink = NULL; + ID2D1Factory *factory; + HRESULT hr; + + *ret = NULL; + + ID2D1Geometry_GetFactory(geometry, &factory); + + hr = ID2D1Factory_CreatePathGeometry(factory, &path_geometry); + if (SUCCEEDED(hr)) + hr = ID2D1PathGeometry_Open(path_geometry, &geometry_sink); + if (SUCCEEDED(hr)) + { + hr = ID2D1Geometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES, + transform, tolerance, (ID2D1SimplifiedGeometrySink *)geometry_sink); + } + if (SUCCEEDED(hr)) + hr = ID2D1GeometrySink_Close(geometry_sink); + if (geometry_sink) + ID2D1GeometrySink_Release(geometry_sink); + + if (SUCCEEDED(hr)) + { + *ret = path_geometry; + ID2D1PathGeometry_AddRef(*ret); + } + + if (path_geometry) + ID2D1PathGeometry_Release(path_geometry); + ID2D1Factory_Release(factory); + + return hr; +} + +static HRESULT d2d_geometry_tessellate(ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1TessellationSink *sink) +{ + ID2D1PathGeometry *path_geometry; + HRESULT hr; + + if (SUCCEEDED(hr = d2d_geometry_get_simplified(geometry, transform, tolerance, &path_geometry))) + { + struct d2d_geometry *path_impl = unsafe_impl_from_ID2D1Geometry((ID2D1Geometry *)path_geometry); + D2D1_TRIANGLE t; + + for (size_t i = 0; i < path_impl->fill.face_count; ++i) + { + const struct d2d_face *face = &path_impl->fill.faces[i]; + + t.point1 = path_impl->fill.vertices[face->v[0]]; + t.point2 = path_impl->fill.vertices[face->v[1]]; + t.point3 = path_impl->fill.vertices[face->v[2]]; + ID2D1TessellationSink_AddTriangles(sink, &t, 1); + } + + ID2D1PathGeometry_Release(path_geometry); + } + + return hr; +} + +static float d2d_triangle_area(const D2D1_TRIANGLE *triangle) +{ + D2D1_POINT_2F point2, point3; + + /* Translate one vertex to origin */ + point2.x = triangle->point2.x - triangle->point1.x; + point2.y = triangle->point2.y - triangle->point1.y; + point3.x = triangle->point3.x - triangle->point1.x; + point3.y = triangle->point3.y - triangle->point1.y; + + return 0.5f * fabsf(point2.x * point3.y - point3.x * point2.y); +} + +static HRESULT d2d_geometry_compute_area(ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, + float tolerance, float *ret) +{ + ID2D1PathGeometry *path_geometry; + float area = 0.0f; + HRESULT hr; + + if (SUCCEEDED(hr = d2d_geometry_get_simplified(geometry, transform, tolerance, &path_geometry))) + { + struct d2d_geometry *path_impl = unsafe_impl_from_ID2D1Geometry((ID2D1Geometry *)path_geometry); + D2D1_TRIANGLE t; + + for (size_t i = 0; i < path_impl->fill.face_count; ++i) + { + const struct d2d_face *face = &path_impl->fill.faces[i]; + + t.point1 = path_impl->fill.vertices[face->v[0]]; + t.point2 = path_impl->fill.vertices[face->v[1]]; + t.point3 = path_impl->fill.vertices[face->v[2]]; + area += d2d_triangle_area(&t); + } + + *ret = area; + + ID2D1PathGeometry_Release(path_geometry); + } + + return hr; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Tessellate(ID2D1PathGeometry1 *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, sink %p.\n", iface, transform, tolerance, sink); + + return d2d_geometry_tessellate(&geometry->ID2D1Geometry_iface, transform, tolerance, sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_CombineWithGeometry(ID2D1PathGeometry1 *iface, + ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n", + iface, geometry, combine_mode, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Outline(ID2D1PathGeometry1 *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_ComputeArea(ID2D1PathGeometry1 *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, area %p.\n", iface, transform, tolerance, area); + + return d2d_geometry_compute_area(&geometry->ID2D1Geometry_iface, transform, tolerance, area); +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_ComputeLength(ID2D1PathGeometry1 *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length) +{ + FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_ComputePointAtLength(ID2D1PathGeometry1 *iface, float length, + const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_POINT_2F *point, D2D1_POINT_2F *tangent) +{ + FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n", + iface, length, transform, tolerance, point, tangent); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Widen(ID2D1PathGeometry1 *iface, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Open(ID2D1PathGeometry1 *iface, ID2D1GeometrySink **sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + + TRACE("iface %p, sink %p.\n", iface, sink); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_INITIAL) + return D2DERR_WRONG_STATE; + + *sink = &geometry->u.path.ID2D1GeometrySink_iface; + ID2D1GeometrySink_AddRef(*sink); + + geometry->u.path.state = D2D_GEOMETRY_STATE_OPEN; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Stream(ID2D1PathGeometry1 *iface, ID2D1GeometrySink *sink) +{ + FIXME("iface %p, sink %p stub!\n", iface, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetSegmentCount(ID2D1PathGeometry1 *iface, UINT32 *count) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + + TRACE("iface %p, count %p.\n", iface, count); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_CLOSED) + return D2DERR_WRONG_STATE; + + *count = geometry->u.path.segment_count; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetFigureCount(ID2D1PathGeometry1 *iface, UINT32 *count) +{ + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry1(iface); + + TRACE("iface %p, count %p.\n", iface, count); + + if (geometry->u.path.state != D2D_GEOMETRY_STATE_CLOSED) + return D2DERR_WRONG_STATE; + + *count = geometry->u.path.figure_count; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_path_geometry1_ComputePointAndSegmentAtLength(ID2D1PathGeometry1 *iface, + float length, UINT32 start_segment, const D2D1_MATRIX_3X2_F *transform, float tolerance, + D2D1_POINT_DESCRIPTION *point_desc) +{ + FIXME("iface %p, length %.8e, start_segment %u, transform %p, tolerance %.8e, point_desc %p.\n", + iface, length, start_segment, transform, tolerance, point_desc); + + return E_NOTIMPL; +} + +static const struct ID2D1PathGeometry1Vtbl d2d_path_geometry_vtbl = +{ + d2d_path_geometry_QueryInterface, + d2d_path_geometry_AddRef, + d2d_path_geometry_Release, + d2d_path_geometry_GetFactory, + d2d_path_geometry_GetBounds, + d2d_path_geometry_GetWidenedBounds, + d2d_path_geometry_StrokeContainsPoint, + d2d_path_geometry_FillContainsPoint, + d2d_path_geometry_CompareWithGeometry, + d2d_path_geometry_Simplify, + d2d_path_geometry_Tessellate, + d2d_path_geometry_CombineWithGeometry, + d2d_path_geometry_Outline, + d2d_path_geometry_ComputeArea, + d2d_path_geometry_ComputeLength, + d2d_path_geometry_ComputePointAtLength, + d2d_path_geometry_Widen, + d2d_path_geometry_Open, + d2d_path_geometry_Stream, + d2d_path_geometry_GetSegmentCount, + d2d_path_geometry_GetFigureCount, + d2d_path_geometry1_ComputePointAndSegmentAtLength, +}; + +void d2d_path_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory) +{ + d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_path_geometry_vtbl); + geometry->u.path.ID2D1GeometrySink_iface.lpVtbl = &d2d_geometry_sink_vtbl; + geometry->u.path.bounds.left = FLT_MAX; + geometry->u.path.bounds.right = -FLT_MAX; + geometry->u.path.bounds.top = FLT_MAX; + geometry->u.path.bounds.bottom = -FLT_MAX; +} + +static inline struct d2d_geometry *impl_from_ID2D1EllipseGeometry(ID2D1EllipseGeometry *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_QueryInterface(ID2D1EllipseGeometry *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1EllipseGeometry) + || IsEqualGUID(iid, &IID_ID2D1Geometry) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1EllipseGeometry_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_ellipse_geometry_AddRef(ID2D1EllipseGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + ULONG refcount = InterlockedIncrement(&geometry->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_ellipse_geometry_Release(ID2D1EllipseGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + ULONG refcount = InterlockedDecrement(&geometry->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + d2d_geometry_cleanup(geometry); + free(geometry); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_ellipse_geometry_GetFactory(ID2D1EllipseGeometry *iface, ID2D1Factory **factory) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = geometry->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_GetBounds(ID2D1EllipseGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, transform %p, bounds %p stub!\n", iface, transform, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_GetWidenedBounds(ID2D1EllipseGeometry *iface, + float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_StrokeContainsPoint(ID2D1EllipseGeometry *iface, + D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, BOOL *contains) +{ + FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p stub!\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_FillContainsPoint(ID2D1EllipseGeometry *iface, + D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + FIXME("iface %p, point %s, transform %p, tolerance %.8e, contains %p stub!\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_CompareWithGeometry(ID2D1EllipseGeometry *iface, + ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation) +{ + FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n", + iface, geometry, transform, tolerance, relation); + + return E_NOTIMPL; +} + +static void d2d_ellipse_to_segments(const D2D1_ELLIPSE *ellipse, D2D1_POINT_2F *start_point, + D2D1_BEZIER_SEGMENT *segments) +{ + const float coeff = 4.0f * (M_SQRT2 - 1.0f) / 3.0f; + D2D1_MATRIX_3X2_F m; + unsigned int i; + + /* Use four Bézier segments to approximate a unit circle. + Endpoints tangents are tangential to the circle. Endpoints and the midpoint + are lying on the circle. */ + + d2d_point_set(start_point, -1.0f, 0.0f); + + d2d_point_set(&segments[0].point1, -1.0f, -coeff); + d2d_point_set(&segments[0].point2, -coeff, -1.0f); + d2d_point_set(&segments[0].point3, 0.0f, -1.0f); + + d2d_point_set(&segments[1].point1, coeff, -1.0f); + d2d_point_set(&segments[1].point2, 1.0f, -coeff); + d2d_point_set(&segments[1].point3, 1.0f, 0.0f); + + d2d_point_set(&segments[2].point1, 1.0f, coeff); + d2d_point_set(&segments[2].point2, coeff, 1.0f); + d2d_point_set(&segments[2].point3, 0.0f, 1.0f); + + d2d_point_set(&segments[3].point1, -coeff, 1.0f); + d2d_point_set(&segments[3].point2, -1.0f, coeff); + d2d_point_set(&segments[3].point3, start_point->x, start_point->y); + + m._11 = ellipse->radiusX; + m._12 = 0.0f; + m._21 = 0.0f; + m._22 = ellipse->radiusY; + m._31 = ellipse->point.x; + m._32 = ellipse->point.y; + + d2d_point_transform(start_point, &m, start_point->x, start_point->y); + for (i = 0; i < 4; ++i) + { + d2d_point_transform(&segments[i].point1, &m, segments[i].point1.x, segments[i].point1.y); + d2d_point_transform(&segments[i].point2, &m, segments[i].point2.x, segments[i].point2.y); + d2d_point_transform(&segments[i].point3, &m, segments[i].point3.x, segments[i].point3.y); + } +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_Simplify(ID2D1EllipseGeometry *iface, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + struct d2d_figure figure = { 0 }; + D2D1_BEZIER_SEGMENT segments[4]; + D2D1_POINT_2F start_point; + + TRACE("iface %p, option %#x, transform %p, tolerance %.8e, sink %p.\n", + iface, option, transform, tolerance, sink); + + d2d_ellipse_to_segments(&geometry->u.ellipse.ellipse, &start_point, segments); + + if (!d2d_figure_begin(&figure, start_point, D2D1_FIGURE_BEGIN_FILLED)) + return E_OUTOFMEMORY; + if (!d2d_figure_add_beziers(&figure, segments, ARRAY_SIZE(segments))) + { + d2d_figure_cleanup(&figure); + return E_OUTOFMEMORY; + } + d2d_figure_end(&figure, D2D1_FIGURE_END_CLOSED); + + d2d_figure_simplify(&figure, option, transform, tolerance, sink); + d2d_figure_cleanup(&figure); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_Tessellate(ID2D1EllipseGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, sink %p.\n", iface, transform, tolerance, sink); + + return d2d_geometry_tessellate(&geometry->ID2D1Geometry_iface, transform, tolerance, sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_CombineWithGeometry(ID2D1EllipseGeometry *iface, + ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n", + iface, geometry, combine_mode, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_Outline(ID2D1EllipseGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_ComputeArea(ID2D1EllipseGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, area %p.\n", iface, transform, tolerance, area); + + return d2d_geometry_compute_area(&geometry->ID2D1Geometry_iface, transform, tolerance, area); +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_ComputeLength(ID2D1EllipseGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length) +{ + FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_ComputePointAtLength(ID2D1EllipseGeometry *iface, + float length, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_POINT_2F *point, + D2D1_POINT_2F *tangent) +{ + FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n", + iface, length, transform, tolerance, point, tangent); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_ellipse_geometry_Widen(ID2D1EllipseGeometry *iface, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_ellipse_geometry_GetEllipse(ID2D1EllipseGeometry *iface, D2D1_ELLIPSE *ellipse) +{ + struct d2d_geometry *geometry = impl_from_ID2D1EllipseGeometry(iface); + + TRACE("iface %p, ellipse %p.\n", iface, ellipse); + + *ellipse = geometry->u.ellipse.ellipse; +} + +static const struct ID2D1EllipseGeometryVtbl d2d_ellipse_geometry_vtbl = +{ + d2d_ellipse_geometry_QueryInterface, + d2d_ellipse_geometry_AddRef, + d2d_ellipse_geometry_Release, + d2d_ellipse_geometry_GetFactory, + d2d_ellipse_geometry_GetBounds, + d2d_ellipse_geometry_GetWidenedBounds, + d2d_ellipse_geometry_StrokeContainsPoint, + d2d_ellipse_geometry_FillContainsPoint, + d2d_ellipse_geometry_CompareWithGeometry, + d2d_ellipse_geometry_Simplify, + d2d_ellipse_geometry_Tessellate, + d2d_ellipse_geometry_CombineWithGeometry, + d2d_ellipse_geometry_Outline, + d2d_ellipse_geometry_ComputeArea, + d2d_ellipse_geometry_ComputeLength, + d2d_ellipse_geometry_ComputePointAtLength, + d2d_ellipse_geometry_Widen, + d2d_ellipse_geometry_GetEllipse, +}; + +HRESULT d2d_ellipse_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory, const D2D1_ELLIPSE *ellipse) +{ + D2D1_POINT_2F *v, v1, v2, v3, v4; + struct d2d_face *f; + float l, r, t, b; + + d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_ellipse_geometry_vtbl); + geometry->u.ellipse.ellipse = *ellipse; + + if (!(geometry->fill.vertices = malloc(4 * sizeof(*geometry->fill.vertices)))) + goto fail; + if (!d2d_array_reserve((void **)&geometry->fill.faces, + &geometry->fill.faces_size, 2, sizeof(*geometry->fill.faces))) + goto fail; + + l = ellipse->point.x - ellipse->radiusX; + r = ellipse->point.x + ellipse->radiusX; + t = ellipse->point.y - ellipse->radiusY; + b = ellipse->point.y + ellipse->radiusY; + + d2d_point_set(&v1, r, t); + d2d_point_set(&v2, r, b); + d2d_point_set(&v3, l, b); + d2d_point_set(&v4, l, t); + + v = geometry->fill.vertices; + d2d_point_set(&v[0], ellipse->point.x, t); + d2d_point_set(&v[1], r, ellipse->point.y); + d2d_point_set(&v[2], ellipse->point.x, b); + d2d_point_set(&v[3], l, ellipse->point.y); + geometry->fill.vertex_count = 4; + + f = geometry->fill.faces; + d2d_face_set(&f[0], 0, 3, 2); + d2d_face_set(&f[1], 0, 2, 1); + geometry->fill.face_count = 2; + + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[0], &v1, &v[1])) + goto fail; + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[1], &v2, &v[2])) + goto fail; + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[2], &v3, &v[3])) + goto fail; + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[3], &v4, &v[0])) + goto fail; + + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[0], &v1, &v[1])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[1], &v2, &v[2])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[2], &v3, &v[3])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[3], &v4, &v[0])) + goto fail; + + return S_OK; + +fail: + d2d_geometry_cleanup(geometry); + return E_OUTOFMEMORY; +} + +static inline struct d2d_geometry *impl_from_ID2D1RectangleGeometry(ID2D1RectangleGeometry *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_QueryInterface(ID2D1RectangleGeometry *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1RectangleGeometry) + || IsEqualGUID(iid, &IID_ID2D1Geometry) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1RectangleGeometry_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_rectangle_geometry_AddRef(ID2D1RectangleGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + ULONG refcount = InterlockedIncrement(&geometry->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_rectangle_geometry_Release(ID2D1RectangleGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + ULONG refcount = InterlockedDecrement(&geometry->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + d2d_geometry_cleanup(geometry); + free(geometry); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_rectangle_geometry_GetFactory(ID2D1RectangleGeometry *iface, ID2D1Factory **factory) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = geometry->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_GetBounds(ID2D1RectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + D2D1_RECT_F *rect; + D2D1_POINT_2F p; + + TRACE("iface %p, transform %p, bounds %p.\n", iface, transform, bounds); + + rect = &geometry->u.rectangle.rect; + if (!transform) + { + *bounds = *rect; + return S_OK; + } + + bounds->left = FLT_MAX; + bounds->top = FLT_MAX; + bounds->right = -FLT_MAX; + bounds->bottom = -FLT_MAX; + + d2d_point_transform(&p, transform, rect->left, rect->top); + d2d_rect_expand(bounds, &p); + d2d_point_transform(&p, transform, rect->left, rect->bottom); + d2d_rect_expand(bounds, &p); + d2d_point_transform(&p, transform, rect->right, rect->bottom); + d2d_rect_expand(bounds, &p); + d2d_point_transform(&p, transform, rect->right, rect->top); + d2d_rect_expand(bounds, &p); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_GetWidenedBounds(ID2D1RectangleGeometry *iface, + float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_StrokeContainsPoint(ID2D1RectangleGeometry *iface, + D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, BOOL *contains) +{ + const struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + const D2D1_RECT_F *rect = &geometry->u.rectangle.rect; + unsigned int i; + struct + { + D2D1_POINT_2F s, e; + } + segments[4]; + + TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); + + if (stroke_style) + FIXME("Ignoring stroke style %p.\n", stroke_style); + + tolerance = fabsf(tolerance); + + if (!transform) + { + D2D1_POINT_2F d, s; + + s.x = rect->right - rect->left; + s.y = rect->bottom - rect->top; + d.x = fabsf((rect->right + rect->left) * 0.5f - point.x); + d.y = fabsf((rect->bottom + rect->top) * 0.5f - point.y); + + /* Inside test. */ + if (d.x <= (s.x - stroke_width) * 0.5f - tolerance && d.y <= (s.y - stroke_width) * 0.5f - tolerance) + { + *contains = FALSE; + return S_OK; + } + + if (tolerance == 0.0f) + { + *contains = d.x < (s.x + stroke_width) * 0.5f && d.y < (s.y + stroke_width) * 0.5f; + } + else + { + d.x = max(d.x - (s.x + stroke_width) * 0.5f, 0.0f); + d.y = max(d.y - (s.y + stroke_width) * 0.5f, 0.0f); + + *contains = d2d_point_dot(&d, &d) < tolerance * tolerance; + } + + return S_OK; + } + + stroke_width *= 0.5f; + + d2d_point_set(&segments[0].s, rect->left - stroke_width, rect->bottom); + d2d_point_set(&segments[0].e, rect->right + stroke_width, rect->bottom); + d2d_point_set(&segments[1].s, rect->right, rect->bottom + stroke_width); + d2d_point_set(&segments[1].e, rect->right, rect->top - stroke_width); + d2d_point_set(&segments[2].s, rect->right + stroke_width, rect->top); + d2d_point_set(&segments[2].e, rect->left - stroke_width, rect->top); + d2d_point_set(&segments[3].s, rect->left, rect->top - stroke_width); + d2d_point_set(&segments[3].e, rect->left, rect->bottom + stroke_width); + + *contains = FALSE; + for (i = 0; i < ARRAY_SIZE(segments); ++i) + { + if (d2d_point_on_line_segment(&point, &segments[i].s, &segments[i].e, transform, stroke_width, tolerance)) + { + *contains = TRUE; + break; + } + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_FillContainsPoint(ID2D1RectangleGeometry *iface, + D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + D2D1_RECT_F *rect = &geometry->u.rectangle.rect; + float dx, dy; + + TRACE("iface %p, point %s, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); + + if (transform) + { + D2D1_MATRIX_3X2_F g_i; + + if (!d2d_matrix_invert(&g_i, transform)) + return D2DERR_UNSUPPORTED_OPERATION; + d2d_point_transform(&point, &g_i, point.x, point.y); + } + + if (tolerance == 0.0f) + tolerance = D2D1_DEFAULT_FLATTENING_TOLERANCE; + + dx = max(fabsf((rect->right + rect->left) / 2.0f - point.x) - (rect->right - rect->left) / 2.0f, 0.0f); + dy = max(fabsf((rect->bottom + rect->top) / 2.0f - point.y) - (rect->bottom - rect->top) / 2.0f, 0.0f); + + *contains = tolerance * tolerance > (dx * dx + dy * dy); + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_CompareWithGeometry(ID2D1RectangleGeometry *iface, + ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation) +{ + FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n", + iface, geometry, transform, tolerance, relation); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_Simplify(ID2D1RectangleGeometry *iface, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + D2D1_RECT_F *rect = &geometry->u.rectangle.rect; + D2D1_POINT_2F p[4]; + unsigned int i; + + TRACE("iface %p, option %#x, transform %p, tolerance %.8e, sink %p.\n", + iface, option, transform, tolerance, sink); + + d2d_point_set(&p[0], rect->left, rect->top); + d2d_point_set(&p[1], rect->right, rect->top); + d2d_point_set(&p[2], rect->right, rect->bottom); + d2d_point_set(&p[3], rect->left, rect->bottom); + + if (transform) + { + for (i = 0; i < ARRAY_SIZE(p); ++i) + { + d2d_point_transform(&p[i], transform, p[i].x, p[i].y); + } + } + + ID2D1SimplifiedGeometrySink_SetFillMode(sink, D2D1_FILL_MODE_ALTERNATE); + ID2D1SimplifiedGeometrySink_BeginFigure(sink, p[0], D2D1_FIGURE_BEGIN_FILLED); + ID2D1SimplifiedGeometrySink_AddLines(sink, &p[1], 3); + ID2D1SimplifiedGeometrySink_EndFigure(sink, D2D1_FIGURE_END_CLOSED); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_Tessellate(ID2D1RectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, sink %p.\n", iface, transform, tolerance, sink); + + return d2d_geometry_tessellate(&geometry->ID2D1Geometry_iface, transform, tolerance, sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_CombineWithGeometry(ID2D1RectangleGeometry *iface, + ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n", + iface, geometry, combine_mode, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_Outline(ID2D1RectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_ComputeArea(ID2D1RectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + const D2D_RECT_F *rect = &geometry->u.rectangle.rect; + D2D1_TRIANGLE triangle; + D2D1_MATRIX_3X2_F m; + + TRACE("iface %p, transform %p, tolerance %.8e, area %p.\n", iface, transform, tolerance, area); + + if (transform) + { + m = *transform; + m._31 = m._32 = 0.0f; + + d2d_point_transform(&triangle.point1, &m, rect->left, rect->bottom); + d2d_point_transform(&triangle.point2, &m, rect->left, rect->top); + d2d_point_transform(&triangle.point3, &m, rect->right, rect->top); + + *area = 2 * d2d_triangle_area(&triangle); + } + else + { + *area = fabsf((rect->right - rect->left) * (rect->bottom - rect->top)); + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_ComputeLength(ID2D1RectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length) +{ + FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_ComputePointAtLength(ID2D1RectangleGeometry *iface, + float length, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_POINT_2F *point, + D2D1_POINT_2F *tangent) +{ + FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n", + iface, length, transform, tolerance, point, tangent); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_Widen(ID2D1RectangleGeometry *iface, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_rectangle_geometry_GetRect(ID2D1RectangleGeometry *iface, D2D1_RECT_F *rect) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + + TRACE("iface %p, rect %p.\n", iface, rect); + + *rect = geometry->u.rectangle.rect; +} + +static const struct ID2D1RectangleGeometryVtbl d2d_rectangle_geometry_vtbl = +{ + d2d_rectangle_geometry_QueryInterface, + d2d_rectangle_geometry_AddRef, + d2d_rectangle_geometry_Release, + d2d_rectangle_geometry_GetFactory, + d2d_rectangle_geometry_GetBounds, + d2d_rectangle_geometry_GetWidenedBounds, + d2d_rectangle_geometry_StrokeContainsPoint, + d2d_rectangle_geometry_FillContainsPoint, + d2d_rectangle_geometry_CompareWithGeometry, + d2d_rectangle_geometry_Simplify, + d2d_rectangle_geometry_Tessellate, + d2d_rectangle_geometry_CombineWithGeometry, + d2d_rectangle_geometry_Outline, + d2d_rectangle_geometry_ComputeArea, + d2d_rectangle_geometry_ComputeLength, + d2d_rectangle_geometry_ComputePointAtLength, + d2d_rectangle_geometry_Widen, + d2d_rectangle_geometry_GetRect, +}; + +HRESULT d2d_rectangle_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory, const D2D1_RECT_F *rect) +{ + struct d2d_face *f; + D2D1_POINT_2F *v; + float l, r, t, b; + + static const D2D1_POINT_2F prev[] = + { + { 1.0f, 0.0f}, + { 0.0f, -1.0f}, + {-1.0f, 0.0f}, + { 0.0f, 1.0f}, + }; + static const D2D1_POINT_2F next[] = + { + { 0.0f, 1.0f}, + { 1.0f, 0.0f}, + { 0.0f, -1.0f}, + {-1.0f, 0.0f}, + }; + + d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_rectangle_geometry_vtbl); + geometry->u.rectangle.rect = *rect; + + if (!(geometry->fill.vertices = malloc(4 * sizeof(*geometry->fill.vertices)))) + goto fail; + if (!d2d_array_reserve((void **)&geometry->fill.faces, + &geometry->fill.faces_size, 2, sizeof(*geometry->fill.faces))) + goto fail; + + l = min(rect->left, rect->right); + r = max(rect->left, rect->right); + t = min(rect->top, rect->bottom); + b = max(rect->top, rect->bottom); + + v = geometry->fill.vertices; + d2d_point_set(&v[0], l, t); + d2d_point_set(&v[1], l, b); + d2d_point_set(&v[2], r, b); + d2d_point_set(&v[3], r, t); + geometry->fill.vertex_count = 4; + + f = geometry->fill.faces; + d2d_face_set(&f[0], 1, 2, 0); + d2d_face_set(&f[1], 0, 2, 3); + geometry->fill.face_count = 2; + + if (!d2d_geometry_outline_add_line_segment(geometry, &v[0], &v[1])) + goto fail; + if (!d2d_geometry_outline_add_line_segment(geometry, &v[1], &v[2])) + goto fail; + if (!d2d_geometry_outline_add_line_segment(geometry, &v[2], &v[3])) + goto fail; + if (!d2d_geometry_outline_add_line_segment(geometry, &v[3], &v[0])) + goto fail; + + if (!d2d_geometry_outline_add_join(geometry, &prev[0], &v[0], &next[0])) + goto fail; + if (!d2d_geometry_outline_add_join(geometry, &prev[1], &v[1], &next[1])) + goto fail; + if (!d2d_geometry_outline_add_join(geometry, &prev[2], &v[2], &next[2])) + goto fail; + if (!d2d_geometry_outline_add_join(geometry, &prev[3], &v[3], &next[3])) + goto fail; + + return S_OK; + +fail: + d2d_geometry_cleanup(geometry); + return E_OUTOFMEMORY; +} + +static inline struct d2d_geometry *impl_from_ID2D1RoundedRectangleGeometry(ID2D1RoundedRectangleGeometry *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_QueryInterface(ID2D1RoundedRectangleGeometry *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1RoundedRectangleGeometry) + || IsEqualGUID(iid, &IID_ID2D1Geometry) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1RoundedRectangleGeometry_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_AddRef(ID2D1RoundedRectangleGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + ULONG refcount = InterlockedIncrement(&geometry->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_Release(ID2D1RoundedRectangleGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + ULONG refcount = InterlockedDecrement(&geometry->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + d2d_geometry_cleanup(geometry); + free(geometry); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_GetFactory(ID2D1RoundedRectangleGeometry *iface, + ID2D1Factory **factory) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = geometry->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_GetBounds(ID2D1RoundedRectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, transform %p, bounds %p stub!\n", iface, transform, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_GetWidenedBounds(ID2D1RoundedRectangleGeometry *iface, + float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_StrokeContainsPoint( + ID2D1RoundedRectangleGeometry *iface, D2D1_POINT_2F point, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p stub!\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_FillContainsPoint(ID2D1RoundedRectangleGeometry *iface, + D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + FIXME("iface %p, point %s, transform %p, tolerance %.8e, contains %p stub!\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_CompareWithGeometry( + ID2D1RoundedRectangleGeometry *iface, ID2D1Geometry *geometry, + const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation) +{ + FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n", + iface, geometry, transform, tolerance, relation); + + return E_NOTIMPL; +} + +static inline void d2d_point_translate(D2D1_POINT_2F *point, float x, float y) +{ + point->x += x; + point->y += y; +} + +static inline void d2d_bezier_segment_translate(D2D1_BEZIER_SEGMENT *segment, float x, float y) +{ + d2d_point_translate(&segment->point1, x, y); + d2d_point_translate(&segment->point2, x, y); + d2d_point_translate(&segment->point3, x, y); +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_Simplify(ID2D1RoundedRectangleGeometry *iface, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + const D2D1_ROUNDED_RECT *r = &geometry->u.rounded_rectangle.rounded_rect; + struct d2d_figure figure = { 0 }; + D2D1_BEZIER_SEGMENT segments[4]; + D2D1_POINT_2F start_point, p; + D2D1_ELLIPSE ellipse; + bool ret; + + TRACE("iface %p, option %#x, transform %p, tolerance %.8e, sink %p.\n", + iface, option, transform, tolerance, sink); + + d2d_point_set(&ellipse.point, 0.0f, 0.0f); + ellipse.radiusX = r->radiusX; + ellipse.radiusY = r->radiusY; + + d2d_ellipse_to_segments(&ellipse, &start_point, segments); + + d2d_point_set(&p, r->rect.left + r->radiusX, r->rect.bottom + r->radiusY); + d2d_point_translate(&start_point, p.x, p.y); + d2d_bezier_segment_translate(&segments[0], p.x, p.y); + d2d_point_set(&p, r->rect.right - r->radiusX, r->rect.bottom + r->radiusY); + d2d_bezier_segment_translate(&segments[1], p.x, p.y); + d2d_point_set(&p, r->rect.right - r->radiusX, r->rect.top - r->radiusY); + d2d_bezier_segment_translate(&segments[2], p.x, p.y); + d2d_point_set(&p, r->rect.left + r->radiusX, r->rect.top - r->radiusY); + d2d_bezier_segment_translate(&segments[3], p.x, p.y); + + ret = d2d_figure_begin(&figure, start_point, D2D1_FIGURE_BEGIN_FILLED); + ret = ret && d2d_figure_add_beziers(&figure, &segments[0], 1); + d2d_point_set(&p, r->rect.right - r->radiusX, r->rect.bottom); + ret = ret && d2d_figure_add_lines(&figure, &p, 1); + ret = ret && d2d_figure_add_beziers(&figure, &segments[1], 1); + d2d_point_set(&p, r->rect.right, r->rect.top - r->radiusY); + ret = ret && d2d_figure_add_lines(&figure, &p, 1); + ret = ret && d2d_figure_add_beziers(&figure, &segments[2], 1); + d2d_point_set(&p, r->rect.left + r->radiusX, r->rect.top); + ret = ret && d2d_figure_add_lines(&figure, &p, 1); + ret = ret && d2d_figure_add_beziers(&figure, &segments[3], 1); + if (!ret) + { + d2d_figure_cleanup(&figure); + return E_OUTOFMEMORY; + } + + d2d_figure_end(&figure, D2D1_FIGURE_END_CLOSED); + + d2d_figure_simplify(&figure, option, transform, tolerance, sink); + d2d_figure_cleanup(&figure); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_Tessellate(ID2D1RoundedRectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, sink %p.\n", iface, transform, tolerance, sink); + + return d2d_geometry_tessellate(&geometry->ID2D1Geometry_iface, transform, tolerance, sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_CombineWithGeometry( + ID2D1RoundedRectangleGeometry *iface, ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n", + iface, geometry, combine_mode, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_Outline(ID2D1RoundedRectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_ComputeArea(ID2D1RoundedRectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + + TRACE("iface %p, transform %p, tolerance %.8e, area %p.\n", iface, transform, tolerance, area); + + return d2d_geometry_compute_area(&geometry->ID2D1Geometry_iface, transform, tolerance, area); +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_ComputeLength(ID2D1RoundedRectangleGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length) +{ + FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_ComputePointAtLength( + ID2D1RoundedRectangleGeometry *iface, float length, const D2D1_MATRIX_3X2_F *transform, + float tolerance, D2D1_POINT_2F *point, D2D1_POINT_2F *tangent) +{ + FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n", + iface, length, transform, tolerance, point, tangent); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_Widen(ID2D1RoundedRectangleGeometry *iface, + float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_rounded_rectangle_geometry_GetRoundedRect(ID2D1RoundedRectangleGeometry *iface, + D2D1_ROUNDED_RECT *rounded_rect) +{ + struct d2d_geometry *geometry = impl_from_ID2D1RoundedRectangleGeometry(iface); + + TRACE("iface %p, rounded_rect %p.\n", iface, rounded_rect); + + *rounded_rect = geometry->u.rounded_rectangle.rounded_rect; +} + +static const struct ID2D1RoundedRectangleGeometryVtbl d2d_rounded_rectangle_geometry_vtbl = +{ + d2d_rounded_rectangle_geometry_QueryInterface, + d2d_rounded_rectangle_geometry_AddRef, + d2d_rounded_rectangle_geometry_Release, + d2d_rounded_rectangle_geometry_GetFactory, + d2d_rounded_rectangle_geometry_GetBounds, + d2d_rounded_rectangle_geometry_GetWidenedBounds, + d2d_rounded_rectangle_geometry_StrokeContainsPoint, + d2d_rounded_rectangle_geometry_FillContainsPoint, + d2d_rounded_rectangle_geometry_CompareWithGeometry, + d2d_rounded_rectangle_geometry_Simplify, + d2d_rounded_rectangle_geometry_Tessellate, + d2d_rounded_rectangle_geometry_CombineWithGeometry, + d2d_rounded_rectangle_geometry_Outline, + d2d_rounded_rectangle_geometry_ComputeArea, + d2d_rounded_rectangle_geometry_ComputeLength, + d2d_rounded_rectangle_geometry_ComputePointAtLength, + d2d_rounded_rectangle_geometry_Widen, + d2d_rounded_rectangle_geometry_GetRoundedRect, +}; + +HRESULT d2d_rounded_rectangle_geometry_init(struct d2d_geometry *geometry, + ID2D1Factory *factory, const D2D1_ROUNDED_RECT *rounded_rect) +{ + D2D1_POINT_2F *v, v1, v2, v3, v4; + struct d2d_face *f; + float l, r, t, b; + float rx, ry; + + d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_rounded_rectangle_geometry_vtbl); + geometry->u.rounded_rectangle.rounded_rect = *rounded_rect; + + if (!(geometry->fill.vertices = malloc(8 * sizeof(*geometry->fill.vertices)))) + goto fail; + if (!d2d_array_reserve((void **)&geometry->fill.faces, + &geometry->fill.faces_size, 6, sizeof(*geometry->fill.faces))) + goto fail; + + l = min(rounded_rect->rect.left, rounded_rect->rect.right); + r = max(rounded_rect->rect.left, rounded_rect->rect.right); + t = min(rounded_rect->rect.top, rounded_rect->rect.bottom); + b = max(rounded_rect->rect.top, rounded_rect->rect.bottom); + + rx = min(rounded_rect->radiusX, 0.5f * (r - l)); + ry = min(rounded_rect->radiusY, 0.5f * (b - t)); + + d2d_point_set(&v1, r, t); + d2d_point_set(&v2, r, b); + d2d_point_set(&v3, l, b); + d2d_point_set(&v4, l, t); + + v = geometry->fill.vertices; + d2d_point_set(&v[0], l + rx, t); + d2d_point_set(&v[1], r - rx, t); + d2d_point_set(&v[2], r, t + ry); + d2d_point_set(&v[3], r, b - ry); + d2d_point_set(&v[4], r - rx, b); + d2d_point_set(&v[5], l + rx, b); + d2d_point_set(&v[6], l, b - ry); + d2d_point_set(&v[7], l, t + ry); + geometry->fill.vertex_count = 8; + + f = geometry->fill.faces; + d2d_face_set(&f[0], 0, 7, 6); + d2d_face_set(&f[1], 0, 6, 5); + d2d_face_set(&f[2], 0, 5, 4); + d2d_face_set(&f[3], 0, 4, 1); + d2d_face_set(&f[4], 1, 4, 3); + d2d_face_set(&f[5], 1, 3, 2); + geometry->fill.face_count = 6; + + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[1], &v1, &v[2])) + goto fail; + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[3], &v2, &v[4])) + goto fail; + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[5], &v3, &v[6])) + goto fail; + if (!d2d_geometry_fill_add_arc_triangle(geometry, &v[7], &v4, &v[0])) + goto fail; + + if (!d2d_geometry_outline_add_line_segment(geometry, &v[0], &v[1])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[1], &v1, &v[2])) + goto fail; + if (!d2d_geometry_outline_add_line_segment(geometry, &v[2], &v[3])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[3], &v2, &v[4])) + goto fail; + if (!d2d_geometry_outline_add_line_segment(geometry, &v[4], &v[5])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[5], &v3, &v[6])) + goto fail; + if (!d2d_geometry_outline_add_line_segment(geometry, &v[6], &v[7])) + goto fail; + if (!d2d_geometry_outline_add_arc_quadrant(geometry, &v[7], &v4, &v[0])) + goto fail; + + return S_OK; + +fail: + d2d_geometry_cleanup(geometry); + return E_OUTOFMEMORY; +} + +static inline struct d2d_geometry *impl_from_ID2D1TransformedGeometry(ID2D1TransformedGeometry *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_QueryInterface(ID2D1TransformedGeometry *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1TransformedGeometry) + || IsEqualGUID(iid, &IID_ID2D1Geometry) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1TransformedGeometry_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_transformed_geometry_AddRef(ID2D1TransformedGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + ULONG refcount = InterlockedIncrement(&geometry->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_transformed_geometry_Release(ID2D1TransformedGeometry *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + ULONG refcount = InterlockedDecrement(&geometry->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + geometry->outline.arc_faces = NULL; + geometry->outline.arcs = NULL; + geometry->outline.bezier_faces = NULL; + geometry->outline.beziers = NULL; + geometry->outline.faces = NULL; + geometry->outline.vertices = NULL; + geometry->fill.arc_vertices = NULL; + geometry->fill.bezier_vertices = NULL; + geometry->fill.faces = NULL; + geometry->fill.vertices = NULL; + ID2D1Geometry_Release(geometry->u.transformed.src_geometry); + d2d_geometry_cleanup(geometry); + free(geometry); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_transformed_geometry_GetFactory(ID2D1TransformedGeometry *iface, + ID2D1Factory **factory) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = geometry->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_GetBounds(ID2D1TransformedGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + D2D1_MATRIX_3X2_F g; + + TRACE("iface %p, transform %p, bounds %p.\n", iface, transform, bounds); + + g = geometry->transform; + if (transform) + d2d_matrix_multiply(&g, transform); + + return ID2D1Geometry_GetBounds(geometry->u.transformed.src_geometry, &g, bounds); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_GetWidenedBounds(ID2D1TransformedGeometry *iface, + float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_StrokeContainsPoint(ID2D1TransformedGeometry *iface, + D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, BOOL *contains) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + D2D1_MATRIX_3X2_F g; + + TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); + + g = geometry->transform; + stroke_width /= g.m11; + if (transform) + d2d_matrix_multiply(&g, transform); + + if (tolerance <= 0.0f) + tolerance = D2D1_DEFAULT_FLATTENING_TOLERANCE; + + return ID2D1Geometry_StrokeContainsPoint(geometry->u.transformed.src_geometry, point, stroke_width, stroke_style, + &g, tolerance, contains); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_FillContainsPoint(ID2D1TransformedGeometry *iface, + D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + D2D1_MATRIX_3X2_F g; + + TRACE("iface %p, point %s, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); + + g = geometry->transform; + if (transform) + d2d_matrix_multiply(&g, transform); + + return ID2D1Geometry_FillContainsPoint(geometry->u.transformed.src_geometry, point, &g, tolerance, contains); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_CompareWithGeometry(ID2D1TransformedGeometry *iface, + ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation) +{ + FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n", + iface, geometry, transform, tolerance, relation); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_Simplify(ID2D1TransformedGeometry *iface, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + D2D1_MATRIX_3X2_F g; + + TRACE("iface %p, option %#x, transform %p, tolerance %.8e, sink %p.\n", + iface, option, transform, tolerance, sink); + + g = geometry->transform; + if (transform) + d2d_matrix_multiply(&g, transform); + + return ID2D1Geometry_Simplify(geometry->u.transformed.src_geometry, option, &g, tolerance, sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_Tessellate(ID2D1TransformedGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + D2D1_MATRIX_3X2_F g; + + TRACE("iface %p, transform %p, tolerance %.8e, sink %p.\n", iface, transform, tolerance, sink); + + g = geometry->transform; + if (transform) + d2d_matrix_multiply(&g, transform); + + return ID2D1Geometry_Tessellate(geometry->u.transformed.src_geometry, transform, tolerance, sink); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_CombineWithGeometry(ID2D1TransformedGeometry *iface, + ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n", + iface, geometry, combine_mode, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_Outline(ID2D1TransformedGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_ComputeArea(ID2D1TransformedGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + D2D1_MATRIX_3X2_F g; + + TRACE("iface %p, transform %p, tolerance %.8e, area %p.\n", iface, transform, tolerance, area); + + g = geometry->transform; + if (transform) + d2d_matrix_multiply(&g, transform); + + return ID2D1Geometry_ComputeArea(geometry->u.transformed.src_geometry, &g, tolerance, area); +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_ComputeLength(ID2D1TransformedGeometry *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length) +{ + FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_ComputePointAtLength(ID2D1TransformedGeometry *iface, + float length, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_POINT_2F *point, + D2D1_POINT_2F *tangent) +{ + FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n", + iface, length, transform, tolerance, point, tangent); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_Widen(ID2D1TransformedGeometry *iface, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_transformed_geometry_GetSourceGeometry(ID2D1TransformedGeometry *iface, + ID2D1Geometry **src_geometry) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + + TRACE("iface %p, src_geometry %p.\n", iface, src_geometry); + + ID2D1Geometry_AddRef(*src_geometry = geometry->u.transformed.src_geometry); +} + +static void STDMETHODCALLTYPE d2d_transformed_geometry_GetTransform(ID2D1TransformedGeometry *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + *transform = geometry->u.transformed.transform; +} + +static const struct ID2D1TransformedGeometryVtbl d2d_transformed_geometry_vtbl = +{ + d2d_transformed_geometry_QueryInterface, + d2d_transformed_geometry_AddRef, + d2d_transformed_geometry_Release, + d2d_transformed_geometry_GetFactory, + d2d_transformed_geometry_GetBounds, + d2d_transformed_geometry_GetWidenedBounds, + d2d_transformed_geometry_StrokeContainsPoint, + d2d_transformed_geometry_FillContainsPoint, + d2d_transformed_geometry_CompareWithGeometry, + d2d_transformed_geometry_Simplify, + d2d_transformed_geometry_Tessellate, + d2d_transformed_geometry_CombineWithGeometry, + d2d_transformed_geometry_Outline, + d2d_transformed_geometry_ComputeArea, + d2d_transformed_geometry_ComputeLength, + d2d_transformed_geometry_ComputePointAtLength, + d2d_transformed_geometry_Widen, + d2d_transformed_geometry_GetSourceGeometry, + d2d_transformed_geometry_GetTransform, +}; + +void d2d_transformed_geometry_init(struct d2d_geometry *geometry, ID2D1Factory *factory, + ID2D1Geometry *src_geometry, const D2D_MATRIX_3X2_F *transform) +{ + struct d2d_geometry *src_impl; + D2D_MATRIX_3X2_F g; + + src_impl = unsafe_impl_from_ID2D1Geometry(src_geometry); + + g = src_impl->transform; + d2d_matrix_multiply(&g, transform); + d2d_geometry_init(geometry, factory, &g, (ID2D1GeometryVtbl *)&d2d_transformed_geometry_vtbl); + ID2D1Geometry_AddRef(geometry->u.transformed.src_geometry = src_geometry); + geometry->u.transformed.transform = *transform; + geometry->fill = src_impl->fill; + geometry->outline = src_impl->outline; +} + +static inline struct d2d_geometry *impl_from_ID2D1GeometryGroup(ID2D1GeometryGroup *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_QueryInterface(ID2D1GeometryGroup *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1GeometryGroup) + || IsEqualGUID(iid, &IID_ID2D1Geometry) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1GeometryGroup_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_geometry_group_AddRef(ID2D1GeometryGroup *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + ULONG refcount = InterlockedIncrement(&geometry->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_geometry_group_Release(ID2D1GeometryGroup *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + ULONG refcount = InterlockedDecrement(&geometry->refcount); + unsigned int i; + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + for (i = 0; i < geometry->u.group.geometry_count; ++i) + ID2D1Geometry_Release(geometry->u.group.src_geometries[i]); + free(geometry->u.group.src_geometries); + d2d_geometry_cleanup(geometry); + free(geometry); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_geometry_group_GetFactory(ID2D1GeometryGroup *iface, + ID2D1Factory **factory) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = geometry->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_GetBounds(ID2D1GeometryGroup *iface, + const D2D1_MATRIX_3X2_F *transform, D2D1_RECT_F *bounds) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + D2D1_RECT_F rect; + unsigned int i; + + TRACE("iface %p, transform %p, bounds %p.\n", iface, transform, bounds); + + bounds->left = FLT_MAX; + bounds->top = FLT_MAX; + bounds->right = -FLT_MAX; + bounds->bottom = -FLT_MAX; + + for (i = 0; i < geometry->u.group.geometry_count; ++i) + { + if (SUCCEEDED(ID2D1Geometry_GetBounds(geometry->u.group.src_geometries[i], transform, &rect))) + d2d_rect_union(bounds, &rect); + } + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_GetWidenedBounds(ID2D1GeometryGroup *iface, + float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, D2D1_RECT_F *bounds) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, bounds %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, bounds); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_StrokeContainsPoint(ID2D1GeometryGroup *iface, + D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, + float tolerance, BOOL *contains) +{ + FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_FillContainsPoint(ID2D1GeometryGroup *iface, + D2D1_POINT_2F point, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) +{ + FIXME("iface %p, point %s, transform %p, tolerance %.8e, contains %p stub!.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_CompareWithGeometry(ID2D1GeometryGroup *iface, + ID2D1Geometry *geometry, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_GEOMETRY_RELATION *relation) +{ + FIXME("iface %p, geometry %p, transform %p, tolerance %.8e, relation %p stub!\n", + iface, geometry, transform, tolerance, relation); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_Simplify(ID2D1GeometryGroup *iface, + D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, option %#x, transform %p, tolerance %.8e, sink %p stub!.\n", + iface, option, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_Tessellate(ID2D1GeometryGroup *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1TessellationSink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_CombineWithGeometry(ID2D1GeometryGroup *iface, + ID2D1Geometry *geometry, D2D1_COMBINE_MODE combine_mode, const D2D1_MATRIX_3X2_F *transform, + float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, geometry %p, combine_mode %#x, transform %p, tolerance %.8e, sink %p stub!\n", + iface, geometry, combine_mode, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_Outline(ID2D1GeometryGroup *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, transform %p, tolerance %.8e, sink %p stub!\n", iface, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_ComputeArea(ID2D1GeometryGroup *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *area) +{ + FIXME("iface %p, transform %p, tolerance %.8e, area %p stub!\n", iface, transform, tolerance, area); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_ComputeLength(ID2D1GeometryGroup *iface, + const D2D1_MATRIX_3X2_F *transform, float tolerance, float *length) +{ + FIXME("iface %p, transform %p, tolerance %.8e, length %p stub!\n", iface, transform, tolerance, length); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_ComputePointAtLength(ID2D1GeometryGroup *iface, + float length, const D2D1_MATRIX_3X2_F *transform, float tolerance, D2D1_POINT_2F *point, + D2D1_POINT_2F *tangent) +{ + FIXME("iface %p, length %.8e, transform %p, tolerance %.8e, point %p, tangent %p stub!\n", + iface, length, transform, tolerance, point, tangent); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_group_Widen(ID2D1GeometryGroup *iface, float stroke_width, + ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, + ID2D1SimplifiedGeometrySink *sink) +{ + FIXME("iface %p, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, sink %p stub!\n", + iface, stroke_width, stroke_style, transform, tolerance, sink); + + return E_NOTIMPL; +} + +static D2D1_FILL_MODE STDMETHODCALLTYPE d2d_geometry_group_GetFillMode(ID2D1GeometryGroup *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + + TRACE("iface %p.\n", iface); + + return geometry->u.group.fill_mode; +} + +static UINT32 STDMETHODCALLTYPE d2d_geometry_group_GetSourceGeometryCount(ID2D1GeometryGroup *iface) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + + TRACE("iface %p.\n", iface); + + return geometry->u.group.geometry_count; +} + +static void STDMETHODCALLTYPE d2d_geometry_group_GetSourceGeometries(ID2D1GeometryGroup *iface, + ID2D1Geometry **geometries, UINT32 geometry_count) +{ + struct d2d_geometry *geometry = impl_from_ID2D1GeometryGroup(iface); + unsigned int i; + + TRACE("iface %p, geometries %p, geometry_count %u.\n", iface, geometries, geometry_count); + + geometry_count = min(geometry_count, geometry->u.group.geometry_count); + for (i = 0; i < geometry_count; ++i) + ID2D1Geometry_AddRef(geometries[i] = geometry->u.group.src_geometries[i]); +} + +static const struct ID2D1GeometryGroupVtbl d2d_geometry_group_vtbl = +{ + d2d_geometry_group_QueryInterface, + d2d_geometry_group_AddRef, + d2d_geometry_group_Release, + d2d_geometry_group_GetFactory, + d2d_geometry_group_GetBounds, + d2d_geometry_group_GetWidenedBounds, + d2d_geometry_group_StrokeContainsPoint, + d2d_geometry_group_FillContainsPoint, + d2d_geometry_group_CompareWithGeometry, + d2d_geometry_group_Simplify, + d2d_geometry_group_Tessellate, + d2d_geometry_group_CombineWithGeometry, + d2d_geometry_group_Outline, + d2d_geometry_group_ComputeArea, + d2d_geometry_group_ComputeLength, + d2d_geometry_group_ComputePointAtLength, + d2d_geometry_group_Widen, + d2d_geometry_group_GetFillMode, + d2d_geometry_group_GetSourceGeometryCount, + d2d_geometry_group_GetSourceGeometries, +}; + +HRESULT d2d_geometry_group_init(struct d2d_geometry *geometry, ID2D1Factory *factory, + D2D1_FILL_MODE fill_mode, ID2D1Geometry **geometries, unsigned int geometry_count) +{ + unsigned int i; + + d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_geometry_group_vtbl); + + if (!(geometry->u.group.src_geometries = calloc(geometry_count, sizeof(*geometries)))) + { + d2d_geometry_cleanup(geometry); + return E_OUTOFMEMORY; + } + + for (i = 0; i < geometry_count; ++i) + { + ID2D1Geometry_AddRef(geometry->u.group.src_geometries[i] = geometries[i]); + } + geometry->u.group.geometry_count = geometry_count; + geometry->u.group.fill_mode = fill_mode; + + return S_OK; +} + +struct d2d_geometry *unsafe_impl_from_ID2D1Geometry(ID2D1Geometry *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_ellipse_geometry_vtbl + || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_path_geometry_vtbl + || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_rectangle_geometry_vtbl + || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_rounded_rectangle_geometry_vtbl + || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_transformed_geometry_vtbl + || iface->lpVtbl == (const ID2D1GeometryVtbl *)&d2d_geometry_group_vtbl); + return CONTAINING_RECORD(iface, struct d2d_geometry, ID2D1Geometry_iface); +} + +static inline struct d2d_geometry_realization *impl_from_ID2D1GeometryRealization( + ID2D1GeometryRealization *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_geometry_realization, ID2D1GeometryRealization_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_geometry_realization_QueryInterface( + ID2D1GeometryRealization *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1GeometryRealization) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1GeometryRealization_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_geometry_realization_AddRef(ID2D1GeometryRealization *iface) +{ + struct d2d_geometry_realization *realization = impl_from_ID2D1GeometryRealization(iface); + ULONG refcount = InterlockedIncrement(&realization->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_geometry_realization_Release(ID2D1GeometryRealization *iface) +{ + struct d2d_geometry_realization *realization = impl_from_ID2D1GeometryRealization(iface); + ULONG refcount = InterlockedDecrement(&realization->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + if (realization->stroke_style) + ID2D1StrokeStyle_Release(realization->stroke_style); + ID2D1Geometry_Release(realization->geometry); + ID2D1Factory_Release(realization->factory); + free(realization); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_geometry_realization_GetFactory(ID2D1GeometryRealization *iface, + ID2D1Factory **factory) +{ + struct d2d_geometry_realization *realization = impl_from_ID2D1GeometryRealization(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = realization->factory); +} + +static const ID2D1GeometryRealizationVtbl d2d_geometry_realization_vtbl = +{ + d2d_geometry_realization_QueryInterface, + d2d_geometry_realization_AddRef, + d2d_geometry_realization_Release, + d2d_geometry_realization_GetFactory, +}; + +HRESULT d2d_geometry_realization_init(struct d2d_geometry_realization *realization, + ID2D1Factory *factory, ID2D1Geometry *geometry) +{ + realization->ID2D1GeometryRealization_iface.lpVtbl = &d2d_geometry_realization_vtbl; + realization->refcount = 1; + ID2D1Factory_AddRef(realization->factory = factory); + ID2D1Geometry_AddRef(realization->geometry = geometry); + + return S_OK; +} + +struct d2d_geometry_realization *unsafe_impl_from_ID2D1GeometryRealization(ID2D1GeometryRealization *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d2d_geometry_realization_vtbl); + return CONTAINING_RECORD(iface, struct d2d_geometry_realization, ID2D1GeometryRealization_iface); +} diff --git a/WineFix/lib/d2d1/src/guids.c b/WineFix/lib/d2d1/src/guids.c new file mode 100644 index 0000000..f8ee2ed --- /dev/null +++ b/WineFix/lib/d2d1/src/guids.c @@ -0,0 +1,15 @@ +/* + * D2D1 GUID definitions + * + * This file instantiates all the GUIDs used by d2d1.dll + */ + +#define COBJMACROS +#define WIDL_C_INLINE_WRAPPERS +#define INITGUID + +#include +#include "d2d1_3.h" +#include "d2d1effectauthor.h" +#include "d3d11_1.h" +#include "dwrite_2.h" diff --git a/WineFix/lib/d2d1/src/hwnd_render_target.c b/WineFix/lib/d2d1/src/hwnd_render_target.c new file mode 100644 index 0000000..dc0dbc6 --- /dev/null +++ b/WineFix/lib/d2d1/src/hwnd_render_target.c @@ -0,0 +1,953 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * Copyright 2016 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_hwnd_render_target *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_hwnd_render_target, ID2D1HwndRenderTarget_iface); +} + +static HRESULT d2d_hwnd_render_target_present(IUnknown *outer_unknown) +{ + struct d2d_hwnd_render_target *render_target = impl_from_IUnknown(outer_unknown); + HRESULT hr; + + if (FAILED(hr = IDXGISwapChain_Present(render_target->swapchain, render_target->sync_interval, 0))) + WARN("Present failed, %#lx.\n", hr); + + return S_OK; +} + +static inline struct d2d_hwnd_render_target *impl_from_ID2D1HwndRenderTarget(ID2D1HwndRenderTarget *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_hwnd_render_target, ID2D1HwndRenderTarget_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_QueryInterface(ID2D1HwndRenderTarget *iface, + REFIID iid, void **out) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1HwndRenderTarget) + || IsEqualGUID(iid, &IID_ID2D1RenderTarget) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1HwndRenderTarget_AddRef(iface); + *out = iface; + return S_OK; + } + + return IUnknown_QueryInterface(render_target->dxgi_inner, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_hwnd_render_target_AddRef(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + ULONG refcount = InterlockedIncrement(&render_target->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_hwnd_render_target_Release(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + ULONG refcount = InterlockedDecrement(&render_target->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + IUnknown_Release(render_target->dxgi_inner); + IDXGISwapChain_Release(render_target->swapchain); + free(render_target); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetFactory(ID2D1HwndRenderTarget *iface, ID2D1Factory **factory) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1RenderTarget_GetFactory(render_target->dxgi_target, factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateBitmap(ID2D1HwndRenderTarget *iface, + D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n", + iface, size.width, size.height, src_data, pitch, desc, bitmap); + + return ID2D1RenderTarget_CreateBitmap(render_target->dxgi_target, size, src_data, pitch, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateBitmapFromWicBitmap(ID2D1HwndRenderTarget *iface, + IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n", + iface, bitmap_source, desc, bitmap); + + return ID2D1RenderTarget_CreateBitmapFromWicBitmap(render_target->dxgi_target, bitmap_source, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateSharedBitmap(ID2D1HwndRenderTarget *iface, + REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n", + iface, debugstr_guid(iid), data, desc, bitmap); + + return ID2D1RenderTarget_CreateSharedBitmap(render_target->dxgi_target, iid, data, desc, bitmap); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateBitmapBrush(ID2D1HwndRenderTarget *iface, + ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, + const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n", + iface, bitmap, bitmap_brush_desc, brush_desc, brush); + + return ID2D1RenderTarget_CreateBitmapBrush(render_target->dxgi_target, + bitmap, bitmap_brush_desc, brush_desc, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateSolidColorBrush(ID2D1HwndRenderTarget *iface, + const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush); + + return ID2D1RenderTarget_CreateSolidColorBrush(render_target->dxgi_target, color, desc, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateGradientStopCollection(ID2D1HwndRenderTarget *iface, + const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, + ID2D1GradientStopCollection **gradient) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n", + iface, stops, stop_count, gamma, extend_mode, gradient); + + return ID2D1RenderTarget_CreateGradientStopCollection(render_target->dxgi_target, + stops, stop_count, gamma, extend_mode, gradient); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateLinearGradientBrush(ID2D1HwndRenderTarget *iface, + const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + return ID2D1RenderTarget_CreateLinearGradientBrush(render_target->dxgi_target, + gradient_brush_desc, brush_desc, gradient, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateRadialGradientBrush(ID2D1HwndRenderTarget *iface, + const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc, + ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n", + iface, gradient_brush_desc, brush_desc, gradient, brush); + + return ID2D1RenderTarget_CreateRadialGradientBrush(render_target->dxgi_target, + gradient_brush_desc, brush_desc, gradient, brush); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateCompatibleRenderTarget(ID2D1HwndRenderTarget *iface, + const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **render_target) +{ + struct d2d_hwnd_render_target *rt = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p,\n", + iface, size, pixel_size, format, options, render_target); + + return ID2D1RenderTarget_CreateCompatibleRenderTarget(rt->dxgi_target, + size, pixel_size, format, options, render_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateLayer(ID2D1HwndRenderTarget *iface, + const D2D1_SIZE_F *size, ID2D1Layer **layer) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, size %p, layer %p.\n", iface, size, layer); + + return ID2D1RenderTarget_CreateLayer(render_target->dxgi_target, size, layer); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_CreateMesh(ID2D1HwndRenderTarget *iface, ID2D1Mesh **mesh) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, mesh %p.\n", iface, mesh); + + return ID2D1RenderTarget_CreateMesh(render_target->dxgi_target, mesh); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawLine(ID2D1HwndRenderTarget *iface, + D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawRectangle(ID2D1HwndRenderTarget *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, rect %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_rect_f(rect), brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillRectangle(ID2D1HwndRenderTarget *iface, + const D2D1_RECT_F *rect, ID2D1Brush *brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, rect %s, brush %p.\n", iface, debug_d2d_rect_f(rect), brush); + + ID2D1RenderTarget_FillRectangle(render_target->dxgi_target, rect, brush); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawRoundedRectangle(ID2D1HwndRenderTarget *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, rect, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawRoundedRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillRoundedRectangle(ID2D1HwndRenderTarget *iface, + const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush); + + ID2D1RenderTarget_FillRoundedRectangle(render_target->dxgi_target, rect, brush); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawEllipse(ID2D1HwndRenderTarget *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, ellipse, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawEllipse(render_target->dxgi_target, ellipse, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillEllipse(ID2D1HwndRenderTarget *iface, + const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush); + + ID2D1RenderTarget_FillEllipse(render_target->dxgi_target, ellipse, brush); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawGeometry(ID2D1HwndRenderTarget *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, geometry, brush, stroke_width, stroke_style); + + ID2D1RenderTarget_DrawGeometry(render_target->dxgi_target, geometry, brush, stroke_width, stroke_style); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillGeometry(ID2D1HwndRenderTarget *iface, + ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush); + + ID2D1RenderTarget_FillGeometry(render_target->dxgi_target, geometry, brush, opacity_brush); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillMesh(ID2D1HwndRenderTarget *iface, + ID2D1Mesh *mesh, ID2D1Brush *brush) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, mesh %p, brush %p.\n", iface, mesh, brush); + + ID2D1RenderTarget_FillMesh(render_target->dxgi_target, mesh, brush); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_FillOpacityMask(ID2D1HwndRenderTarget *iface, + ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content, + const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, mask %p, brush %p, content %#x, dst_rect %s, src_rect %s.\n", + iface, mask, brush, content, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect)); + + ID2D1RenderTarget_FillOpacityMask(render_target->dxgi_target, + mask, brush, content, dst_rect, src_rect); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawBitmap(ID2D1HwndRenderTarget *iface, + ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, + D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, src_rect %s.\n", + iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, debug_d2d_rect_f(src_rect)); + + ID2D1RenderTarget_DrawBitmap(render_target->dxgi_target, + bitmap, dst_rect, opacity, interpolation_mode, src_rect); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawText(ID2D1HwndRenderTarget *iface, + const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect, + ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, " + "brush %p, options %#x, measuring_mode %#x.\n", + iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect), + brush, options, measuring_mode); + + ID2D1RenderTarget_DrawText(render_target->dxgi_target, string, string_len, + text_format, layout_rect, brush, options, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawTextLayout(ID2D1HwndRenderTarget *iface, + D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); + + ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawGlyphRun(ID2D1HwndRenderTarget *iface, + D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, + DWRITE_MEASURING_MODE measuring_mode) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); + + ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target, + baseline_origin, glyph_run, brush, measuring_mode); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTransform(ID2D1HwndRenderTarget *iface, + const D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + ID2D1RenderTarget_SetTransform(render_target->dxgi_target, transform); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetTransform(ID2D1HwndRenderTarget *iface, + D2D1_MATRIX_3X2_F *transform) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, transform %p.\n", iface, transform); + + ID2D1RenderTarget_GetTransform(render_target->dxgi_target, transform); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetAntialiasMode(ID2D1HwndRenderTarget *iface, + D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + ID2D1RenderTarget_SetAntialiasMode(render_target->dxgi_target, antialias_mode); +} + +static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_hwnd_render_target_GetAntialiasMode(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetAntialiasMode(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTextAntialiasMode(ID2D1HwndRenderTarget *iface, + D2D1_TEXT_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode); + + ID2D1RenderTarget_SetTextAntialiasMode(render_target->dxgi_target, antialias_mode); +} + +static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_hwnd_render_target_GetTextAntialiasMode( + ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetTextAntialiasMode(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTextRenderingParams(ID2D1HwndRenderTarget *iface, + IDWriteRenderingParams *text_rendering_params) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + ID2D1RenderTarget_SetTextRenderingParams(render_target->dxgi_target, text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetTextRenderingParams(ID2D1HwndRenderTarget *iface, + IDWriteRenderingParams **text_rendering_params) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + ID2D1RenderTarget_GetTextRenderingParams(render_target->dxgi_target, text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetTags(ID2D1HwndRenderTarget *iface, D2D1_TAG tag1, D2D1_TAG tag2) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2)); + + ID2D1RenderTarget_SetTags(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetTags(ID2D1HwndRenderTarget *iface, D2D1_TAG *tag1, + D2D1_TAG *tag2) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + ID2D1RenderTarget_GetTags(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_PushLayer(ID2D1HwndRenderTarget *iface, + const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, layer_parameters %p, layer %p.\n", iface, layer_parameters, layer); + + ID2D1RenderTarget_PushLayer(render_target->dxgi_target, layer_parameters, layer); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_PopLayer(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_PopLayer(render_target->dxgi_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_Flush(ID2D1HwndRenderTarget *iface, D2D1_TAG *tag1, + D2D1_TAG *tag2) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + return ID2D1RenderTarget_Flush(render_target->dxgi_target, tag1, tag2); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SaveDrawingState(ID2D1HwndRenderTarget *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + ID2D1RenderTarget_SaveDrawingState(render_target->dxgi_target, state_block); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_RestoreDrawingState(ID2D1HwndRenderTarget *iface, + ID2D1DrawingStateBlock *state_block) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, state_block %p.\n", iface, state_block); + + ID2D1RenderTarget_RestoreDrawingState(render_target->dxgi_target, state_block); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_PushAxisAlignedClip(ID2D1HwndRenderTarget *iface, + const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, clip_rect %s, antialias_mode %#x.\n", iface, debug_d2d_rect_f(clip_rect), antialias_mode); + + ID2D1RenderTarget_PushAxisAlignedClip(render_target->dxgi_target, clip_rect, antialias_mode); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_PopAxisAlignedClip(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_PopAxisAlignedClip(render_target->dxgi_target); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_Clear(ID2D1HwndRenderTarget *iface, const D2D1_COLOR_F *color) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, color %p.\n", iface, color); + + ID2D1RenderTarget_Clear(render_target->dxgi_target, color); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_BeginDraw(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + ID2D1RenderTarget_BeginDraw(render_target->dxgi_target); +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_EndDraw(ID2D1HwndRenderTarget *iface, + D2D1_TAG *tag1, D2D1_TAG *tag2) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2); + + return ID2D1RenderTarget_EndDraw(render_target->dxgi_target, tag1, tag2); +} + +static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_hwnd_render_target_GetPixelFormat(ID2D1HwndRenderTarget *iface, + D2D1_PIXEL_FORMAT *format) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, format %p.\n", iface, format); + + *format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target); + return format; +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_SetDpi(ID2D1HwndRenderTarget *iface, float dpi_x, float dpi_y) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y); + + ID2D1RenderTarget_SetDpi(render_target->dxgi_target, dpi_x, dpi_y); +} + +static void STDMETHODCALLTYPE d2d_hwnd_render_target_GetDpi(ID2D1HwndRenderTarget *iface, float *dpi_x, float *dpi_y) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y); + + ID2D1RenderTarget_GetDpi(render_target->dxgi_target, dpi_x, dpi_y); +} + +static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_hwnd_render_target_GetSize(ID2D1HwndRenderTarget *iface, D2D1_SIZE_F *size) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, size %p.\n", iface, size); + + *size = ID2D1RenderTarget_GetSize(render_target->dxgi_target); + return size; +} + +static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_hwnd_render_target_GetPixelSize(ID2D1HwndRenderTarget *iface, + D2D1_SIZE_U *pixel_size) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p, pixel_size %p.\n", iface, pixel_size); + + *pixel_size = ID2D1RenderTarget_GetPixelSize(render_target->dxgi_target); + return pixel_size; +} + +static UINT32 STDMETHODCALLTYPE d2d_hwnd_render_target_GetMaximumBitmapSize(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1RenderTarget_GetMaximumBitmapSize(render_target->dxgi_target); +} + +static BOOL STDMETHODCALLTYPE d2d_hwnd_render_target_IsSupported(ID2D1HwndRenderTarget *iface, + const D2D1_RENDER_TARGET_PROPERTIES *desc) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + const D2D1_RENDER_TARGET_PROPERTIES *target_desc = &render_target->desc; + D2D1_PIXEL_FORMAT pixel_format; + + TRACE("iface %p, desc %p.\n", iface, desc); + + if (desc->type != D2D1_RENDER_TARGET_TYPE_DEFAULT + && target_desc->type != desc->type) + { + return FALSE; + } + + pixel_format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target); + + if (desc->pixelFormat.format != DXGI_FORMAT_UNKNOWN + && pixel_format.format != desc->pixelFormat.format) + { + return FALSE; + } + + if (desc->pixelFormat.alphaMode != D2D1_ALPHA_MODE_UNKNOWN + && pixel_format.alphaMode != desc->pixelFormat.alphaMode) + { + return FALSE; + } + + return (target_desc->usage & desc->usage) == desc->usage; +} + +static D2D1_WINDOW_STATE STDMETHODCALLTYPE d2d_hwnd_render_target_CheckWindowState(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return IDXGISwapChain_Present(render_target->swapchain, render_target->sync_interval, DXGI_PRESENT_TEST) == + DXGI_STATUS_OCCLUDED ? D2D1_WINDOW_STATE_OCCLUDED : D2D1_WINDOW_STATE_NONE; +} + +static HRESULT STDMETHODCALLTYPE d2d_hwnd_render_target_Resize(ID2D1HwndRenderTarget *iface, const D2D1_SIZE_U *size) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + IDXGISurface1 *dxgi_surface; + ID2D1DeviceContext *context; + ID2D1Bitmap1 *bitmap; + HRESULT hr; + + TRACE("iface %p, width %u, height %u.\n", iface, size->width, size->height); + + ID2D1RenderTarget_QueryInterface(render_target->dxgi_target, &IID_ID2D1DeviceContext, (void **)&context); + ID2D1DeviceContext_SetTarget(context, NULL); + + if (SUCCEEDED(hr = IDXGISwapChain_ResizeBuffers(render_target->swapchain, 1, size->width, size->height, + DXGI_FORMAT_UNKNOWN, 0))) + { + if (FAILED(hr = IDXGISwapChain_GetBuffer(render_target->swapchain, 0, &IID_IDXGISurface1, + (void **)&dxgi_surface))) + { + WARN("Failed to get buffer, hr %#lx.\n", hr); + ID2D1DeviceContext_Release(context); + return hr; + } + + hr = ID2D1DeviceContext_CreateBitmapFromDxgiSurface(context, (IDXGISurface *)dxgi_surface, NULL, &bitmap); + IDXGISurface1_Release(dxgi_surface); + if (FAILED(hr)) + { + WARN("Failed to create target bitmap, hr %#lx.\n", hr); + ID2D1DeviceContext_Release(context); + return hr; + } + + ID2D1DeviceContext_SetTarget(context, (ID2D1Image *)bitmap); + ID2D1Bitmap1_Release(bitmap); + } + + ID2D1DeviceContext_Release(context); + + return hr; +} + +static HWND STDMETHODCALLTYPE d2d_hwnd_render_target_GetHwnd(ID2D1HwndRenderTarget *iface) +{ + struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); + + TRACE("iface %p.\n", iface); + + return render_target->hwnd; +} + +static const struct ID2D1HwndRenderTargetVtbl d2d_hwnd_render_target_vtbl = +{ + d2d_hwnd_render_target_QueryInterface, + d2d_hwnd_render_target_AddRef, + d2d_hwnd_render_target_Release, + d2d_hwnd_render_target_GetFactory, + d2d_hwnd_render_target_CreateBitmap, + d2d_hwnd_render_target_CreateBitmapFromWicBitmap, + d2d_hwnd_render_target_CreateSharedBitmap, + d2d_hwnd_render_target_CreateBitmapBrush, + d2d_hwnd_render_target_CreateSolidColorBrush, + d2d_hwnd_render_target_CreateGradientStopCollection, + d2d_hwnd_render_target_CreateLinearGradientBrush, + d2d_hwnd_render_target_CreateRadialGradientBrush, + d2d_hwnd_render_target_CreateCompatibleRenderTarget, + d2d_hwnd_render_target_CreateLayer, + d2d_hwnd_render_target_CreateMesh, + d2d_hwnd_render_target_DrawLine, + d2d_hwnd_render_target_DrawRectangle, + d2d_hwnd_render_target_FillRectangle, + d2d_hwnd_render_target_DrawRoundedRectangle, + d2d_hwnd_render_target_FillRoundedRectangle, + d2d_hwnd_render_target_DrawEllipse, + d2d_hwnd_render_target_FillEllipse, + d2d_hwnd_render_target_DrawGeometry, + d2d_hwnd_render_target_FillGeometry, + d2d_hwnd_render_target_FillMesh, + d2d_hwnd_render_target_FillOpacityMask, + d2d_hwnd_render_target_DrawBitmap, + d2d_hwnd_render_target_DrawText, + d2d_hwnd_render_target_DrawTextLayout, + d2d_hwnd_render_target_DrawGlyphRun, + d2d_hwnd_render_target_SetTransform, + d2d_hwnd_render_target_GetTransform, + d2d_hwnd_render_target_SetAntialiasMode, + d2d_hwnd_render_target_GetAntialiasMode, + d2d_hwnd_render_target_SetTextAntialiasMode, + d2d_hwnd_render_target_GetTextAntialiasMode, + d2d_hwnd_render_target_SetTextRenderingParams, + d2d_hwnd_render_target_GetTextRenderingParams, + d2d_hwnd_render_target_SetTags, + d2d_hwnd_render_target_GetTags, + d2d_hwnd_render_target_PushLayer, + d2d_hwnd_render_target_PopLayer, + d2d_hwnd_render_target_Flush, + d2d_hwnd_render_target_SaveDrawingState, + d2d_hwnd_render_target_RestoreDrawingState, + d2d_hwnd_render_target_PushAxisAlignedClip, + d2d_hwnd_render_target_PopAxisAlignedClip, + d2d_hwnd_render_target_Clear, + d2d_hwnd_render_target_BeginDraw, + d2d_hwnd_render_target_EndDraw, + d2d_hwnd_render_target_GetPixelFormat, + d2d_hwnd_render_target_SetDpi, + d2d_hwnd_render_target_GetDpi, + d2d_hwnd_render_target_GetSize, + d2d_hwnd_render_target_GetPixelSize, + d2d_hwnd_render_target_GetMaximumBitmapSize, + d2d_hwnd_render_target_IsSupported, + d2d_hwnd_render_target_CheckWindowState, + d2d_hwnd_render_target_Resize, + d2d_hwnd_render_target_GetHwnd +}; + +static const struct d2d_device_context_ops d2d_hwnd_render_target_ops = +{ + d2d_hwnd_render_target_present, +}; + +HRESULT d2d_hwnd_render_target_init(struct d2d_hwnd_render_target *render_target, ID2D1Factory1 *factory, + ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc, + const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwnd_rt_desc) +{ + D2D1_RENDER_TARGET_PROPERTIES dxgi_rt_desc; + DXGI_SWAP_CHAIN_DESC swapchain_desc; + IDXGIAdapter *dxgi_adapter; + IDXGIFactory *dxgi_factory; + IDXGISurface *dxgi_surface; + IDXGIDevice *dxgi_device; + ID2D1Device *device; + HRESULT hr; + + if (!IsWindow(hwnd_rt_desc->hwnd)) + return HRESULT_FROM_WIN32(ERROR_INVALID_WINDOW_HANDLE); + + render_target->ID2D1HwndRenderTarget_iface.lpVtbl = &d2d_hwnd_render_target_vtbl; + render_target->hwnd = hwnd_rt_desc->hwnd; + render_target->sync_interval = hwnd_rt_desc->presentOptions & D2D1_PRESENT_OPTIONS_IMMEDIATELY ? 0 : 1; + + if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device))) + { + WARN("Failed to get IDXGIDevice interface, hr %#lx.\n", hr); + return hr; + } + + hr = IDXGIDevice_GetAdapter(dxgi_device, &dxgi_adapter); + IDXGIDevice_Release(dxgi_device); + if (FAILED(hr)) + { + WARN("Failed to get IDXGIAdapter interface, hr %#lx.\n", hr); + return hr; + } + + hr = IDXGIAdapter_GetParent(dxgi_adapter, &IID_IDXGIFactory, (void **)&dxgi_factory); + IDXGIAdapter_Release(dxgi_adapter); + if (FAILED(hr)) + { + WARN("Failed to get IDXGIFactory interface, hr %#lx.\n", hr); + return hr; + } + + dxgi_rt_desc = *desc; + if (dxgi_rt_desc.dpiX == 0.0f && dxgi_rt_desc.dpiY == 0.0f) + ID2D1Factory1_GetDesktopDpi(factory, &dxgi_rt_desc.dpiX, &dxgi_rt_desc.dpiY); + + if (dxgi_rt_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN) + dxgi_rt_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM; + + if (dxgi_rt_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN) + dxgi_rt_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE; + + if (dxgi_rt_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_STRAIGHT) + { + IDXGIFactory_Release(dxgi_factory); + WARN("Alpha mode %u is not supported.\n", dxgi_rt_desc.pixelFormat.alphaMode); + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; + } + + render_target->desc = dxgi_rt_desc; + /* FIXME: should be resolved to either HW or SW type. */ + if (render_target->desc.type == D2D1_RENDER_TARGET_TYPE_DEFAULT) + render_target->desc.type = D2D1_RENDER_TARGET_TYPE_HARDWARE; + + swapchain_desc.BufferDesc.Width = hwnd_rt_desc->pixelSize.width; + swapchain_desc.BufferDesc.Height = hwnd_rt_desc->pixelSize.height; + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 1; + swapchain_desc.BufferDesc.Format = dxgi_rt_desc.pixelFormat.format; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = 1; + swapchain_desc.OutputWindow = hwnd_rt_desc->hwnd; + swapchain_desc.Windowed = TRUE; + swapchain_desc.SwapEffect = hwnd_rt_desc->presentOptions & D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS ? + DXGI_SWAP_EFFECT_SEQUENTIAL : DXGI_SWAP_EFFECT_DISCARD; + swapchain_desc.Flags = 0; + if (desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE) + swapchain_desc.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE; + + hr = IDXGIFactory_CreateSwapChain(dxgi_factory, (IUnknown *)d3d_device, &swapchain_desc, &render_target->swapchain); + IDXGIFactory_Release(dxgi_factory); + if (FAILED(hr)) + { + WARN("Failed to create a swapchain, hr %#lx.\n", hr); + return hr; + } + + if (FAILED(hr = IDXGISwapChain_GetBuffer(render_target->swapchain, 0, &IID_IDXGISurface, (void **)&dxgi_surface))) + { + WARN("Failed to get buffer, hr %#lx.\n", hr); + IDXGISwapChain_Release(render_target->swapchain); + return hr; + } + + render_target->ID2D1HwndRenderTarget_iface.lpVtbl = &d2d_hwnd_render_target_vtbl; + + if (FAILED(hr = IDXGISurface_GetDevice(dxgi_surface, &IID_IDXGIDevice, (void **)&dxgi_device))) + { + WARN("Failed to get DXGI device, hr %#lx.\n", hr); + IDXGISurface_Release(dxgi_surface); + IDXGISwapChain_Release(render_target->swapchain); + return hr; + } + + hr = d2d_factory_create_device(factory, dxgi_device, false, &IID_ID2D1Device, (void **)&device); + IDXGIDevice_Release(dxgi_device); + if (FAILED(hr)) + { + WARN("Failed to create D2D device, hr %#lx.\n", hr); + IDXGISurface_Release(dxgi_surface); + IDXGISwapChain_Release(render_target->swapchain); + return hr; + } + + hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device), dxgi_surface, + (IUnknown *)&render_target->ID2D1HwndRenderTarget_iface, &d2d_hwnd_render_target_ops, + &dxgi_rt_desc, (void **)&render_target->dxgi_inner); + IDXGISurface_Release(dxgi_surface); + ID2D1Device_Release(device); + if (FAILED(hr)) + { + WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr); + IDXGISwapChain_Release(render_target->swapchain); + return hr; + } + + if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner, + &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target))) + { + WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr); + IUnknown_Release(render_target->dxgi_inner); + IDXGISwapChain_Release(render_target->swapchain); + return hr; + } + + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/layer.c b/WineFix/lib/d2d1/src/layer.c new file mode 100644 index 0000000..eead61d --- /dev/null +++ b/WineFix/lib/d2d1/src/layer.c @@ -0,0 +1,115 @@ +/* + * Copyright 2017 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_layer *impl_from_ID2D1Layer(ID2D1Layer *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_layer, ID2D1Layer_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_layer_QueryInterface(ID2D1Layer *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1Layer) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Layer_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_layer_AddRef(ID2D1Layer *iface) +{ + struct d2d_layer *layer = impl_from_ID2D1Layer(iface); + ULONG refcount = InterlockedIncrement(&layer->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_layer_Release(ID2D1Layer *iface) +{ + struct d2d_layer *layer = impl_from_ID2D1Layer(iface); + ULONG refcount = InterlockedDecrement(&layer->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1Factory_Release(layer->factory); + free(layer); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_layer_GetFactory(ID2D1Layer *iface, ID2D1Factory **factory) +{ + struct d2d_layer *layer = impl_from_ID2D1Layer(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = layer->factory); +} + +static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_layer_GetSize(ID2D1Layer *iface, D2D1_SIZE_F *size) +{ + struct d2d_layer *layer = impl_from_ID2D1Layer(iface); + + TRACE("iface %p, size %p.\n", iface, size); + + *size = layer->size; + return size; +} + +static const struct ID2D1LayerVtbl d2d_layer_vtbl = +{ + d2d_layer_QueryInterface, + d2d_layer_AddRef, + d2d_layer_Release, + d2d_layer_GetFactory, + d2d_layer_GetSize, +}; + +HRESULT d2d_layer_create(ID2D1Factory *factory, const D2D1_SIZE_F *size, struct d2d_layer **layer) +{ + if (!(*layer = calloc(1, sizeof(**layer)))) + return E_OUTOFMEMORY; + + (*layer)->ID2D1Layer_iface.lpVtbl = &d2d_layer_vtbl; + (*layer)->refcount = 1; + ID2D1Factory_AddRef((*layer)->factory = factory); + if (size) + (*layer)->size = *size; + + TRACE("Created layer %p.\n", *layer); + + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/mesh.c b/WineFix/lib/d2d1/src/mesh.c new file mode 100644 index 0000000..a782e01 --- /dev/null +++ b/WineFix/lib/d2d1/src/mesh.c @@ -0,0 +1,206 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_mesh *impl_from_ID2D1Mesh(ID2D1Mesh *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_mesh, ID2D1Mesh_iface); +} + +static inline struct d2d_mesh *impl_from_ID2D1TessellationSink(ID2D1TessellationSink *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_mesh, ID2D1TessellationSink_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_mesh_QueryInterface(ID2D1Mesh *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1Mesh) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Mesh_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_mesh_AddRef(ID2D1Mesh *iface) +{ + struct d2d_mesh *mesh = impl_from_ID2D1Mesh(iface); + ULONG refcount = InterlockedIncrement(&mesh->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_mesh_Release(ID2D1Mesh *iface) +{ + struct d2d_mesh *mesh = impl_from_ID2D1Mesh(iface); + ULONG refcount = InterlockedDecrement(&mesh->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1Factory_Release(mesh->factory); + free(mesh->triangles); + free(mesh); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_mesh_GetFactory(ID2D1Mesh *iface, ID2D1Factory **factory) +{ + struct d2d_mesh *mesh = impl_from_ID2D1Mesh(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = mesh->factory); +} + +static HRESULT STDMETHODCALLTYPE d2d_mesh_Open(ID2D1Mesh *iface, ID2D1TessellationSink **sink) +{ + struct d2d_mesh *mesh = impl_from_ID2D1Mesh(iface); + + TRACE("iface %p, sink %p.\n", iface, sink); + + *sink = NULL; + + if (mesh->state != D2D_MESH_STATE_INITIAL) + return D2DERR_WRONG_STATE; + + *sink = &mesh->ID2D1TessellationSink_iface; + ID2D1TessellationSink_AddRef(*sink); + + mesh->state = D2D_MESH_STATE_OPEN; + + return S_OK; +} + +static const struct ID2D1MeshVtbl d2d_mesh_vtbl = +{ + d2d_mesh_QueryInterface, + d2d_mesh_AddRef, + d2d_mesh_Release, + d2d_mesh_GetFactory, + d2d_mesh_Open, +}; + +static HRESULT STDMETHODCALLTYPE d2d_mesh_sink_QueryInterface(ID2D1TessellationSink *iface, + REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1TessellationSink) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1TessellationSink_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_mesh_sink_AddRef(ID2D1TessellationSink *iface) +{ + struct d2d_mesh *mesh = impl_from_ID2D1TessellationSink(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1Mesh_AddRef(&mesh->ID2D1Mesh_iface); +} + +static ULONG STDMETHODCALLTYPE d2d_mesh_sink_Release(ID2D1TessellationSink *iface) +{ + struct d2d_mesh *mesh = impl_from_ID2D1TessellationSink(iface); + + TRACE("iface %p.\n", iface); + + return ID2D1Mesh_Release(&mesh->ID2D1Mesh_iface); +} + +static void STDMETHODCALLTYPE d2d_mesh_sink_AddTriangles(ID2D1TessellationSink *iface, + const D2D1_TRIANGLE *triangles, UINT32 count) +{ + struct d2d_mesh *mesh = impl_from_ID2D1TessellationSink(iface); + + TRACE("iface %p, triangles %p, count %u.\n", iface, triangles, count); + + if (!d2d_array_reserve((void **)&mesh->triangles, &mesh->size, + mesh->count + count, sizeof(*mesh->triangles))) + { + WARN("Failed to grow mesh triangles array.\n"); + return; + } + + memcpy(&mesh->triangles[mesh->count], triangles, count * sizeof(*triangles)); + mesh->count += count; +} + +static HRESULT STDMETHODCALLTYPE d2d_mesh_sink_Close(ID2D1TessellationSink *iface) +{ + struct d2d_mesh *mesh = impl_from_ID2D1TessellationSink(iface); + + TRACE("iface %p.\n", iface); + + if (mesh->state != D2D_MESH_STATE_OPEN) + return D2DERR_WRONG_STATE; + + mesh->state = D2D_MESH_STATE_CLOSED; + + return S_OK; +} + +static const ID2D1TessellationSinkVtbl d2d_mesh_sink_vtbl = +{ + d2d_mesh_sink_QueryInterface, + d2d_mesh_sink_AddRef, + d2d_mesh_sink_Release, + d2d_mesh_sink_AddTriangles, + d2d_mesh_sink_Close, +}; + +HRESULT d2d_mesh_create(ID2D1Factory *factory, struct d2d_mesh **mesh) +{ + if (!(*mesh = calloc(1, sizeof(**mesh)))) + return E_OUTOFMEMORY; + + (*mesh)->ID2D1Mesh_iface.lpVtbl = &d2d_mesh_vtbl; + (*mesh)->ID2D1TessellationSink_iface.lpVtbl = &d2d_mesh_sink_vtbl; + (*mesh)->refcount = 1; + ID2D1Factory_AddRef((*mesh)->factory = factory); + + TRACE("Created mesh %p.\n", *mesh); + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/state_block.c b/WineFix/lib/d2d1/src/state_block.c new file mode 100644 index 0000000..770c165 --- /dev/null +++ b/WineFix/lib/d2d1/src/state_block.c @@ -0,0 +1,195 @@ +/* + * Copyright 2015 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_state_block *impl_from_ID2D1DrawingStateBlock1(ID2D1DrawingStateBlock1 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_state_block, ID2D1DrawingStateBlock1_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_state_block_QueryInterface(ID2D1DrawingStateBlock1 *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1DrawingStateBlock1) + || IsEqualGUID(iid, &IID_ID2D1DrawingStateBlock) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1DrawingStateBlock1_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_state_block_AddRef(ID2D1DrawingStateBlock1 *iface) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + ULONG refcount = InterlockedIncrement(&state_block->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_state_block_Release(ID2D1DrawingStateBlock1 *iface) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + ULONG refcount = InterlockedDecrement(&state_block->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + if (state_block->text_rendering_params) + IDWriteRenderingParams_Release(state_block->text_rendering_params); + ID2D1Factory_Release(state_block->factory); + free(state_block); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_state_block_GetFactory(ID2D1DrawingStateBlock1 *iface, ID2D1Factory **factory) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = state_block->factory); +} + +static void STDMETHODCALLTYPE d2d_state_block_GetDescription(ID2D1DrawingStateBlock1 *iface, + D2D1_DRAWING_STATE_DESCRIPTION *desc) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, desc %p.\n", iface, desc); + + memcpy(desc, &state_block->drawing_state, sizeof(*desc)); +} + +static void STDMETHODCALLTYPE d2d_state_block_SetDescription(ID2D1DrawingStateBlock1 *iface, + const D2D1_DRAWING_STATE_DESCRIPTION *desc) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, desc %p.\n", iface, desc); + + memcpy(&state_block->drawing_state, desc, sizeof(*desc)); +} + +static void STDMETHODCALLTYPE d2d_state_block_SetTextRenderingParams(ID2D1DrawingStateBlock1 *iface, + IDWriteRenderingParams *text_rendering_params) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + if (text_rendering_params) + IDWriteRenderingParams_AddRef(text_rendering_params); + if (state_block->text_rendering_params) + IDWriteRenderingParams_Release(state_block->text_rendering_params); + state_block->text_rendering_params = text_rendering_params; +} + +static void STDMETHODCALLTYPE d2d_state_block_GetTextRenderingParams(ID2D1DrawingStateBlock1 *iface, + IDWriteRenderingParams **text_rendering_params) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params); + + if ((*text_rendering_params = state_block->text_rendering_params)) + IDWriteRenderingParams_AddRef(*text_rendering_params); +} + +static void STDMETHODCALLTYPE d2d_state_block_GetDescription1(ID2D1DrawingStateBlock1 *iface, + D2D1_DRAWING_STATE_DESCRIPTION1 *desc) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, desc %p.\n", iface, desc); + + *desc = state_block->drawing_state; +} + +static void STDMETHODCALLTYPE d2d_state_block_SetDescription1(ID2D1DrawingStateBlock1 *iface, + const D2D1_DRAWING_STATE_DESCRIPTION1 *desc) +{ + struct d2d_state_block *state_block = impl_from_ID2D1DrawingStateBlock1(iface); + + TRACE("iface %p, desc %p.\n", iface, desc); + + state_block->drawing_state = *desc; +} + +static const struct ID2D1DrawingStateBlock1Vtbl d2d_state_block_vtbl = +{ + d2d_state_block_QueryInterface, + d2d_state_block_AddRef, + d2d_state_block_Release, + d2d_state_block_GetFactory, + d2d_state_block_GetDescription, + d2d_state_block_SetDescription, + d2d_state_block_SetTextRenderingParams, + d2d_state_block_GetTextRenderingParams, + d2d_state_block_GetDescription1, + d2d_state_block_SetDescription1, +}; + +void d2d_state_block_init(struct d2d_state_block *state_block, ID2D1Factory *factory, + const D2D1_DRAWING_STATE_DESCRIPTION1 *desc, IDWriteRenderingParams *text_rendering_params) +{ + static const D2D1_MATRIX_3X2_F identity = + {{{ + 1.0f, 0.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, + }}}; + + state_block->ID2D1DrawingStateBlock1_iface.lpVtbl = &d2d_state_block_vtbl; + state_block->refcount = 1; + ID2D1Factory_AddRef(state_block->factory = factory); + if (desc) + state_block->drawing_state = *desc; + else + state_block->drawing_state.transform = identity; + if ((state_block->text_rendering_params = text_rendering_params)) + IDWriteRenderingParams_AddRef(state_block->text_rendering_params); +} + +struct d2d_state_block *unsafe_impl_from_ID2D1DrawingStateBlock(ID2D1DrawingStateBlock *iface) +{ + if (!iface) + return NULL; + if (iface->lpVtbl != (ID2D1DrawingStateBlockVtbl *)&d2d_state_block_vtbl) + { + WARN("Unexpected state block vtbl %p.\n", iface->lpVtbl); + return NULL; + } + return CONTAINING_RECORD(iface, struct d2d_state_block, ID2D1DrawingStateBlock1_iface); +} diff --git a/WineFix/lib/d2d1/src/stroke.c b/WineFix/lib/d2d1/src/stroke.c new file mode 100644 index 0000000..fc12d4e --- /dev/null +++ b/WineFix/lib/d2d1/src/stroke.c @@ -0,0 +1,251 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_stroke_style *impl_from_ID2D1StrokeStyle1(ID2D1StrokeStyle1 *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_stroke_style, ID2D1StrokeStyle1_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_stroke_style_QueryInterface(ID2D1StrokeStyle1 *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1StrokeStyle) + || IsEqualGUID(iid, &IID_ID2D1Resource) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1StrokeStyle1_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_stroke_style_AddRef(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + ULONG refcount = InterlockedIncrement(&style->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_stroke_style_Release(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + ULONG refcount = InterlockedDecrement(&style->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + ID2D1Factory_Release(style->factory); + if (style->desc.dashStyle == D2D1_DASH_STYLE_CUSTOM) + free(style->dashes); + free(style); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d2d_stroke_style_GetFactory(ID2D1StrokeStyle1 *iface, ID2D1Factory **factory) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p, factory %p.\n", iface, factory); + + ID2D1Factory_AddRef(*factory = style->factory); +} + +static D2D1_CAP_STYLE STDMETHODCALLTYPE d2d_stroke_style_GetStartCap(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.startCap; +} + +static D2D1_CAP_STYLE STDMETHODCALLTYPE d2d_stroke_style_GetEndCap(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.endCap; +} + +static D2D1_CAP_STYLE STDMETHODCALLTYPE d2d_stroke_style_GetDashCap(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.dashCap; +} + +static float STDMETHODCALLTYPE d2d_stroke_style_GetMiterLimit(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.miterLimit; +} + +static D2D1_LINE_JOIN STDMETHODCALLTYPE d2d_stroke_style_GetLineJoin(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.lineJoin; +} + +static float STDMETHODCALLTYPE d2d_stroke_style_GetDashOffset(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.dashOffset; +} + +static D2D1_DASH_STYLE STDMETHODCALLTYPE d2d_stroke_style_GetDashStyle(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.dashStyle; +} + +static UINT32 STDMETHODCALLTYPE d2d_stroke_style_GetDashesCount(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->dash_count; +} + +static void STDMETHODCALLTYPE d2d_stroke_style_GetDashes(ID2D1StrokeStyle1 *iface, float *dashes, UINT32 dash_count) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p, dashes %p, count %u.\n", iface, dashes, dash_count); + + memcpy(dashes, style->dashes, min(style->dash_count, dash_count) * sizeof(*dashes)); + if (dash_count > style->dash_count) + memset(dashes + style->dash_count, 0, (dash_count - style->dash_count) * sizeof(*dashes)); +} + +static D2D1_STROKE_TRANSFORM_TYPE STDMETHODCALLTYPE d2d_stroke_style_GetStrokeTransformType(ID2D1StrokeStyle1 *iface) +{ + struct d2d_stroke_style *style = impl_from_ID2D1StrokeStyle1(iface); + + TRACE("iface %p.\n", iface); + + return style->desc.transformType; +} + +static const struct ID2D1StrokeStyle1Vtbl d2d_stroke_style_vtbl = +{ + d2d_stroke_style_QueryInterface, + d2d_stroke_style_AddRef, + d2d_stroke_style_Release, + d2d_stroke_style_GetFactory, + d2d_stroke_style_GetStartCap, + d2d_stroke_style_GetEndCap, + d2d_stroke_style_GetDashCap, + d2d_stroke_style_GetMiterLimit, + d2d_stroke_style_GetLineJoin, + d2d_stroke_style_GetDashOffset, + d2d_stroke_style_GetDashStyle, + d2d_stroke_style_GetDashesCount, + d2d_stroke_style_GetDashes, + d2d_stroke_style_GetStrokeTransformType +}; + +struct d2d_stroke_style *unsafe_impl_from_ID2D1StrokeStyle(ID2D1StrokeStyle *iface) +{ + if (!iface) + return NULL; + assert((const struct ID2D1StrokeStyle1Vtbl *)iface->lpVtbl == &d2d_stroke_style_vtbl); + return CONTAINING_RECORD(iface, struct d2d_stroke_style, ID2D1StrokeStyle1_iface); +} + +HRESULT d2d_stroke_style_init(struct d2d_stroke_style *style, ID2D1Factory *factory, + const D2D1_STROKE_STYLE_PROPERTIES1 *desc, const float *dashes, UINT32 dash_count) +{ + static const struct + { + UINT32 dash_count; + float dashes[6]; + } + builtin_dash_styles[] = + { + /* D2D1_DASH_STYLE_SOLID */ { 0 }, + /* D2D1_DASH_STYLE_DASH */ { 2, {2.0f, 2.0f}}, + /* D2D1_DASH_STYLE_DOT */ { 2, {0.0f, 2.0f}}, + /* D2D1_DASH_STYLE_DASH_DOT */ { 4, {2.0f, 2.0f, 0.0f, 2.0f}}, + /* D2D1_DASH_STYLE_DASH_DOT_DOT */ { 6, {2.0f, 2.0f, 0.0f, 2.0f, 0.0f, 2.0f}}, + }; + + if (desc->dashStyle > D2D1_DASH_STYLE_CUSTOM) + return E_INVALIDARG; + + if (desc->transformType != D2D1_STROKE_TRANSFORM_TYPE_NORMAL) + FIXME("transformType %d is not supported\n", desc->transformType); + + style->ID2D1StrokeStyle1_iface.lpVtbl = &d2d_stroke_style_vtbl; + style->refcount = 1; + + if (desc->dashStyle == D2D1_DASH_STYLE_CUSTOM) + { + if (!dashes || !dash_count) + return E_INVALIDARG; + + if (!(style->dashes = calloc(dash_count, sizeof(*style->dashes)))) + return E_OUTOFMEMORY; + memcpy(style->dashes, dashes, dash_count * sizeof(*style->dashes)); + style->dash_count = dash_count; + } + else + { + if (dashes) + return E_INVALIDARG; + + style->dashes = (float *)builtin_dash_styles[desc->dashStyle].dashes; + style->dash_count = builtin_dash_styles[desc->dashStyle].dash_count; + } + + ID2D1Factory_AddRef(style->factory = factory); + style->desc = *desc; + + return S_OK; +} diff --git a/WineFix/lib/d2d1/src/stubs.c b/WineFix/lib/d2d1/src/stubs.c new file mode 100644 index 0000000..cab3c60 --- /dev/null +++ b/WineFix/lib/d2d1/src/stubs.c @@ -0,0 +1,33 @@ +/* + * Compatibility stubs for missing C runtime functions + */ + +#include +#include +#include +#include +#include + +/* wcsdup might not be available in all MinGW distributions */ +#ifndef _WIN32 +wchar_t *wcsdup(const wchar_t *str) +{ + size_t len; + wchar_t *copy; + + if (!str) return NULL; + + len = wcslen(str) + 1; + copy = malloc(len * sizeof(wchar_t)); + if (copy) + memcpy(copy, str, len * sizeof(wchar_t)); + + return copy; +} +#endif + +/* strtof - provide implementation if missing */ +float strtof(const char *str, char **endptr) +{ + return (float)strtod(str, endptr); +} diff --git a/WineFix/lib/d2d1/src/version.rc b/WineFix/lib/d2d1/src/version.rc new file mode 100644 index 0000000..28990e4 --- /dev/null +++ b/WineFix/lib/d2d1/src/version.rc @@ -0,0 +1,33 @@ +/* + * D2D1.DLL Version Resource + * Wine 10.18 + */ + +1 VERSIONINFO + FILEVERSION 6,2,9200,16765 + PRODUCTVERSION 10,18,0,0 + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS 0x40004L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", "Wine Project" + VALUE "FileDescription", "Wine Direct2D" + VALUE "FileVersion", "6.2.9200.16765" + VALUE "InternalName", "d2d1.dll" + VALUE "LegalCopyright", "Copyright (c) Wine Project" + VALUE "OriginalFilename", "d2d1.dll" + VALUE "ProductName", "Wine" + VALUE "ProductVersion", "10.18" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 0x4b0 + END +END diff --git a/WineFix/lib/d2d1/src/wic_render_target.c b/WineFix/lib/d2d1/src/wic_render_target.c new file mode 100644 index 0000000..c0720e6 --- /dev/null +++ b/WineFix/lib/d2d1/src/wic_render_target.c @@ -0,0 +1,312 @@ +/* + * Copyright 2014 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d2d1_private.h" +#include "initguid.h" +#include "wincodec.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_wic_render_target *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_wic_render_target, IUnknown_iface); +} + +static HRESULT d2d_wic_render_target_present(IUnknown *outer_unknown) +{ + struct d2d_wic_render_target *render_target = impl_from_IUnknown(outer_unknown); + D3D10_MAPPED_TEXTURE2D mapped_texture; + ID3D10Resource *src_resource; + IWICBitmapLock *bitmap_lock; + UINT dst_size, dst_pitch; + ID3D10Device *device; + WICRect dst_rect; + BYTE *src, *dst; + unsigned int i; + HRESULT hr; + + if (FAILED(hr = IDXGISurface_QueryInterface(render_target->dxgi_surface, + &IID_ID3D10Resource, (void **)&src_resource))) + { + ERR("Failed to get source resource interface, hr %#lx.\n", hr); + goto end; + } + + ID3D10Texture2D_GetDevice(render_target->readback_texture, &device); + ID3D10Device_CopyResource(device, (ID3D10Resource *)render_target->readback_texture, src_resource); + ID3D10Device_Release(device); + ID3D10Resource_Release(src_resource); + + dst_rect.X = 0; + dst_rect.Y = 0; + dst_rect.Width = render_target->width; + dst_rect.Height = render_target->height; + if (FAILED(hr = IWICBitmap_Lock(render_target->bitmap, &dst_rect, WICBitmapLockWrite, &bitmap_lock))) + { + ERR("Failed to lock destination bitmap, hr %#lx.\n", hr); + goto end; + } + + if (FAILED(hr = IWICBitmapLock_GetDataPointer(bitmap_lock, &dst_size, &dst))) + { + ERR("Failed to get data pointer, hr %#lx.\n", hr); + IWICBitmapLock_Release(bitmap_lock); + goto end; + } + + if (FAILED(hr = IWICBitmapLock_GetStride(bitmap_lock, &dst_pitch))) + { + ERR("Failed to get stride, hr %#lx.\n", hr); + IWICBitmapLock_Release(bitmap_lock); + goto end; + } + + if (FAILED(hr = ID3D10Texture2D_Map(render_target->readback_texture, 0, D3D10_MAP_READ, 0, &mapped_texture))) + { + ERR("Failed to map readback texture, hr %#lx.\n", hr); + IWICBitmapLock_Release(bitmap_lock); + goto end; + } + + src = mapped_texture.pData; + + for (i = 0; i < render_target->height; ++i) + { + memcpy(dst, src, render_target->bpp * render_target->width); + src += mapped_texture.RowPitch; + dst += dst_pitch; + } + + ID3D10Texture2D_Unmap(render_target->readback_texture, 0); + IWICBitmapLock_Release(bitmap_lock); + +end: + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_QueryInterface(IUnknown *iface, REFIID iid, void **out) +{ + struct d2d_wic_render_target *render_target = impl_from_IUnknown(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + return IUnknown_QueryInterface(render_target->dxgi_inner, iid, out); +} + +static ULONG STDMETHODCALLTYPE d2d_wic_render_target_AddRef(IUnknown *iface) +{ + struct d2d_wic_render_target *render_target = impl_from_IUnknown(iface); + ULONG refcount = InterlockedIncrement(&render_target->refcount); + + TRACE("%p increasing refcount to %lu.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_wic_render_target_Release(IUnknown *iface) +{ + struct d2d_wic_render_target *render_target = impl_from_IUnknown(iface); + ULONG refcount = InterlockedDecrement(&render_target->refcount); + + TRACE("%p decreasing refcount to %lu.\n", iface, refcount); + + if (!refcount) + { + IWICBitmap_Release(render_target->bitmap); + ID3D10Texture2D_Release(render_target->readback_texture); + IUnknown_Release(render_target->dxgi_inner); + IDXGISurface_Release(render_target->dxgi_surface); + free(render_target); + } + + return refcount; +} + +static const struct IUnknownVtbl d2d_wic_render_target_vtbl = +{ + d2d_wic_render_target_QueryInterface, + d2d_wic_render_target_AddRef, + d2d_wic_render_target_Release, +}; + +static const struct d2d_device_context_ops d2d_wic_render_target_ops = +{ + d2d_wic_render_target_present, +}; + +static HRESULT d2d_wic_resolve_pixel_format(D2D1_PIXEL_FORMAT *pixel_format, + const WICPixelFormatGUID *wic_format) +{ + static const struct + { + const WICPixelFormatGUID *wic_format; + D2D1_PIXEL_FORMAT pixel_format; + } + formats[] = + { + { &GUID_WICPixelFormat32bppBGR, { DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE } }, + { &GUID_WICPixelFormat32bppRGB, { DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_IGNORE } }, + { &GUID_WICPixelFormat32bppPBGRA, { DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED } }, + { &GUID_WICPixelFormat32bppPRGBA, { DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED } }, + }; + + if (pixel_format->format != DXGI_FORMAT_UNKNOWN && pixel_format->alphaMode != D2D1_ALPHA_MODE_UNKNOWN) + return S_OK; + + for (int i = 0; i < ARRAY_SIZE(formats); ++i) + { + if (IsEqualGUID(formats[i].wic_format, wic_format)) + { + if (pixel_format->format == DXGI_FORMAT_UNKNOWN) + pixel_format->format = formats[i].pixel_format.format; + if (pixel_format->alphaMode == D2D1_ALPHA_MODE_UNKNOWN) + pixel_format->alphaMode = formats[i].pixel_format.alphaMode; + return S_OK; + } + } + + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; +} + +HRESULT d2d_wic_render_target_init(struct d2d_wic_render_target *render_target, ID2D1Factory1 *factory, + ID3D10Device1 *d3d_device, IWICBitmap *bitmap, const D2D1_RENDER_TARGET_PROPERTIES *desc) +{ + D2D1_RENDER_TARGET_PROPERTIES rt_desc; + D3D10_TEXTURE2D_DESC texture_desc; + WICPixelFormatGUID bitmap_format; + ID3D10Texture2D *texture; + IDXGIDevice *dxgi_device; + ID2D1Device *device; + HRESULT hr; + + render_target->IUnknown_iface.lpVtbl = &d2d_wic_render_target_vtbl; + + if (FAILED(hr = IWICBitmap_GetSize(bitmap, &render_target->width, &render_target->height))) + { + WARN("Failed to get bitmap dimensions, hr %#lx.\n", hr); + return hr; + } + + if (FAILED(hr = IWICBitmap_GetPixelFormat(bitmap, &bitmap_format))) + { + WARN("Failed to get bitmap format, hr %#lx.\n", hr); + return hr; + } + + rt_desc = *desc; + if (FAILED(hr = d2d_wic_resolve_pixel_format(&rt_desc.pixelFormat, &bitmap_format))) + { + WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&bitmap_format)); + return hr; + } + + texture_desc.Width = render_target->width; + texture_desc.Height = render_target->height; + texture_desc.MipLevels = 1; + texture_desc.ArraySize = 1; + texture_desc.Format = rt_desc.pixelFormat.format; + + switch (texture_desc.Format) + { + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM: + render_target->bpp = 4; + break; + + default: + FIXME("Unhandled format %#x.\n", texture_desc.Format); + return D2DERR_UNSUPPORTED_PIXEL_FORMAT; + } + + texture_desc.SampleDesc.Count = 1; + texture_desc.SampleDesc.Quality = 0; + texture_desc.Usage = D3D10_USAGE_DEFAULT; + texture_desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE; + texture_desc.CPUAccessFlags = 0; + texture_desc.MiscFlags = desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE ? + D3D10_RESOURCE_MISC_GDI_COMPATIBLE : 0; + + if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &texture))) + { + WARN("Failed to create texture, hr %#lx.\n", hr); + return hr; + } + + hr = ID3D10Texture2D_QueryInterface(texture, &IID_IDXGISurface, (void **)&render_target->dxgi_surface); + ID3D10Texture2D_Release(texture); + if (FAILED(hr)) + { + WARN("Failed to get DXGI surface interface, hr %#lx.\n", hr); + return hr; + } + + texture_desc.Usage = D3D10_USAGE_STAGING; + texture_desc.BindFlags = 0; + texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ; + texture_desc.MiscFlags = 0; + + if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &render_target->readback_texture))) + { + WARN("Failed to create readback texture, hr %#lx.\n", hr); + IDXGISurface_Release(render_target->dxgi_surface); + return hr; + } + + if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device))) + { + WARN("Failed to get DXGI device, hr %#lx.\n", hr); + IDXGISurface_Release(render_target->dxgi_surface); + return hr; + } + + hr = d2d_factory_create_device(factory, dxgi_device, false, &IID_ID2D1Device, (void **)&device); + IDXGIDevice_Release(dxgi_device); + if (FAILED(hr)) + { + WARN("Failed to create D2D device, hr %#lx.\n", hr); + IDXGISurface_Release(render_target->dxgi_surface); + return hr; + } + + hr = d2d_d3d_create_render_target(unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device), + render_target->dxgi_surface, &render_target->IUnknown_iface, + &d2d_wic_render_target_ops, &rt_desc, (void **)&render_target->dxgi_inner); + ID2D1Device_Release(device); + if (FAILED(hr)) + { + WARN("Failed to create DXGI surface render target, hr %#lx.\n", hr); + ID3D10Texture2D_Release(render_target->readback_texture); + IDXGISurface_Release(render_target->dxgi_surface); + return hr; + } + + if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner, + &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target))) + { + WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#lx.\n", hr); + IUnknown_Release(render_target->dxgi_inner); + ID3D10Texture2D_Release(render_target->readback_texture); + IDXGISurface_Release(render_target->dxgi_surface); + return hr; + } + + render_target->bitmap = bitmap; + IWICBitmap_AddRef(bitmap); + + return S_OK; +} diff --git a/build.sh b/build.sh index c0f720a..c56a588 100755 --- a/build.sh +++ b/build.sh @@ -15,16 +15,27 @@ echo "========================================" echo # Build .NET projects -echo "[1/2] Building .NET projects..." +echo "[1/3] Building .NET projects..." dotnet build -c "$CONFIGURATION" echo # Build AffinityBootstrap -echo "[2/2] Building AffinityBootstrap..." +echo "[2/3] Building AffinityBootstrap..." cd AffinityBootstrap bash build.sh cd .. +# Build d2d1.dll for Wine (x86_64-unix) +echo "[3/3] Building d2d1.dll (Wine native)..." +cd WineFix/lib/d2d1 +if command -v winegcc &> /dev/null; then + make TARGET=x86_64-unix +else + echo "Warning: winegcc not found. Skipping d2d1.dll build." + echo "Install wine-devel to build d2d1.dll for Wine." +fi +cd ../../.. + echo echo "========================================" echo "Build completed successfully!" diff --git a/package-release.sh b/package-release.sh index 3570295..279e198 100755 --- a/package-release.sh +++ b/package-release.sh @@ -101,6 +101,14 @@ cp "README.md" "$WINEFIX_TEMP/" cp "WineFix/LICENSE" "$WINEFIX_TEMP/" cp "WineFix/bin/x64/$CONFIGURATION/net48/win-x64/WineFix.dll" "$WINEFIX_TEMP/plugins/" +# Copy d2d1.dll (Wine native) if it exists +if [ -f "WineFix/lib/d2d1/build/x86_64-unix/d2d1.dll.so" ]; then + cp "WineFix/lib/d2d1/build/x86_64-unix/d2d1.dll.so" "$WINEFIX_TEMP/d2d1.dll" + echo "Included d2d1.dll (Wine native)" +else + echo "Warning: d2d1.dll.so not found. Skipping d2d1.dll in WineFix package." +fi + # Create zip (cd "$WINEFIX_TEMP" && zip -q -r "../winefix-v$WINEFIX_VERSION.zip" *) rm -rf "$WINEFIX_TEMP" @@ -119,6 +127,14 @@ cp "AffinityHook/bin/x64/$CONFIGURATION/net48/win-x64/AffinityHook.exe" "$COMBIN cp "AffinityPluginLoader/bin/x64/$CONFIGURATION/net48/win-x64/AffinityPluginLoader.dll" "$COMBINED_TEMP/" cp "WineFix/bin/x64/$CONFIGURATION/net48/win-x64/WineFix.dll" "$COMBINED_TEMP/plugins/" +# Copy d2d1.dll (Wine native) if it exists +if [ -f "WineFix/lib/d2d1/build/x86_64-unix/d2d1.dll.so" ]; then + cp "WineFix/lib/d2d1/build/x86_64-unix/d2d1.dll.so" "$COMBINED_TEMP/d2d1.dll" + echo "Included d2d1.dll (Wine native) in combined package" +else + echo "Warning: d2d1.dll.so not found. Skipping d2d1.dll in combined package." +fi + # Create tar.xz tar -C "$COMBINED_TEMP" -cJf "$OUTPUT_DIR/affinitypluginloader-plus-winefix.tar.xz" . rm -rf "$COMBINED_TEMP"