> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# CreatePlacedResource

> ID3D12Device::CreatePlacedResource crée une ressource légère placée dans un tas spécifique sur XBOX Direct3D 12, soit le type de ressource le plus rapide à créer.

Crée une ressource placée dans un tas spécifique. Les ressources placées sont les objets ressources les plus légers disponibles, et ce sont les plus rapides à créer et à détruire.

Votre application peut réutiliser la mémoire vidéo en superposant plusieurs ressources placées et réservées Direct3D sur des régions de tas. Le modèle simple de réutilisation de la mémoire (décrit dans [Remarques](#remarks)) existe pour préciser quelle ressource superposée est valide à un moment donné. Afin de maximiser la prise en charge des outils graphiques, le modèle simple ne prend pas en charge l'héritage de données, ni l'invalidation plus fine des vignettes et des sous-ressources. Seule l'invalidation complète des ressources superposées a lieu.

## Syntaxe

```cpp theme={null}
HRESULT CreatePlacedResource(
    ID3D12Heap  pHeap,
    UINT64 HeapOffset,
    const D3D12_RESOURCE_DESC  pDesc,
    D3D12_RESOURCE_STATES InitialState,
    const D3D12_CLEAR_VALUE  pOptimizedClearValue,
    const IID & riid,
    void  ppvResource
)
```

### Paramètres

*pHeap*<br />Type : ID3D12Heap \*

Pointeur vers l'interface **ID3D12Heap** qui représente le tas dans lequel la ressource est placée.

*HeapOffset*<br />Type : UINT64

Décalage, en octets, de la ressource. *HeapOffset* doit être un multiple de l'alignement de la ressource, et *HeapOffset* plus la taille de la ressource doit être inférieur ou égal à la taille du tas. [**GetResourceAllocationInfo**](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device/methods/id3d12device_getresourceallocationinfo_public) doit être utilisé pour connaître la taille des ressources de texture.

*pDesc*<br />Type : const D3D12\_RESOURCE\_DESC \*

Pointeur vers une structure **D3D12\_RESOURCE\_DESC** qui décrit la ressource.

*InitialState*<br />Type : D3D12\_RESOURCE\_STATES

État initial de la ressource, sous forme de combinaison par OU au niveau du bit de constantes de l'énumération **D3D12\_RESOURCE\_STATES**.

Lorsqu'une ressource est créée avec un tas **D3D12\_HEAP\_TYPE\_UPLOAD**, *InitialState* doit être **D3D12\_RESOURCE\_STATE\_GENERIC\_READ**. Lorsqu'une ressource est créée avec un tas **D3D12\_HEAP\_TYPE\_READBACK**, *InitialState* doit être **D3D12\_RESOURCE\_STATE\_COPY\_DEST**.

*pOptimizedClearValue*<br />Type : const D3D12\_CLEAR\_VALUE \*

Spécifie une structure **D3D12\_CLEAR\_VALUE** qui décrit la valeur par défaut d'une couleur d'effacement.

*pOptimizedClearValue* spécifie une valeur pour laquelle les opérations d'effacement sont les plus optimales. Lorsque la ressource créée est une texture comportant l'indicateur **D3D12\_RESOURCE\_FLAG\_ALLOW\_RENDER\_TARGET** ou **D3D12\_RESOURCE\_FLAG\_ALLOW\_DEPTH\_STENCIL**, votre application doit choisir la valeur avec laquelle l'opération d'effacement sera le plus souvent appelée.

Les opérations d'effacement peuvent être appelées avec d'autres valeurs, mais ces opérations ne seront pas aussi efficaces que lorsque la valeur correspond à celle passée lors de la création de la ressource.

*pOptimizedClearValue* doit être NULL lorsqu'il est utilisé avec **D3D12\_RESOURCE\_DIMENSION\_BUFFER**.

*riid*<br />Type : const IID &

Identificateur global unique (**GUID**) de l'interface de ressource. Il s'agit d'un paramètre d'entrée.

Le **REFIID**, ou **GUID**, de l'interface de la ressource peut être obtenu à l'aide de la macro `__uuidof`. Par exemple, `__uuidof(ID3D12Resource)` obtient le **GUID** de l'interface d'une ressource. Bien que **riid** soit le plus souvent le GUID de [**ID3D12Resource**](/fr-CA/reference/graphics/d3d12_xs/interfaces/ID3D12Resource/id3d12resource_xs), il peut s'agir de n'importe quel **GUID** de n'importe quelle interface. Si l'objet ressource ne prend pas en charge l'interface de ce **GUID**, la création échoue avec **E\_NOINTERFACE**.

*ppvResource*<br />Type : void \*\*

Pointeur vers un bloc de mémoire qui reçoit un pointeur vers la ressource. *ppvResource* peut être NULL afin de permettre le test des capacités. Lorsque *ppvResource* est NULL, aucun objet n'est créé et S\_FALSE est retourné lorsque *pResourceDesc* et les autres paramètres sont valides.

### Valeur de retour

Type : HRESULT

Cette méthode retourne **E\_OUTOFMEMORY** si la mémoire est insuffisante pour créer la ressource. Consultez [Codes de retour Direct3D 12](https://learn.microsoft.com/en-us/windows/win32/direct3d12/d3d12-graphics-reference-returnvalues) pour connaître les autres valeurs de retour possibles.

## Remarques

**CreatePlacedResource** est semblable au mappage complet d'une ressource réservée à un décalage dans un tas; toutefois, l'espace d'adressage virtuel associé à un tas peut également être réutilisé.

Les ressources placées sont plus légères à créer et à détruire que les ressources validées. En effet, aucun tas n'est créé ni détruit au cours de ces opérations. De plus, les ressources placées permettent une technique de réutilisation de la mémoire encore plus légère que la création et la destruction de ressources, c'est-à-dire la réutilisation par l'aliasing et les barrières d'aliasing. Plusieurs ressources placées peuvent se superposer simultanément sur le même tas, mais une seule ressource superposée peut être utilisée à la fois.

Il existe deux sémantiques d'utilisation des ressources placées : un modèle simple et un modèle avancé. Nous vous recommandons de choisir le modèle simple (il maximise la prise en charge des outils graphiques dans l'écosystème diversifié des GPU), à moins que vous ne constatiez que vous avez besoin du modèle avancé pour votre application.

### Modèle simple

Dans ce modèle, vous pouvez considérer qu'une ressource placée se trouve dans l'un de deux états : active ou inactive. Il n'est pas valide que le GPU lise ou écrive dans une ressource inactive. Les ressources placées sont créées à l'état inactif.

Pour activer une ressource avec une barrière d'aliasing dans une liste de commandes, votre application doit passer la ressource dans [**D3D12\_RESOURCE\_ALIASING\_BARRIER::pResourceAfter**](/fr-CA/reference/graphics/d3d12/structs/d3d12_resource_aliasing_barrier_public). **pResourceBefore** peut être laissé à NULL lors d'une activation. Toutes les ressources qui partagent la mémoire physique avec la ressource activée deviennent alors inactives, y compris les ressources placées et réservées qui se superposent.

Les barrières d'aliasing doivent être regroupées et soumises ensemble afin de maximiser l'efficacité.

Après l'activation, les ressources comportant l'indicateur de cible de rendu ou de profondeur-gabarit doivent être initialisées davantage. Consultez les notes sur l'initialisation requise des ressources ci-dessous.

#### Notes sur l'initialisation requise des ressources

Certains types de ressources nécessitent tout de même une initialisation. Les ressources comportant l'indicateur de cible de rendu ou de profondeur-gabarit doivent être initialisées avec une opération d'effacement ou un ensemble de copies complètes de sous-ressources. Si une barrière d'aliasing a été utilisée pour indiquer la transition entre deux ressources avec alias, l'initialisation doit avoir lieu après la barrière d'aliasing. Cette initialisation est toujours requise chaque fois qu'une ressource aurait été activée dans le modèle simple.

Les ressources placées et réservées comportant l'indicateur de cible de rendu ou de profondeur-gabarit doivent être initialisées avec l'une des opérations suivantes avant que d'autres opérations soient prises en charge.

* Une opération *Clear*; par exemple [ClearRenderTargetView](/fr-CA/reference/graphics/d3d12_xs/interfaces/ID3D12GraphicsCommandList/methods/id3d12graphicscommandlist_clearrendertargetview_xs) ou [ClearDepthStencilView](/fr-CA/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_cleardepthstencilview_public).
* Une opération [DiscardResource](/fr-CA/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_discardresource_public).
* Une opération *Copy*; par exemple [CopyBufferRegion](/fr-CA/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_copybufferregion_public), [CopyTextureRegion](/fr-CA/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_copytextureregion_public) ou [CopyResource](https://learn.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-copyresource).

Les applications doivent privilégier l'opération la plus explicite qui entraîne la modification du plus petit nombre de texels. Prenez les exemples suivants.

* L'utilisation d'un tampon de profondeur pour résoudre la visibilité des pixels exige généralement que chaque texel de profondeur commence à 1,0 ou à 0. Par conséquent, une opération *Clear* devrait être l'option la plus efficace pour l'initialisation d'un tampon de profondeur avec alias.
* Une application peut utiliser une cible de rendu avec alias comme destination pour le mappage des tons. Puisque l'application effectuera le rendu sur chaque pixel pendant le mappage des tons, [DiscardResource](/fr-CA/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_discardresource_public) devrait être l'option la plus efficace pour l'initialisation.

### Modèle avancé

Dans ce modèle, vous pouvez ignorer l'abstraction de l'état actif/inactif. Vous devez plutôt respecter ces règles de plus bas niveau.

* Une barrière d'aliasing doit se trouver entre deux accès différents du GPU à une ressource de la même mémoire physique, dans la mesure où ces accès se trouvent dans le même appel à [ExecuteCommandLists](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_executecommandlists).
* La première opération de rendu sur certains types de ressources avec alias doit tout de même être une initialisation, tout comme dans le modèle simple.

Les opérations d'initialisation doivent avoir lieu sur une sous-ressource entière ou selon une granularité de 64 Ko. L'initialisation d'une sous-ressource entière est prise en charge pour tous les types de ressources. Une granularité d'initialisation de 64 Ko, alignée sur un décalage de 64 Ko, est prise en charge pour les tampons et les textures dont la disposition de texture est 64KB\_UNDEFINED\_SWIZZLE ou 64KB\_STANDARD\_SWIZZLE (consultez [D3D12\_TEXTURE\_LAYOUT](/fr-CA/reference/graphics/d3d12_x/enums/d3d12_texture_layout)).

### Notes sur la barrière d'aliasing

La barrière d'aliasing peut définir NULL pour *pResourceAfter* et *pResourceBefore*. La définition de la cohérence de la mémoire de [**ExecuteCommandLists**](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_executecommandlists) et celle d'une barrière d'aliasing sont identiques, de sorte que deux accès avec alias à la même mémoire physique ne nécessitent aucune barrière d'aliasing lorsque les accès se trouvent dans deux appels différents à **ExecuteCommandLists**.

Pour les modèles d'utilisation avancés de D3D12, la définition de la synchronisation de [**ExecuteCommandLists**](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_executecommandlists) équivaut à une barrière d'aliasing. Par conséquent, les applications peuvent soit insérer une barrière d'aliasing entre les réutilisations de la mémoire physique, soit s'assurer que les deux utilisations avec alias de la mémoire physique ont lieu dans deux appels distincts à **ExecuteCommandLists**.

L'ampleur de l'inactivation varie selon les propriétés des ressources. Les textures dont la disposition de mémoire n'est pas définie constituent le pire cas, car la texture entière doit être inactivée de façon atomique. Pour deux ressources superposées dont les dispositions sont définies, l'inactivation peut ne toucher que les régions alignées superposées d'une ressource. L'héritage de données peut même être bien défini. Pour plus de détails, consultez [Aliasing de mémoire et héritage de données](https://learn.microsoft.com/en-us/windows/win32/direct3d12/memory-aliasing-and-data-inheritance).

## Configuration requise

**En-tête :** d3d12\_xs.h ou d3d12\_x.h<br />**Bibliothèque :** d3d12\_xs.lib ou d3d12\_x.lib<br />**Plateformes prises en charge :** consoles XBOX Series et famille XBOX One

## Voir aussi

[CreateCommittedResource](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device/methods/id3d12device_createcommittedresource_public)

[CreateReservedResource](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device/methods/id3d12device_createreservedresource_public)

[ID3D12Device](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12device/id3d12device)

[Tas partagés](https://learn.microsoft.com/en-us/windows/win32/direct3d12/shared-heaps)


## Related topics

- [CreatePlacedResource2 (consoles XBOX Series)](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device10/methods/id3d12device10_createplacedresource2_public.md)
- [CreateReservedResource](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device/methods/id3d12device_createreservedresource_public.md)
- [CreateCommittedResource](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device/methods/id3d12device_createcommittedresource_public.md)
- [CreateReservedResource2 (consoles XBOX Series)](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device10/methods/id3d12device10_createreservedresource2_public.md)
- [CreateReservedResource1 (consoles XBOX Series)](/fr-CA/reference/graphics/d3d12/interfaces/id3d12device4/methods/id3d12device4_createreservedresource1_public.md)