ArcGIS Pro 3.0 API Reference Guide
ArcGIS.Core.Geometry Namespace / Multipatch Class / GetPatchPriority Method
The index of the patch. Must be greater than or equal to zero and less than PartCount.
Example

In This Topic
    GetPatchPriority Method
    In This Topic
    Gets a value representing the priority of the specified patch (part).
    Syntax
    public int GetPatchPriority( 
       int patchIndex
    )
    Public Function GetPatchPriority( _
       ByVal patchIndex As Integer _
    ) As Integer

    Parameters

    patchIndex
    The index of the patch. Must be greater than or equal to zero and less than PartCount.
    Exceptions
    ExceptionDescription
    The patch index must be >= 0.
    The patch index must be less than the number of patches (parts) in the multipatch.
    Remarks
    When overlapping patches are defined within the same multipatch, patch priorities can be used to explicitly specify the order in which patches should be drawn when rendered. The larger the number assigned, the higher the patch priority or precedence the patch takes when rendered.
    Example
    Multipatch Properties
    // standard geometry properties
    bool hasZ = multipatch.HasZ;
    bool hasM = multipatch.HasM;
    bool hasID = multipatch.HasID;
    bool isEmpty = multipatch.IsEmpty;
    var sr = multipatch.SpatialReference;
    
    // number of patches (parts)
    int patchCount = multiPatch.PartCount;
    // number of points
    int pointCount = multiPatch.PointCount;
    
    // retrieve the points as MapPoints
    ReadOnlyPointCollection points = multipatch.Points;
    // or as 3D Coordinates
    IReadOnlyList<Coordinate3D> coordinates = multipatch.Copy3DCoordinatesToList();
    
    
    // multipatch materials
    bool hasMaterials = multiPatch.HasMaterials;
    int materialCount = multiPatch.MaterialCount;
    
    
    // multipatch textures
    bool hasTextures = multiPatch.HasTextures;
    int textureVertexCount = multiPatch.TextureVertexCount;
    
    // normals
    bool hasNormals = multiPatch.HasNormals;
    
    
    // properties for an individual patch (if multipatch.PartCount > 0)
    int patchPriority = multiPatch.GetPatchPriority(patchIndex);
    PatchType patchType = multiPatch.GetPatchType(patchIndex);
    
    // patch points
    int patchPointCount = multiPatch.GetPatchPointCount(patchIndex);
    int pointStartIndex = multiPatch.GetPatchStartPointIndex(patchIndex);
    // the patch Points are then the points in multipatch.Points from pointStartIndex to pointStartIndex + patchPointCount 
    
    // if the multipatch has materials 
    if (hasMaterials)
    {
      // does the patch have a material?  
      //   materialIndex = -1 if the patch does not have a material; 
      //   0 <= materialIndex < materialCount if the patch does have materials
      int materialIndex = multipatch.GetPatchMaterialIndex(patchIndex);
    
    
      // properties for an individual material (if multipatch.MaterialCount > 0)
      var color = multipatch.GetMaterialColor(materialIndex);
      var edgeColor = multipatch.GetMaterialEdgeColor(materialIndex);
      var edgeWidth = multipatch.GetMaterialEdgeWidth(materialIndex);
      var shiness = multipatch.GetMaterialShininess(materialIndex);
      var percent = multipatch.GetMaterialTransparencyPercent(materialIndex);
      var cullBackFace = multipatch.IsMaterialCullBackFace(materialIndex);
    
      // texture properties
      bool isTextured = multipatch.IsMaterialTextured(materialIndex);
      if (isTextured)
      {
        int columnCount = multipatch.GetMaterialTextureColumnCount(materialIndex);
        int rowCount = multipatch.GetMaterialTextureRowCount(materialIndex);
        int bpp = multipatch.GetMaterialTextureBytesPerPixel(materialIndex);
        TextureCompressionType compressionType = multipatch.GetMaterialTextureCompressionType(materialIndex);
        var texture = multipatch.GetMaterialTexture(materialIndex);
      }
    }
    
    // texture coordinates (if multipatch.HasTextures = true)
    if (hasTextures)
    {
      int numPatchTexturePoints = multiPatch.GetPatchTextureVertexCount(patchIndex);
      var coordinate2D = multiPatch.GetPatchTextureCoordinate(patchIndex, 0);
    
      ICollection<Coordinate2D> textureCoordinates = new List<Coordinate2D>(numPatchTexturePoints);
      multiPatch.GetPatchTextureCoordinates(patchIndex, ref textureCoordinates);
    }
    
    
    // patch normals (if multipatch.HasNormals = true)
    if (hasNormals)
    {
      //  number of normal coordinates = multipatch.GetPatchPointCount(patchIndex)
      Coordinate3D patchNormal = multipatch.GetPatchNormal(patchIndex, 0);
      ICollection<Coordinate3D> normalCoordinates = new List<Coordinate3D>(patchPointCount);
      multipatch.GetPatchNormals(patchIndex, ref normalCoordinates);
    }
    
    
    Requirements

    Target Platforms: Windows 11, Windows 10, Windows 8.1

    See Also