Model I/O: 2. UV Set fuer MDLMesh

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • ja, sorry, wenn das etwas knapp war... daher hier etwas ausfuehrlicher - in der Hoffnung dass es ueberhaupt Leute gibt, die sich native 3D antun...

    Also ich suche einen Weg, wie ich ein 2. UV-Set implementieren kann. Das erste brauche ich fuer kachelbare diffuse Maps und das zweite fuer eine objekt-bezogene 'Ganzkoerper'-Normal Map.

    Zu diesem Zweck verwende ich das CTM-Format, das passt auch alles soweit. Siehe Code.

    Nun suche ich einen Weg, das 2. UV-Set so zu implementieren dass ich es zumindest erstmal bis in die SCNGeometry hinueberretten kann. Im gegensatz zu Unity-3D scheint es dafuer wohl keine dedizierte VertexAttribute-Semantik zu geben, so dass ich mich schweren Herzens mit dem gedanken trage ein anderes Attribute zu verwenden. Das waere meine erste Frage gewesen... ist unten auskommentiert.

    Der Spass geht dann natuerlich auf der SCN-Ebene weiter, wobei es wohl auf einen Custom-Shader hinauslaufen wird, was wohl auf SCN-Ebene (im Gegensatz zur Model IO-Ebene) kein Problem ist. Auch hier waere ich ueber Gedankenaustausch/Tipps dankbar.

    Mahlzeit,

    Ekki

    Quellcode

    1. using System;
    2. using System.IO;
    3. using OpenCTM;
    4. using ModelIO;
    6. // https://developer.apple.com/videos/play/wwdc2015/602/
    8. namespace IG.Mobile.Planning.iOS
    9. {
    10. public static class D3OpenCtm
    11. {
    12. /// <summary>
    13. /// Submeshes seem to need an initial non-null material otherwise staying white.
    14. /// </summary>
    15. static readonly MDLMaterial defaultMaterial = new MDLMaterial();
    17. public static MDLMesh FromCtm(FileStream stream)
    18. {
    19. var tReader = new CtmFileReader(stream);
    20. var tSourceMesh = tReader.decode();
    22. var tVertexCount = tSourceMesh.getVertexCount();
    24. var tAllocator = new MDLMeshBufferDataAllocator();
    26. #region Indices
    28. var tByteArray = new byte[tSourceMesh.indices.Length * sizeof(int)];
    29. Buffer.BlockCopy(tSourceMesh.indices, 0, tByteArray, 0, tByteArray.Length);
    30. var tIndexBuffer = tAllocator.CreateBuffer(Foundation.NSData.FromArray(tByteArray), MDLMeshBufferType.Index);
    32. #endregion
    34. #region Configuration
    36. var tHasNormals = tSourceMesh.hasNormals();
    38. float[] tUVCoordinates = null;
    39. float[] tUV2Coordinates = null;
    41. if (tSourceMesh.texCoordinates != null)
    42. {
    43. foreach (var tData in tSourceMesh.texCoordinates)
    44. {
    45. switch (tData.name)
    46. {
    47. case OpenCTM.Mesh.DiffuseColor:
    48. tUVCoordinates = tData.values;
    49. break;
    50. case OpenCTM.Mesh.Object:
    51. tUV2Coordinates = tData.values;
    52. break;
    53. }
    54. }
    55. }
    57. var tHasUVs = tUVCoordinates != null;
    58. var tHasUV2s = tUV2Coordinates != null;
    60. #endregion
    62. #region Vertices
    64. var tVertexSize = 3;
    66. if (tHasNormals)
    67. {
    68. tVertexSize += 3;
    69. }
    71. if (tHasUVs)
    72. {
    73. tVertexSize += 2;
    74. }
    76. if (tHasUV2s)
    77. {
    78. tVertexSize += 2;
    79. }
    81. var tVertices = new float[tVertexCount * tVertexSize];
    83. var tVCnt = 0;
    85. var tPCnt = 0;
    86. var tNCnt = 0;
    87. var tUVCnt = 0;
    88. var tUV2Cnt = 0;
    90. for (var tI = 0; tI < tVertexCount; tI++)
    91. {
    92. tVertices[tVCnt++] = tSourceMesh.vertices[tPCnt++];
    93. tVertices[tVCnt++] = tSourceMesh.vertices[tPCnt++];
    94. tVertices[tVCnt++] = tSourceMesh.vertices[tPCnt++];
    96. if (tHasNormals)
    97. {
    98. tVertices[tVCnt++] = tSourceMesh.normals[tNCnt++];
    99. tVertices[tVCnt++] = tSourceMesh.normals[tNCnt++];
    100. tVertices[tVCnt++] = tSourceMesh.normals[tNCnt++];
    101. }
    103. if (tHasUVs)
    104. {
    105. tVertices[tVCnt++] = tUVCoordinates[tUVCnt++];
    106. tVertices[tVCnt++] = tUVCoordinates[tUVCnt++];
    107. }
    109. if (tHasUV2s)
    110. {
    111. tVertices[tVCnt++] = tUV2Coordinates[tUV2Cnt++];
    112. tVertices[tVCnt++] = tUV2Coordinates[tUV2Cnt++];
    113. }
    114. }
    116. tByteArray = new byte[tVertices.Length * sizeof(float)];
    117. Buffer.BlockCopy(tVertices, 0, tByteArray, 0, tByteArray.Length);
    118. var tVertexBuffer = tAllocator.CreateBuffer(Foundation.NSData.FromArray(tByteArray), MDLMeshBufferType.Vertex);
    120. #endregion
    122. #region Creation
    124. var tVertexDescriptor = new MDLVertexDescriptor();
    126. var tVertexAttribute = new MDLVertexAttribute(MDLVertexAttributes.Position, MDLVertexFormat.Float3, 0, 0);
    127. tVertexDescriptor.AddOrReplaceAttribute(tVertexAttribute);
    128. var tOffset = (nuint)3;
    130. if (tHasNormals)
    131. {
    132. tVertexAttribute = new MDLVertexAttribute(MDLVertexAttributes.Normal, MDLVertexFormat.Float3, tOffset * sizeof(float), 0);
    133. tVertexDescriptor.AddOrReplaceAttribute(tVertexAttribute);
    134. tOffset += 3;
    135. }
    137. if (tHasUVs)
    138. {
    139. tVertexAttribute = new MDLVertexAttribute(MDLVertexAttributes.TextureCoordinate, MDLVertexFormat.Float2, tOffset * sizeof(float), 0);
    140. tVertexDescriptor.AddOrReplaceAttribute(tVertexAttribute);
    141. tOffset += 2;
    142. }
    144. if (tHasUV2s)
    145. {
    146. // tVertexAttribute = new MDLVertexAttribute(MDLVertexAttributes., MDLVertexFormat.Float2, tOffset * sizeof(float), 0);
    147. // tVertexDescriptor.AddOrReplaceAttribute(tVertexAttribute);
    148. tOffset += 2;
    149. }
    151. tVertexDescriptor.Layouts = new Foundation.NSMutableArray<MDLVertexBufferLayout>(new MDLVertexBufferLayout[]
    152. {
    153. new MDLVertexBufferLayout(tOffset * (sizeof(float)))
    154. });
    156. var tMesh = new MDLMesh(tVertexBuffer, (nuint)tVertexCount, tVertexDescriptor, new MDLSubmesh[]
    157. {
    158. new MDLSubmesh(tIndexBuffer, (nuint)tSourceMesh.indices.Length, MDLIndexBitDepth.UInt32, MDLGeometryType.Triangles, defaultMaterial)
    159. });
    161. /*
    162. if (!tHasNormals)
    163. {
    164. tMesh.AddNormals(MDLVertexAttributes.Normal, 0.2f);
    165. }
    166. */
    168. #endregion
    170. return tMesh;
    171. }
    172. }
    173. }
    Alles anzeigen

  • 1) man kann eine eigene MDL-Vertex-Attribute-Semantik definieren, z.B. MDLVertexAttributes.TextureCoordinate + "2"

    2) dann kommt das auf Ebene SCNGeometry sauber an und wird auch als Texturkoordinaten-GeometrySource erkannt (aufgrund welcher Heuristik auch immer)

    3) dann kann man den Index dieser GeometrySource innerhalb der TextureCoordinates-GeometrySources (wichtig!) der Normal-Map als mappingChannel mit geben.

    und alles laueft wie erwartet!