diff --git a/src/xenia/gpu/d3d12/d3d12_command_processor.h b/src/xenia/gpu/d3d12/d3d12_command_processor.h
index 42c1e0092..ceffe5fd0 100644
--- a/src/xenia/gpu/d3d12/d3d12_command_processor.h
+++ b/src/xenia/gpu/d3d12/d3d12_command_processor.h
@@ -188,7 +188,7 @@ class D3D12CommandProcessor : public CommandProcessor {
 
   // Returns a pipeline with deferred creation by its handle. May return nullptr
   // if failed to create the pipeline.
-  inline ID3D12PipelineState* GetD3D12PipelineByHandle(void* handle) const {
+  ID3D12PipelineState* GetD3D12PipelineByHandle(void* handle) const {
     return pipeline_cache_->GetD3D12PipelineByHandle(handle);
   }
 
@@ -501,7 +501,7 @@ class D3D12CommandProcessor : public CommandProcessor {
 
   static constexpr uint32_t kSwapTextureWidth = 1280;
   static constexpr uint32_t kSwapTextureHeight = 720;
-  inline std::pair<uint32_t, uint32_t> GetSwapTextureSize() const {
+  std::pair<uint32_t, uint32_t> GetSwapTextureSize() const {
     if (texture_cache_->IsResolutionScale2X()) {
       return std::make_pair(kSwapTextureWidth * 2, kSwapTextureHeight * 2);
     }
diff --git a/src/xenia/gpu/d3d12/d3d12_shared_memory.h b/src/xenia/gpu/d3d12/d3d12_shared_memory.h
index 6620cecaa..dc918bb11 100644
--- a/src/xenia/gpu/d3d12/d3d12_shared_memory.h
+++ b/src/xenia/gpu/d3d12/d3d12_shared_memory.h
@@ -48,7 +48,7 @@ class D3D12SharedMemory : public SharedMemory {
   // UseForReading or UseForWriting.
 
   // Makes the buffer usable for vertices, indices and texture untiling.
-  inline void UseForReading() {
+  void UseForReading() {
     // Vertex fetch is also allowed in pixel shaders.
     CommitUAVWritesAndTransitionBuffer(
         D3D12_RESOURCE_STATE_INDEX_BUFFER |
@@ -56,18 +56,18 @@ class D3D12SharedMemory : public SharedMemory {
         D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
   }
   // Makes the buffer usable for texture tiling after a resolve.
-  inline void UseForWriting() {
+  void UseForWriting() {
     CommitUAVWritesAndTransitionBuffer(D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
   }
   // Makes the buffer usable as a source for copy commands.
-  inline void UseAsCopySource() {
+  void UseAsCopySource() {
     CommitUAVWritesAndTransitionBuffer(D3D12_RESOURCE_STATE_COPY_SOURCE);
   }
   // Must be called when doing draws/dispatches modifying data within the shared
   // memory buffer as a UAV, to make sure that when UseForWriting is called the
   // next time, a UAV barrier will be done, and subsequent overlapping UAV
   // writes and reads are ordered.
-  inline void MarkUAVWritesCommitNeeded() {
+  void MarkUAVWritesCommitNeeded() {
     if (buffer_state_ == D3D12_RESOURCE_STATE_UNORDERED_ACCESS) {
       buffer_uav_writes_commit_needed_ = true;
     }
diff --git a/src/xenia/gpu/d3d12/deferred_command_list.h b/src/xenia/gpu/d3d12/deferred_command_list.h
index 9393798c3..e8060371c 100644
--- a/src/xenia/gpu/d3d12/deferred_command_list.h
+++ b/src/xenia/gpu/d3d12/deferred_command_list.h
@@ -33,7 +33,7 @@ class DeferredCommandList {
   void Execute(ID3D12GraphicsCommandList* command_list,
                ID3D12GraphicsCommandList1* command_list_1);
 
-  inline void D3DClearUnorderedAccessViewUint(
+  void D3DClearUnorderedAccessViewUint(
       D3D12_GPU_DESCRIPTOR_HANDLE view_gpu_handle_in_current_heap,
       D3D12_CPU_DESCRIPTOR_HANDLE view_cpu_handle, ID3D12Resource* resource,
       const UINT values[4], UINT num_rects, const D3D12_RECT* rects) {
@@ -51,9 +51,9 @@ class DeferredCommandList {
     }
   }
 
-  inline void D3DCopyBufferRegion(ID3D12Resource* dst_buffer, UINT64 dst_offset,
-                                  ID3D12Resource* src_buffer, UINT64 src_offset,
-                                  UINT64 num_bytes) {
+  void D3DCopyBufferRegion(ID3D12Resource* dst_buffer, UINT64 dst_offset,
+                           ID3D12Resource* src_buffer, UINT64 src_offset,
+                           UINT64 num_bytes) {
     auto& args = *reinterpret_cast<D3DCopyBufferRegionArguments*>(WriteCommand(
         Command::kD3DCopyBufferRegion, sizeof(D3DCopyBufferRegionArguments)));
     args.dst_buffer = dst_buffer;
@@ -63,26 +63,26 @@ class DeferredCommandList {
     args.num_bytes = num_bytes;
   }
 
-  inline void D3DCopyResource(ID3D12Resource* dst_resource,
-                              ID3D12Resource* src_resource) {
+  void D3DCopyResource(ID3D12Resource* dst_resource,
+                       ID3D12Resource* src_resource) {
     auto& args = *reinterpret_cast<D3DCopyResourceArguments*>(WriteCommand(
         Command::kD3DCopyResource, sizeof(D3DCopyResourceArguments)));
     args.dst_resource = dst_resource;
     args.src_resource = src_resource;
   }
 
-  inline void CopyTexture(const D3D12_TEXTURE_COPY_LOCATION& dst,
-                          const D3D12_TEXTURE_COPY_LOCATION& src) {
+  void CopyTexture(const D3D12_TEXTURE_COPY_LOCATION& dst,
+                   const D3D12_TEXTURE_COPY_LOCATION& src) {
     auto& args = *reinterpret_cast<CopyTextureArguments*>(
         WriteCommand(Command::kCopyTexture, sizeof(CopyTextureArguments)));
     std::memcpy(&args.dst, &dst, sizeof(D3D12_TEXTURE_COPY_LOCATION));
     std::memcpy(&args.src, &src, sizeof(D3D12_TEXTURE_COPY_LOCATION));
   }
 
-  inline 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 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) {
     auto& args = *reinterpret_cast<CopyTextureRegionArguments*>(WriteCommand(
         Command::kCopyTextureRegion, sizeof(CopyTextureRegionArguments)));
     std::memcpy(&args.dst, &dst, sizeof(D3D12_TEXTURE_COPY_LOCATION));
@@ -93,8 +93,8 @@ class DeferredCommandList {
     args.src_box = src_box;
   }
 
-  inline void D3DDispatch(UINT thread_group_count_x, UINT thread_group_count_y,
-                          UINT thread_group_count_z) {
+  void D3DDispatch(UINT thread_group_count_x, UINT thread_group_count_y,
+                   UINT thread_group_count_z) {
     auto& args = *reinterpret_cast<D3DDispatchArguments*>(
         WriteCommand(Command::kD3DDispatch, sizeof(D3DDispatchArguments)));
     args.thread_group_count_x = thread_group_count_x;
@@ -102,11 +102,10 @@ class DeferredCommandList {
     args.thread_group_count_z = thread_group_count_z;
   }
 
-  inline void D3DDrawIndexedInstanced(UINT index_count_per_instance,
-                                      UINT instance_count,
-                                      UINT start_index_location,
-                                      INT base_vertex_location,
-                                      UINT start_instance_location) {
+  void D3DDrawIndexedInstanced(UINT index_count_per_instance,
+                               UINT instance_count, UINT start_index_location,
+                               INT base_vertex_location,
+                               UINT start_instance_location) {
     auto& args = *reinterpret_cast<D3DDrawIndexedInstancedArguments*>(
         WriteCommand(Command::kD3DDrawIndexedInstanced,
                      sizeof(D3DDrawIndexedInstancedArguments)));
@@ -117,9 +116,9 @@ class DeferredCommandList {
     args.start_instance_location = start_instance_location;
   }
 
-  inline void D3DDrawInstanced(UINT vertex_count_per_instance,
-                               UINT instance_count, UINT start_vertex_location,
-                               UINT start_instance_location) {
+  void D3DDrawInstanced(UINT vertex_count_per_instance, UINT instance_count,
+                        UINT start_vertex_location,
+                        UINT start_instance_location) {
     auto& args = *reinterpret_cast<D3DDrawInstancedArguments*>(WriteCommand(
         Command::kD3DDrawInstanced, sizeof(D3DDrawInstancedArguments)));
     args.vertex_count_per_instance = vertex_count_per_instance;
@@ -128,7 +127,7 @@ class DeferredCommandList {
     args.start_instance_location = start_instance_location;
   }
 
-  inline void D3DIASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW* view) {
+  void D3DIASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW* view) {
     auto& args = *reinterpret_cast<D3D12_INDEX_BUFFER_VIEW*>(WriteCommand(
         Command::kD3DIASetIndexBuffer, sizeof(D3D12_INDEX_BUFFER_VIEW)));
     if (view != nullptr) {
@@ -142,14 +141,13 @@ class DeferredCommandList {
     }
   }
 
-  inline void D3DIASetPrimitiveTopology(
-      D3D12_PRIMITIVE_TOPOLOGY primitive_topology) {
+  void D3DIASetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitive_topology) {
     auto& arg = *reinterpret_cast<D3D12_PRIMITIVE_TOPOLOGY*>(WriteCommand(
         Command::kD3DIASetPrimitiveTopology, sizeof(D3D12_PRIMITIVE_TOPOLOGY)));
     arg = primitive_topology;
   }
 
-  inline void D3DOMSetBlendFactor(const FLOAT blend_factor[4]) {
+  void D3DOMSetBlendFactor(const FLOAT blend_factor[4]) {
     auto args = reinterpret_cast<FLOAT*>(
         WriteCommand(Command::kD3DOMSetBlendFactor, 4 * sizeof(FLOAT)));
     args[0] = blend_factor[0];
@@ -158,7 +156,7 @@ class DeferredCommandList {
     args[3] = blend_factor[3];
   }
 
-  inline void D3DOMSetRenderTargets(
+  void D3DOMSetRenderTargets(
       UINT num_render_target_descriptors,
       const D3D12_CPU_DESCRIPTOR_HANDLE* render_target_descriptors,
       BOOL rts_single_handle_to_descriptor_range,
@@ -185,14 +183,14 @@ class DeferredCommandList {
     }
   }
 
-  inline void D3DOMSetStencilRef(UINT stencil_ref) {
+  void D3DOMSetStencilRef(UINT stencil_ref) {
     auto& arg = *reinterpret_cast<UINT*>(
         WriteCommand(Command::kD3DOMSetStencilRef, sizeof(UINT)));
     arg = stencil_ref;
   }
 
-  inline void D3DResourceBarrier(UINT num_barriers,
-                                 const D3D12_RESOURCE_BARRIER* barriers) {
+  void D3DResourceBarrier(UINT num_barriers,
+                          const D3D12_RESOURCE_BARRIER* barriers) {
     if (num_barriers == 0) {
       return;
     }
@@ -207,21 +205,22 @@ class DeferredCommandList {
                 num_barriers * sizeof(D3D12_RESOURCE_BARRIER));
   }
 
-  inline void RSSetScissorRect(const D3D12_RECT& rect) {
+  void RSSetScissorRect(const D3D12_RECT& rect) {
     auto& arg = *reinterpret_cast<D3D12_RECT*>(
         WriteCommand(Command::kRSSetScissorRect, sizeof(D3D12_RECT)));
     arg = rect;
   }
 
-  inline void RSSetViewport(const D3D12_VIEWPORT& viewport) {
+  void RSSetViewport(const D3D12_VIEWPORT& viewport) {
     auto& arg = *reinterpret_cast<D3D12_VIEWPORT*>(
         WriteCommand(Command::kRSSetViewport, sizeof(D3D12_VIEWPORT)));
     arg = viewport;
   }
 
-  inline void D3DSetComputeRoot32BitConstants(
-      UINT root_parameter_index, UINT num_32bit_values_to_set,
-      const void* src_data, UINT dest_offset_in_32bit_values) {
+  void D3DSetComputeRoot32BitConstants(UINT root_parameter_index,
+                                       UINT num_32bit_values_to_set,
+                                       const void* src_data,
+                                       UINT dest_offset_in_32bit_values) {
     if (num_32bit_values_to_set == 0) {
       return;
     }
@@ -235,9 +234,10 @@ class DeferredCommandList {
     std::memcpy(args + 1, src_data, num_32bit_values_to_set * sizeof(uint32_t));
   }
 
-  inline void D3DSetGraphicsRoot32BitConstants(
-      UINT root_parameter_index, UINT num_32bit_values_to_set,
-      const void* src_data, UINT dest_offset_in_32bit_values) {
+  void D3DSetGraphicsRoot32BitConstants(UINT root_parameter_index,
+                                        UINT num_32bit_values_to_set,
+                                        const void* src_data,
+                                        UINT dest_offset_in_32bit_values) {
     if (num_32bit_values_to_set == 0) {
       return;
     }
@@ -251,7 +251,7 @@ class DeferredCommandList {
     std::memcpy(args + 1, src_data, num_32bit_values_to_set * sizeof(uint32_t));
   }
 
-  inline void D3DSetComputeRootConstantBufferView(
+  void D3DSetComputeRootConstantBufferView(
       UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS buffer_location) {
     auto& args = *reinterpret_cast<SetRootConstantBufferViewArguments*>(
         WriteCommand(Command::kD3DSetComputeRootConstantBufferView,
@@ -260,7 +260,7 @@ class DeferredCommandList {
     args.buffer_location = buffer_location;
   }
 
-  inline void D3DSetGraphicsRootConstantBufferView(
+  void D3DSetGraphicsRootConstantBufferView(
       UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS buffer_location) {
     auto& args = *reinterpret_cast<SetRootConstantBufferViewArguments*>(
         WriteCommand(Command::kD3DSetGraphicsRootConstantBufferView,
@@ -269,7 +269,7 @@ class DeferredCommandList {
     args.buffer_location = buffer_location;
   }
 
-  inline void D3DSetComputeRootDescriptorTable(
+  void D3DSetComputeRootDescriptorTable(
       UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor) {
     auto& args = *reinterpret_cast<SetRootDescriptorTableArguments*>(
         WriteCommand(Command::kD3DSetComputeRootDescriptorTable,
@@ -278,7 +278,7 @@ class DeferredCommandList {
     args.base_descriptor.ptr = base_descriptor.ptr;
   }
 
-  inline void D3DSetGraphicsRootDescriptorTable(
+  void D3DSetGraphicsRootDescriptorTable(
       UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor) {
     auto& args = *reinterpret_cast<SetRootDescriptorTableArguments*>(
         WriteCommand(Command::kD3DSetGraphicsRootDescriptorTable,
@@ -287,42 +287,40 @@ class DeferredCommandList {
     args.base_descriptor.ptr = base_descriptor.ptr;
   }
 
-  inline void D3DSetComputeRootSignature(ID3D12RootSignature* root_signature) {
+  void D3DSetComputeRootSignature(ID3D12RootSignature* root_signature) {
     auto& arg = *reinterpret_cast<ID3D12RootSignature**>(WriteCommand(
         Command::kD3DSetComputeRootSignature, sizeof(ID3D12RootSignature*)));
     arg = root_signature;
   }
 
-  inline void D3DSetGraphicsRootSignature(ID3D12RootSignature* root_signature) {
+  void D3DSetGraphicsRootSignature(ID3D12RootSignature* root_signature) {
     auto& arg = *reinterpret_cast<ID3D12RootSignature**>(WriteCommand(
         Command::kD3DSetGraphicsRootSignature, sizeof(ID3D12RootSignature*)));
     arg = root_signature;
   }
 
-  inline void SetDescriptorHeaps(
-      ID3D12DescriptorHeap* cbv_srv_uav_descriptor_heap,
-      ID3D12DescriptorHeap* sampler_descriptor_heap) {
+  void SetDescriptorHeaps(ID3D12DescriptorHeap* cbv_srv_uav_descriptor_heap,
+                          ID3D12DescriptorHeap* sampler_descriptor_heap) {
     auto& args = *reinterpret_cast<SetDescriptorHeapsArguments*>(WriteCommand(
         Command::kSetDescriptorHeaps, sizeof(SetDescriptorHeapsArguments)));
     args.cbv_srv_uav_descriptor_heap = cbv_srv_uav_descriptor_heap;
     args.sampler_descriptor_heap = sampler_descriptor_heap;
   }
 
-  inline void D3DSetPipelineState(ID3D12PipelineState* pipeline_state) {
+  void D3DSetPipelineState(ID3D12PipelineState* pipeline_state) {
     auto& arg = *reinterpret_cast<ID3D12PipelineState**>(WriteCommand(
         Command::kD3DSetPipelineState, sizeof(ID3D12PipelineState*)));
     arg = pipeline_state;
   }
 
-  inline void SetPipelineStateHandle(void* pipeline_state_handle) {
+  void SetPipelineStateHandle(void* pipeline_state_handle) {
     auto& arg = *reinterpret_cast<void**>(
         WriteCommand(Command::kSetPipelineStateHandle, sizeof(void*)));
     arg = pipeline_state_handle;
   }
 
-  inline void D3DSetSamplePositions(
-      UINT num_samples_per_pixel, UINT num_pixels,
-      const D3D12_SAMPLE_POSITION* sample_positions) {
+  void D3DSetSamplePositions(UINT num_samples_per_pixel, UINT num_pixels,
+                             const D3D12_SAMPLE_POSITION* sample_positions) {
     auto& args = *reinterpret_cast<D3DSetSamplePositionsArguments*>(
         WriteCommand(Command::kD3DSetSamplePositions,
                      sizeof(D3DSetSamplePositionsArguments)));
diff --git a/src/xenia/gpu/d3d12/pipeline_cache.h b/src/xenia/gpu/d3d12/pipeline_cache.h
index ee7f0a7de..8159416d0 100644
--- a/src/xenia/gpu/d3d12/pipeline_cache.h
+++ b/src/xenia/gpu/d3d12/pipeline_cache.h
@@ -78,7 +78,7 @@ class PipelineCache {
 
   // Returns a pipeline with deferred creation by its handle. May return nullptr
   // if failed to create the pipeline.
-  inline ID3D12PipelineState* GetD3D12PipelineByHandle(void* handle) const {
+  ID3D12PipelineState* GetD3D12PipelineByHandle(void* handle) const {
     return reinterpret_cast<const Pipeline*>(handle)->state;
   }
 
diff --git a/src/xenia/gpu/d3d12/render_target_cache.h b/src/xenia/gpu/d3d12/render_target_cache.h
index bc68c68a9..6d20e8d52 100644
--- a/src/xenia/gpu/d3d12/render_target_cache.h
+++ b/src/xenia/gpu/d3d12/render_target_cache.h
@@ -303,8 +303,7 @@ class RenderTargetCache {
   // performance difference, but with EDRAM loads/stores less conversion should
   // be performed by the shaders if D24S8 is emulated as D24_UNORM_S8_UINT, and
   // it's probably more accurate.
-  static inline DXGI_FORMAT GetDepthDXGIFormat(
-      xenos::DepthRenderTargetFormat format) {
+  static DXGI_FORMAT GetDepthDXGIFormat(xenos::DepthRenderTargetFormat format) {
     return format == xenos::DepthRenderTargetFormat::kD24FS8
                ? DXGI_FORMAT_D32_FLOAT_S8X24_UINT
                : DXGI_FORMAT_D24_UNORM_S8_UINT;
diff --git a/src/xenia/gpu/d3d12/texture_cache.h b/src/xenia/gpu/d3d12/texture_cache.h
index 0e66328f0..85131f25d 100644
--- a/src/xenia/gpu/d3d12/texture_cache.h
+++ b/src/xenia/gpu/d3d12/texture_cache.h
@@ -106,18 +106,18 @@ class TextureCache {
     bool operator!=(const TextureKey& key) const {
       return GetMapKey() != key.GetMapKey() || bucket_key != key.bucket_key;
     }
-    inline uint64_t GetMapKey() const {
+    uint64_t GetMapKey() const {
       return uint64_t(map_key[0]) | (uint64_t(map_key[1]) << 32);
     }
-    inline void SetMapKey(uint64_t key) {
+    void SetMapKey(uint64_t key) {
       map_key[0] = uint32_t(key);
       map_key[1] = uint32_t(key >> 32);
     }
-    inline bool IsInvalid() const {
+    bool IsInvalid() const {
       // Zero base and zero width is enough for a binding to be invalid.
       return map_key[0] == 0;
     }
-    inline void MakeInvalid() {
+    void MakeInvalid() {
       // Reset all for a stable hash.
       SetMapKey(0);
       bucket_key = 0;
@@ -222,9 +222,7 @@ class TextureCache {
 
   void MarkRangeAsResolved(uint32_t start_unscaled, uint32_t length_unscaled);
 
-  inline bool IsResolutionScale2X() const {
-    return scaled_resolve_buffer_ != nullptr;
-  }
+  bool IsResolutionScale2X() const { return scaled_resolve_buffer_ != nullptr; }
   ID3D12Resource* GetScaledResolveBuffer() const {
     return scaled_resolve_buffer_;
   }
@@ -233,7 +231,7 @@ class TextureCache {
                                          uint32_t length_unscaled);
   void UseScaledResolveBufferForReading();
   void UseScaledResolveBufferForWriting();
-  inline void MarkScaledResolveBufferUAVWritesCommitNeeded() {
+  void MarkScaledResolveBufferUAVWritesCommitNeeded() {
     if (scaled_resolve_buffer_state_ == D3D12_RESOURCE_STATE_UNORDERED_ACCESS) {
       scaled_resolve_buffer_uav_writes_commit_needed_ = true;
     }
@@ -432,7 +430,7 @@ class TextureCache {
   // Whether the signed version of the texture has a different representation on
   // the host than its unsigned version (for example, if it's a fixed-point
   // texture emulated with a larger host pixel format).
-  static inline bool IsSignedVersionSeparate(xenos::TextureFormat format) {
+  static bool IsSignedVersionSeparate(xenos::TextureFormat format) {
     const HostFormat& host_format = host_formats_[uint32_t(format)];
     return host_format.load_mode_snorm != LoadMode::kUnknown &&
            host_format.load_mode_snorm != host_format.load_mode;
@@ -441,26 +439,24 @@ class TextureCache {
   // of block-compressed textures with 4x4-aligned dimensions on PC).
   static bool IsDecompressionNeeded(xenos::TextureFormat format, uint32_t width,
                                     uint32_t height);
-  static inline DXGI_FORMAT GetDXGIResourceFormat(xenos::TextureFormat format,
-                                                  uint32_t width,
-                                                  uint32_t height) {
+  static DXGI_FORMAT GetDXGIResourceFormat(xenos::TextureFormat format,
+                                           uint32_t width, uint32_t height) {
     const HostFormat& host_format = host_formats_[uint32_t(format)];
     return IsDecompressionNeeded(format, width, height)
                ? host_format.dxgi_format_uncompressed
                : host_format.dxgi_format_resource;
   }
-  static inline DXGI_FORMAT GetDXGIResourceFormat(TextureKey key) {
+  static DXGI_FORMAT GetDXGIResourceFormat(TextureKey key) {
     return GetDXGIResourceFormat(key.format, key.width, key.height);
   }
-  static inline DXGI_FORMAT GetDXGIUnormFormat(xenos::TextureFormat format,
-                                               uint32_t width,
-                                               uint32_t height) {
+  static DXGI_FORMAT GetDXGIUnormFormat(xenos::TextureFormat format,
+                                        uint32_t width, uint32_t height) {
     const HostFormat& host_format = host_formats_[uint32_t(format)];
     return IsDecompressionNeeded(format, width, height)
                ? host_format.dxgi_format_uncompressed
                : host_format.dxgi_format_unorm;
   }
-  static inline DXGI_FORMAT GetDXGIUnormFormat(TextureKey key) {
+  static DXGI_FORMAT GetDXGIUnormFormat(TextureKey key) {
     return GetDXGIUnormFormat(key.format, key.width, key.height);
   }
 
diff --git a/src/xenia/ui/d3d12/d3d12_provider.h b/src/xenia/ui/d3d12/d3d12_provider.h
index 0e70def17..255d42a3d 100644
--- a/src/xenia/ui/d3d12/d3d12_provider.h
+++ b/src/xenia/ui/d3d12/d3d12_provider.h
@@ -46,22 +46,22 @@ class D3D12Provider : public GraphicsProvider {
   uint32_t GetRTVDescriptorSize() const { return descriptor_size_rtv_; }
   uint32_t GetDSVDescriptorSize() const { return descriptor_size_dsv_; }
   template <typename T>
-  inline T OffsetViewDescriptor(T start, uint32_t index) const {
+  T OffsetViewDescriptor(T start, uint32_t index) const {
     start.ptr += index * descriptor_size_view_;
     return start;
   }
   template <typename T>
-  inline T OffsetSamplerDescriptor(T start, uint32_t index) const {
+  T OffsetSamplerDescriptor(T start, uint32_t index) const {
     start.ptr += index * descriptor_size_sampler_;
     return start;
   }
   template <typename T>
-  inline T OffsetRTVDescriptor(T start, uint32_t index) const {
+  T OffsetRTVDescriptor(T start, uint32_t index) const {
     start.ptr += index * descriptor_size_rtv_;
     return start;
   }
   template <typename T>
-  inline T OffsetDSVDescriptor(T start, uint32_t index) const {
+  T OffsetDSVDescriptor(T start, uint32_t index) const {
     start.ptr += index * descriptor_size_dsv_;
     return start;
   }
@@ -91,32 +91,30 @@ class D3D12Provider : public GraphicsProvider {
   }
 
   // Proxies for Direct3D 12 functions since they are loaded dynamically.
-  inline HRESULT SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc,
-                                        D3D_ROOT_SIGNATURE_VERSION version,
-                                        ID3DBlob** blob_out,
-                                        ID3DBlob** error_blob_out) const {
+  HRESULT SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc,
+                                 D3D_ROOT_SIGNATURE_VERSION version,
+                                 ID3DBlob** blob_out,
+                                 ID3DBlob** error_blob_out) const {
     return pfn_d3d12_serialize_root_signature_(desc, version, blob_out,
                                                error_blob_out);
   }
-  inline HRESULT Disassemble(const void* src_data, size_t src_data_size,
-                             UINT flags, const char* comments,
-                             ID3DBlob** disassembly_out) const {
+  HRESULT Disassemble(const void* src_data, size_t src_data_size, UINT flags,
+                      const char* comments, ID3DBlob** disassembly_out) const {
     if (!pfn_d3d_disassemble_) {
       return E_NOINTERFACE;
     }
     return pfn_d3d_disassemble_(src_data, src_data_size, flags, comments,
                                 disassembly_out);
   }
-  inline HRESULT DxbcConverterCreateInstance(const CLSID& rclsid,
-                                             const IID& riid,
-                                             void** ppv) const {
+  HRESULT DxbcConverterCreateInstance(const CLSID& rclsid, const IID& riid,
+                                      void** ppv) const {
     if (!pfn_dxilconv_dxc_create_instance_) {
       return E_NOINTERFACE;
     }
     return pfn_dxilconv_dxc_create_instance_(rclsid, riid, ppv);
   }
-  inline HRESULT DxcCreateInstance(const CLSID& rclsid, const IID& riid,
-                                   void** ppv) const {
+  HRESULT DxcCreateInstance(const CLSID& rclsid, const IID& riid,
+                            void** ppv) const {
     if (!pfn_dxcompiler_dxc_create_instance_) {
       return E_NOINTERFACE;
     }
diff --git a/src/xenia/ui/d3d12/d3d12_util.h b/src/xenia/ui/d3d12/d3d12_util.h
index 062177218..6798f4f1c 100644
--- a/src/xenia/ui/d3d12/d3d12_util.h
+++ b/src/xenia/ui/d3d12/d3d12_util.h
@@ -27,7 +27,7 @@ extern const D3D12_HEAP_PROPERTIES kHeapPropertiesUpload;
 extern const D3D12_HEAP_PROPERTIES kHeapPropertiesReadback;
 
 template <typename T>
-inline bool ReleaseAndNull(T& object) {
+bool ReleaseAndNull(T& object) {
   if (object != nullptr) {
     object->Release();
     object = nullptr;