TODOs

Author: FlorianBorn71

articles/remote-rendering/concepts/graphics-bindings.md

@@ -30,21 +30,25 @@ The only other relevant part for Unity is accessing the [basic binding](#access)
 
 To select a graphics binding, take the following two steps: First, the graphics binding has to be statically initialized when the program is initialized:
 
-``` cs
+```cs
 RemoteRenderingInitialization managerInit = new RemoteRenderingInitialization;
 managerInit.graphicsApi = GraphicsApiType.WmrD3D11;
 managerInit.connectionType = ConnectionType.General;
 managerInit.right = ///...
 RemoteManagerStatic.StartupRemoteRendering(managerInit);
 ```
 
+```cpp
+TODO
+```
+
 The call above is necessary to initialize Azure Remote Rendering into the holographic APIs. This function must be called before any holographic API is called and before any other Remote Rendering APIs are accessed. Similarly, the corresponding de-init function `RemoteManagerStatic.ShutdownRemoteRendering();` should be called after no holographic APIs are being called anymore.
 
 ## <span id="access">Accessing graphics binding
 
 Once a client is set up, the basic graphics binding can be accessed with the `AzureSession.GraphicsBinding` getter. As an example, the last frame statistics can be retrieved like this:
 
-``` cs
+```cs
 AzureSession currentSesson = ...;
 if (currentSesson.GraphicsBinding)
 {
@@ -56,6 +60,10 @@ if (currentSesson.GraphicsBinding)
 }
 ```
 
+```cpp
+TODO
+```
+
 ## Graphic APIs
 
 There are currently two graphics APIs that can be selected, `WmrD3D11` and `SimD3D11`. A third one `Headless` exists but is not yet supported on the client side.
@@ -69,7 +77,7 @@ There are two things that need to be done to use the WMR binding:
 
 #### Inform Remote Rendering of the used coordinate system
 
-``` cs
+```cs
 AzureSession currentSesson = ...;
 IntPtr ptr = ...; // native pointer to ISpatialCoordinateSystem
 GraphicsBindingWmrD3d11 wmrBinding = (currentSession.GraphicsBinding as GraphicsBindingWmrD3d11);
@@ -79,18 +87,27 @@ if (binding.UpdateUserCoordinateSystem(ptr) == Result.Success)
 }
 ```
 
+```cpp
+TODO
+```
+
+
 Where the above `ptr` must be a pointer to a native `ABI::Windows::Perception::Spatial::ISpatialCoordinateSystem` object that defines the world space coordinate system in which coordinates in the API are expressed in.
 
 #### Render remote image
 
 At the start of each frame the remote frame needs to be rendered into the back buffer. This is done by calling `BlitRemoteFrame`, which will fill both color and depth information into the currently bound render target. Thus it is important that this is done after binding the back buffer as a render target.
 
-``` cs
+```cs
 AzureSession currentSesson = ...;
 GraphicsBindingWmrD3d11 wmrBinding = (currentSession.GraphicsBinding as GraphicsBindingWmrD3d11);
 binding.BlitRemoteFrame();
 ```
 
+```cpp
+TODO
+```
+
 ### Simulation
 
 `GraphicsApiType.SimD3D11` is the simulation binding and if selected it creates the `GraphicsBindingSimD3d11` graphics binding. This interface is used to simulate head movement, for example in a desktop application and renders a monoscopic image.
@@ -101,7 +118,7 @@ The setup is a bit more involved and works as follows:
 Remote and local content needs to be rendered to an offscreen color / depth render target called 'proxy' using
 the proxy camera data provided by the `GraphicsBindingSimD3d11.Update` function. The proxy must match the resolution of the back buffer. Once a session is ready, `GraphicsBindingSimD3d11.InitSimulation` needs to be called before connecting to it:
 
-``` cs
+```cs
 AzureSession currentSesson = ...;
 IntPtr d3dDevice = ...; // native pointer to ID3D11Device
 IntPtr color = ...; // native pointer to ID3D11Texture2D
@@ -113,6 +130,10 @@ GraphicsBindingSimD3d11 simBinding = (currentSession.GraphicsBinding as Graphics
 simBinding.InitSimulation(d3dDevice, depth, color, refreshRate, flipBlitRemoteFrameTextureVertically, flipReprojectTextureVertically);
 ```
 
+```cpp
+TODO
+```
+
 The init function needs to be provided with pointers to the native d3d-device as well as to the color and depth texture of the proxy render target. Once initialized, `AzureSession.ConnectToRuntime` and `DisconnectFromRuntime` can be called multiple times but when switching to a different session, `GraphicsBindingSimD3d11.DeinitSimulation` needs to be called first on the old session before `GraphicsBindingSimD3d11.InitSimulation` can be called on another session.
 
 #### Render loop update
@@ -124,7 +145,7 @@ If the returned proxy update `SimulationUpdate.frameId` is null, there is no rem
 1. The application should now bind the proxy render target and call `GraphicsBindingSimD3d11.BlitRemoteFrameToProxy`. This will fill the remote color and depth information into the proxy render target. Any local content can now be rendered onto the proxy using the proxy camera transform.
 1. Next, the back buffer needs to be bound as a render target and `GraphicsBindingSimD3d11.ReprojectProxy` called at which point the back buffer can be presented.
 
-``` cs
+```cs
 AzureSession currentSesson = ...;
 GraphicsBindingSimD3d11 simBinding = (currentSession.GraphicsBinding as GraphicsBindingSimD3d11);
 SimulationUpdate update = new SimulationUpdate();
@@ -150,6 +171,10 @@ else
 }
 ```
 
+```cpp
+TODO
+```
+
 ## Next steps
 
 * [Tutorial: Setting up a Unity project from scratch](../tutorials/unity/project-setup.md)

articles/remote-rendering/concepts/materials.md

@@ -34,7 +34,7 @@ When you modify a material directly on the mesh resource, this change affects al
 
 All materials provided by the API derive from the base class `Material`. Their type can be queried through `Material.MaterialSubType` or by casting them directly:
 
-``` cs
+```cs
 void SetMaterialColorToGreen(Material material)
 {
     if (material.MaterialSubType == MaterialType.Color)
@@ -54,6 +54,11 @@ void SetMaterialColorToGreen(Material material)
 }
 ```
 
+```cpp
+TODO
+```
+
+
 ## Next steps
 
 * [PBR materials](../overview/features/pbr-materials.md)

articles/remote-rendering/concepts/object-bounds.md

@@ -19,7 +19,7 @@ It's possible to compute the bounds of an entire object hierarchy this way, but
 
 A better way is to call `QueryLocalBoundsAsync` or `QueryWorldBoundsAsync` on an entity. The computation is then offloaded to the server and returned with minimal delay.
 
-``` cs
+```cs
 private BoundsQueryAsync _boundsQuery = null;
 
 public void GetBounds(Entity entity)
@@ -37,6 +37,11 @@ public void GetBounds(Entity entity)
 }
 ```
 
+```cpp
+TODO
+```
+
+
 ## Next steps
 
 * [Spatial queries](../overview/features/spatial-queries.md)

articles/remote-rendering/concepts/sessions.md

@@ -77,7 +77,7 @@ You can [extend the lease time](../how-tos/session-rest-api.md#update-a-session)
 
 The code below shows a simple implementation of starting a session, waiting for the *ready* state, connecting, and then disconnecting and shutting down again.
 
-``` cs
+```cs
 RemoteRenderingInitialization init = new RemoteRenderingInitialization();
 // fill out RemoteRenderingInitialization parameters...
 
@@ -131,6 +131,11 @@ await session.StopAsync().AsTask();
 RemoteManagerStatic.ShutdownRemoteRendering();
 ```
 
+```cpp
+TODO
+```
+
+
 Multiple `AzureFrontend` and `AzureSession` instances can be maintained, manipulated, and queried from code. But only a single device may connect to an `AzureSession` at a time.
 
 The lifetime of a virtual machine isn't tied to the `AzureFrontend` instance or the `AzureSession` instance. `AzureSession.StopAsync` must be called to stop a session.

articles/remote-rendering/concepts/textures.md

@@ -34,7 +34,7 @@ Similar to loading models, there are two variants of addressing a texture asset
 
 The following sample code shows how to load a texture via its SAS URI (or built-in texture) - note that only the loading function/parameter differs for the other case:
 
-``` cs
+```cs
 LoadTextureAsync _textureLoad = null;
 void LoadMyTexture(AzureSession session, string textureUri)
 {
@@ -55,6 +55,11 @@ void LoadMyTexture(AzureSession session, string textureUri)
 }
 ```
 
+```cpp
+TODO
+```
+
+
 Depending on what the texture is supposed to be used for, there may be restrictions for the texture type and content. For example, the roughness map of a [PBR material](../overview/features/pbr-materials.md) must be grayscale.
 
 > [!CAUTION]

articles/remote-rendering/how-tos/frontend-apis.md

@@ -73,7 +73,7 @@ For more information about the conversion service, see [the model conversion RES
 
 #### Start asset conversion
 
-``` cs
+```cs
 private StartConversionAsync _pendingAsync = null;
 
 void StartAssetConversion(AzureFrontend frontend, string modelName, string modelUrl, string assetContainerUrl)
@@ -97,9 +97,14 @@ void StartAssetConversion(AzureFrontend frontend, string modelName, string model
 }
 ```
 
+```cpp
+TODO
+```
+
+
 #### Get conversion status
 
-``` cs
+```cs
 private ConversionStatusAsync _pendingAsync = null
 void GetConversionStatus(AzureFrontend frontend, string assetId)
 {
@@ -121,6 +126,11 @@ void GetConversionStatus(AzureFrontend frontend, string assetId)
 }
 ```
 
+```cpp
+TODO
+```
+
+
 ### Rendering APIs
 
 See [the session management REST API](session-rest-api.md) for details about session management.
@@ -129,7 +139,7 @@ A rendering session can either be created dynamically on the service or an alrea
 
 #### Create rendering session
 
-``` cs
+```cs
 private CreateSessionAsync _pendingAsync = null;
 void CreateRenderingSession(AzureFrontend frontend, RenderingSessionVmSize vmSize, ARRTimeSpan maxLease)
 {
@@ -152,21 +162,30 @@ void CreateRenderingSession(AzureFrontend frontend, RenderingSessionVmSize vmSiz
 }
 ```
 
+```cpp
+TODO
+```
+
 #### Open an existing rendering session
 
 Opening an existing session is a synchronous call.
 
-``` cs
+```cs
 void CreateRenderingSession(AzureFrontend frontend, string sessionId)
 {
     AzureSession session = frontend.OpenRenderingSession(sessionId);
     // Query session status, etc.
 }
 ```
 
+```cpp
+TODO
+```
+
+
 #### Get current rendering sessions
 
-``` cs
+```cs
 private SessionPropertiesArrayAsync _pendingAsync = null;
 void GetCurrentRenderingSessions(AzureFrontend frontend)
 {
@@ -187,11 +206,15 @@ void GetCurrentRenderingSessions(AzureFrontend frontend)
 }
 ```
 
+```cpp
+TODO
+```
+
 ### Session APIs
 
 #### Get rendering session properties
 
-``` cs
+```cs
 private SessionPropertiesAsync _pendingAsync = null;
 void GetRenderingSessionProperties(AzureSession session)
 {
@@ -212,9 +235,13 @@ void GetRenderingSessionProperties(AzureSession session)
 }
 ```
 
+```cpp
+TODO
+```
+
 #### Update rendering session
 
-``` cs
+```cs
 private SessionAsync _pendingAsync;
 void UpdateRenderingSession(AzureSession session, ARRTimeSpan updatedLease)
 {
@@ -236,9 +263,13 @@ void UpdateRenderingSession(AzureSession session, ARRTimeSpan updatedLease)
 }
 ```
 
+```cpp
+TODO
+```
+
 #### Stop rendering session
 
-``` cs
+```cs
 private SessionAsync _pendingAsync;
 void StopRenderingSession(AzureSession session)
 {
@@ -259,9 +290,13 @@ void StopRenderingSession(AzureSession session)
 }
 ```
 
+```cpp
+TODO
+```
+
 #### Connect to ARR inspector
 
-``` cs
+```cs
 private ArrInspectorAsync _pendingAsync = null;
 void ConnectToArrInspector(AzureSession session, string hostname)
 {
@@ -294,6 +329,10 @@ void ConnectToArrInspector(AzureSession session, string hostname)
 }
 ```
 
+```cpp
+TODO
+```
+
 ## Next steps
 
 * [Create an account](create-an-account.md)

articles/remote-rendering/overview/features/debug-rendering.md

@@ -21,7 +21,7 @@ The debug rendering API provides a range of global options to alter server-side
 
 The following code enables these debugging effects:
 
-``` cs
+```cs
 void EnableDebugRenderingEffects(AzureSession session, bool highlight)
 {
     DebugRenderingSettings settings = session.Actions.DebugRenderingSettings;
@@ -37,6 +37,10 @@ void EnableDebugRenderingEffects(AzureSession session, bool highlight)
 }
 ```
 
+```cpp
+TODO
+```
+
 ![Debug rendering](./media/debug-rendering.png)
 
 > [!NOTE]

articles/remote-rendering/overview/features/outlines.md

@@ -29,7 +29,7 @@ Class `OutlineSettings` holds the settings related to global outline properties.
 
 The following code shows an example for setting outline parameters via the API:
 
-``` cs
+```cs
 void SetOutlineParameters(AzureSession session)
 {
     OutlineSettings outlineSettings = session.Actions.OutlineSettings;
@@ -39,6 +39,10 @@ void SetOutlineParameters(AzureSession session)
 }
 ```
 
+```cpp
+TODO
+```
+
 ## Performance
 
 Outline rendering may have a significant impact on rendering performance. This impact varies based on screen-space spatial relation between selected and non-selected objects for a given frame.