d3d11.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: MIT
 * Copyright (c) 2026 Jeremiah van Oosten
 *
 * vgl Direct3D 11 backend: draws a context's globe with Direct3D 11 at feature level 11_0, into
 * the host's render targets (design document, section 7.6). It is a consumer of the render
 * interface (vgl/render.h), linked separately as vgl_d3d11, and uses vgl only through the C API.
 *
 * The host creates the device and passes it, with the device context to draw with:
 *
 *     vgl_d3d11_backend_create_info info = {.struct_size = sizeof(info)};
 *     info.device = device;
 *     info.device_context = immediate_context;
 *     vgl_d3d11_backend* backend;
 *     vgl_d3d11_backend_create(context, &info, &backend);
 *
 *     // Each frame, after vgl_context_update, with the host's render target and depth buffer
 *     // bound and its viewport set:
 *     vgl_d3d11_backend_draw(backend, NULL);
 *
 *     vgl_d3d11_backend_destroy(backend);  // Before the context and the device.
 *
 * State (NFR-08). The backend saves the following state of the device context when it draws,
 * and restores it before returning: the input layout, the primitive topology, vertex buffer 0
 * and the index buffer; the vertex shader and its constant buffers 0 and 1; the pixel shader,
 * its constant buffers 0 and 1, its shader resources 0 to 5 and its samplers 0 and 1; the
 * rasterizer state; the depth-stencil state and stencil reference; and the blend state, blend
 * factor and sample mask. It draws with the host's render targets, viewports and scissor
 * rectangles as they are, with the stencil test and blending off.
 *
 * Projections map depth to [0, 1], as Direct3D does, and camera space is the view matrix's:
 * right-handed, like ECEF, looking along -z.
 */
#ifndef VGL_D3D11_H
#define VGL_D3D11_H
 
#include <d3d11.h>
 
#include <vgl/base.h>
#include <vgl/context.h>
#include <vgl/render.h>
 
/* Symbol visibility of the backend library, which is shared when vgl is. */
#if defined(VGL_SHARED)
#    if defined(VGL_D3D11_BUILDING)
#        define VGL_D3D11_API __declspec(dllexport)
#    else
#        define VGL_D3D11_API __declspec(dllimport)
#    endif
#else
#    define VGL_D3D11_API
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct vgl_d3d11_backend vgl_d3d11_backend;
 
typedef struct vgl_d3d11_backend_create_info
{
    uint32_t struct_size;
    vgl_depth_convention depth_convention;
    ID3D11Device* device;
    VGL_POINTER_PADDING(device_padding)
    ID3D11DeviceContext* device_context;
    VGL_POINTER_PADDING(device_context_padding)
} vgl_d3d11_backend_create_info;
 
VGL_D3D11_API vgl_result vgl_d3d11_backend_create(vgl_context* context,
                                                  const vgl_d3d11_backend_create_info* info,
                                                  vgl_d3d11_backend** out_backend);
 
VGL_D3D11_API vgl_result vgl_d3d11_backend_destroy(vgl_d3d11_backend* backend);
 
typedef struct vgl_d3d11_draw_info
{
    uint32_t struct_size;
    vgl_bool mirrored;
    const vgl_dmat4* view_matrix;
    VGL_POINTER_PADDING(view_matrix_padding)
    const vgl_dmat4* projection_matrix;
    VGL_POINTER_PADDING(projection_matrix_padding)
    vgl_dvec3 sun_direction;
    double logarithmic_far;
    uint64_t upload_budget;
    vgl_draw_features features;
    vgl_debug_views debug_views;
    double earth_rotation_angle;
    double contour_interval;
    double cloud_height;
} vgl_d3d11_draw_info;
 
VGL_D3D11_API vgl_result vgl_d3d11_backend_draw(vgl_d3d11_backend* backend,
                                                const vgl_d3d11_draw_info* info);
 
VGL_D3D11_API vgl_result vgl_d3d11_backend_clouds_set(vgl_d3d11_backend* backend,
                                                      const uint8_t* coverage,
                                                      uint32_t width,
                                                      uint32_t height);
 
VGL_D3D11_API vgl_result vgl_d3d11_backend_stars_set(vgl_d3d11_backend* backend,
                                                     const vgl_star* stars,
                                                     uint32_t star_count);
 
VGL_D3D11_API vgl_result vgl_d3d11_backend_device_reset(vgl_d3d11_backend* backend,
                                                        ID3D11Device* device,
                                                        ID3D11DeviceContext* device_context);
 
#ifdef __cplusplus
}
#endif
 
#endif /* VGL_D3D11_H */