Merge pull request #196845 from TimShererWithAquent/t596438e

Edits to improve SEO and usability

Author: LJSpiller

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

@@ -1,24 +1,26 @@
 ---
 title: Object bounds
-description: Explains how spatial object bounds can be queried
+description: Learn how spatial object bounds can be queried. Object bounds represent the volume that an entity and its children occupy. 
 author: florianborn71
 ms.author: flborn
 ms.date: 02/03/2020
 ms.topic: conceptual
-ms.custom: devx-track-csharp
+ms.custom: 
+- devx-track-csharp
+- kr2b-contr-experiment
 ---
 
 # Object bounds
 
-Object bounds represent the volume that an [entity](entities.md) and its children occupy. In Azure Remote Rendering, object bounds are always given as *axis aligned bounding boxes* (AABB). Object bounds can be either in *local space* or in *world space*. Either way, they are always axis-aligned, which means the extents and volume may differ between the local and world space representation.
+Object bounds represent the volume that an [entity](entities.md) and its children occupy. In Azure Remote Rendering, object bounds are always given as *axis aligned bounding boxes* (AABB). Object bounds can be either in *local space* or in *world space*. Either way, they're always axis-aligned, which means the extents and volume may differ between the local and world space representation.
 
 ## Querying object bounds
 
-The local axis aligned bounding box of a [mesh](meshes.md) can be queried directly from the mesh resource. These bounds can be transformed into the local space or world space of an entity using the entity's transform.
+The local axis aligned bounding box of a mesh can be queried directly from the mesh resource. These bounds can be transformed into the local space or world space of an entity using the entity's transform. For more information, see [Meshes](meshes.md).
 
-It's possible to compute the bounds of an entire object hierarchy this way, but that requires to traverse the hierarchy, query the bounds for each mesh, and combine them manually. This operation is both tedious and inefficient.
+It's possible to compute the bounds of an entire object hierarchy this way. That approach requires traversing the hierarchy, querying the bounds for each mesh, and combining them manually. This operation is both tedious and inefficient.
 
-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.
+A better way is to call `QueryLocalBoundsAsync` or `QueryWorldBoundsAsync` on an entity. This approach offloads computation to the server and returns with minimal delay.
 
 ```cs
 public async void GetBounds(Entity entity)

articles/remote-rendering/how-tos/conversion/override-materials.md

@@ -1,24 +1,26 @@
 ---
 title: Override materials during model conversion
-description: Explains the material overriding workflow at conversion time
+description: Learn about the material overriding workflow at conversion time. Material settings in the source model define the PBR materials used by the renderer.
 author: florianborn71
 ms.author: flborn
 ms.date: 02/13/2020
 ms.topic: how-to
+ms.custom: kr2b-contr-experiment
 ---
 
 # Override materials during model conversion
 
-The material settings in the source model are used to define the [PBR materials](../../overview/features/pbr-materials.md) used by the renderer.
-Sometimes the [default conversion](../../reference/material-mapping.md) doesn't give the desired results and you need to make changes.
+The material settings in the source model define the [PBR materials](../../overview/features/pbr-materials.md) used by the renderer.
+Sometimes the default conversion doesn't give the desired results and you need to make changes. For more information, see [Material mapping for model formats](../../reference/material-mapping.md).
+
 When a model is converted for use in Azure Remote Rendering, you can provide a material override file to customize how material conversion is done on a per-material basis.
-If a file called `<modelName>.MaterialOverrides.json` is found in the input container beside the input model `<modelName>.<ext>`, then it will be used as the material override file.
+If a file called *\<modelName>.MaterialOverrides.json* is found in the input container with the input model *\<modelName>.\<ext>*, it's used as the material override file.
 
 ## The override file used during conversion
 
-As a simple example, let's say that a box model has a single material, called "Default".
-Additionally, let's say its albedo color needs to be adjusted for use in ARR.
-In this case, a `box.MaterialOverrides.json` file can be created as follows:
+As a simple example, take a box model that has a single material, called `Default`.
+Its albedo color needs to be adjusted for use in Remote Rendering.
+In this case, a *box.MaterialOverrides.json* file can be created as follows:
 
 ```json
 [
@@ -34,12 +36,12 @@ In this case, a `box.MaterialOverrides.json` file can be created as follows:
 ]
 ```
 
-The `box.MaterialOverrides.json` file is placed in the input container beside `box.fbx`, which tells the conversion service to apply the new settings.
+The *box.MaterialOverrides.json* file is placed in the input container with *box.fbx*, which tells the conversion service to apply the new settings.
 
 ### Color materials
 
-The [color material](../../overview/features/color-materials.md) model describes a constantly shaded surface that is independent of lighting.
-Color materials are useful for assets made by Photogrammetry algorithms, for example.
+The color material model describes a constantly shaded surface that is independent of lighting.
+Color materials are useful for assets made by Photogrammetry algorithms, for example. For more information, see [Color materials](../../overview/features/color-materials.md).
 In material override files, a material can be declared to be a color material by setting `unlit` to `true`.
 
 ```json
@@ -57,9 +59,9 @@ In material override files, a material can be declared to be a color material by
 
 ### Ignore specific texture maps
 
-Sometimes you might want the conversion process to ignore specific texture maps. This might be the case when your model was generated by a tool that generates special maps not understood correctly by the renderer. For example, an "OpacityMap" that is used to define something other than opacity, or a model where the "NormalMap" is stored as "BumpMap". (In the latter case you want to ignore "NormalMap", which will cause the converter to use "BumpMap" as "NormalMap".)
+Sometimes you might want the conversion process to ignore specific texture maps. This situation might happen when your model was generated by a tool that generates special maps not understood by the renderer. For example, an "OpacityMap" might be used to define something other than opacity, or the "NormalMap" is stored as "BumpMap". In the latter case you want to ignore "NormalMap", which causes the converter to use "BumpMap" as "NormalMap".
 
-The principle is simple. Just add a property called `ignoreTextureMaps` and add any texture map you want to ignore:
+Add a property called `ignoreTextureMaps` and add any texture map you want to ignore:
 
 ```json
 [
@@ -70,15 +72,15 @@ The principle is simple. Just add a property called `ignoreTextureMaps` and add
 ]
 ```
 
-For the full list of texture maps you can ignore, see the JSON schema below.
+For the full list of texture maps you can ignore, see the [JSON schema](#json-schema).
 
 ### Applying the same overrides to multiple materials
 
 By default, an entry in the material overrides file applies when its name matches the material name exactly.
-Since it's quite common that the same override should apply to multiple materials, you can optionally provide a regular expression as the entry name.
+Since it's common that the same override should apply to multiple materials, you can optionally provide a regular expression as the entry name.
 The field `nameMatching` has a default value `exact`, but it can be set to `regex` to state that the entry should apply to every matching material.
-The syntax used is the same as that used for JavaScript. 
-The following example shows an override which applies to materials with names like "Material2", "Material01" and "Material999".
+The syntax used is the same syntax used for JavaScript. 
+The following example shows an override that applies to materials with names like `Material2`, `Material01` and `Material999`.
 
 ```json
 [
@@ -95,17 +97,17 @@ The following example shows an override which applies to materials with names li
 ]
 ```
 
-At most one entry in a material override file applies to a single material.
-If there is an exact match (i.e. `nameMatching` is absent or equals `exact`) for the material name, then that entry is chosen.
+At most, one entry in a material override file applies to a single material.
+If there's an exact match (that is, `nameMatching` is absent or equals `exact`) for the material name, then that entry is chosen.
 Otherwise, the first regex entry in the file that matches the material name is chosen.
 
 ### Getting information about which entries applied
 
-The [info file](get-information.md#information-about-a-converted-model-the-info-file) written to the output container carries information about the number of overrides provided, and the number of materials that were overridden.
+The info file written to the output container carries information about the number of overrides provided, and the number of materials that were overridden. For more information, see [Information about a converted model](get-information.md#information-about-a-converted-model-the-info-file).
 
 ## JSON schema
 
-The full JSON schema for materials files is given here. With the exception of `unlit` and `ignoreTextureMaps`, the properties available are a subset of the properties described in the sections on the [color material](../../overview/features/color-materials.md) and [PBR material](../../overview/features/pbr-materials.md) models.
+The full JSON schema for materials files is given here. Except for `unlit` and `ignoreTextureMaps`, the properties available are a subset of the properties described in the sections on the [color material](../../overview/features/color-materials.md) and [PBR material](../../overview/features/pbr-materials.md) models.
 
 ```json
 {

articles/remote-rendering/overview/features/z-fighting-mitigation.md

@@ -1,24 +1,26 @@
 ---
 title: Z-fighting mitigation
-description: Describes techniques to mitigate z-fighting artifacts
+description: Learn about techniques to mitigate z-fighting artifacts that occur when surfaces overlap and it isn't clear which one should be rendered on top. 
 author: florianborn71
 ms.author: flborn
 ms.date: 02/06/2020
-ms.topic: article
-ms.custom: devx-track-csharp
+ms.topic: how-to
+ms.custom: 
+- devx-track-csharp
+- kr2b-contr-experiment
 ---
 
 # Z-fighting mitigation
 
-When two surfaces overlap, it is not clear which one should be rendered on top of the other. The result even varies per pixel, resulting in camera view-dependent artifacts. Consequently, when the camera or the mesh moves, these patterns flicker noticeably. This artifact is called *z-fighting*. For AR and VR applications, the problem is intensified because head-mounted devices naturally always move. To prevent viewer discomfort z-fighting mitigation functionality is available in Azure Remote Rendering.
+When two surfaces overlap, it isn't clear which one should be rendered on top of the other. The result even varies per pixel, resulting in camera view-dependent artifacts. When the camera or the mesh moves, these patterns flicker noticeably. This artifact is called *z-fighting*. For augmented reality and virtual reality applications, the problem is intensified because head-mounted devices naturally always move. To prevent viewer discomfort, Azure Remote Rendering offers z-fighting mitigation functionality.
 
 ## Z-fighting mitigation modes
 
 |Situation                        | Result                               |
 |---------------------------------|:-------------------------------------|
-|Regular z-fighting               |![No deterministic precedence between red and green quads](./media/zfighting-0.png)|
-|Z-fighting mitigation enabled    |![Red quad has precedence](./media/zfighting-1.png)|
-|Checkerboard highlighting enabled|![Red and green quad toggle preference in checkerboard pattern](./media/zfighting-2.png)|
+|Regular z-fighting               |![Screenshot shows no deterministic precedence between red and green quads.](./media/zfighting-0.png)|
+|Z-fighting mitigation enabled    |![Screenshot displays the red quad precedence with a solid red rectangle.](./media/zfighting-1.png)|
+|Checkerboard highlighting enabled|![Screenshot shows red and green quad toggle preference with a checkerboard pattern rectangle.](./media/zfighting-2.png)|
 
 The following code enables z-fighting mitigation:
 
@@ -55,16 +57,16 @@ void EnableZFightingMitigation(ApiHandle<RenderingSession> session, bool highlig
 
 Z-fighting happens mainly for two reasons:
 
-1. when surfaces are very far away from the camera, the precision of their depth values degrades and the values become indistinguishable
-1. when surfaces in a mesh physically overlap
+* When surfaces are very far away from the camera, the precision of their depth values degrades and the values become indistinguishable
+* When surfaces in a mesh physically overlap
 
-The first problem can always happen and is difficult to eliminate. If this happens in your application, make sure that the ratio of the *near plane* distance to the *far plane* distance is as low as practical. For example, a near plane at distance 0.01 and far plane at distance 1000 will create this problem much earlier, than having the near plane at 0.1 and the far plane at distance 20.
+The first problem can always happen and is difficult to eliminate. If this situation happens in your application, make sure that the ratio of the *near plane* distance to the *far plane* distance is as low as practical. For example, a near plane at distance 0.01 and far plane at distance 1000 creates this problem much earlier than having the near plane at 0.1 and the far plane at distance 20.
 
-The second problem is an indicator for badly authored content. In the real world, two objects can't be in the same place at the same time. Depending on the application, users might want to know whether overlapping surfaces exist and where they are. For example, a CAD scene of a building that is the basis for a real world construction, shouldn't contain physically impossible surface intersections. To allow for visual inspection, the highlighting mode is available, which displays potential z-fighting as an animated checkerboard pattern.
+The second problem is an indication of badly authored content. In the real world, two objects can't be in the same place at the same time. Depending on the application, users might want to know whether overlapping surfaces exist and where they are. For example, a CAD scene of a building that is the basis for a real world construction, shouldn't contain physically impossible surface intersections. To allow for visual inspection, the highlighting mode is available, which displays potential z-fighting as an animated checkerboard pattern.
 
 ## Limitations
 
-The provided z-fighting mitigation is a best effort. There is no guarantee that it removes all z-fighting. Also it will automatically prefer one surface over another. Thus when you have surfaces that are too close to each other, it might happen that the "wrong" surface ends up on top. A common problem case is when text and other decals are applied to a surface. With z-fighting mitigation enabled these details could easily just vanish.
+The provided z-fighting mitigation is a best effort. There's no guarantee that it removes all z-fighting. Also, mitigation prefers one surface over another. When you have surfaces that are too close to each other, the "wrong" surface ends up on top. A common problem case is when text and other decals are applied to a surface. With z-fighting mitigation enabled, these details could easily just vanish.
 
 ## Performance considerations