Updated main to Version 1.2.2

Author: ChristopherRemde

Converter/Sequence_Converter.py

@@ -19,10 +19,11 @@ class MetaData():
     ASTC = False
     hasUVs = False
     hasNormals = False
+    useCompression = False
     maxVertexCount = 0
     maxIndiceCount = 0
-    boundsCenter = [0,0,0]
-    boundsSize = [1,1,1]
+    boundsMin = [float('inf'),float('inf'),float('inf')]
+    boundsMax = [float('-inf'),float('-inf'),float('-inf')]
     textureWidth = 0
     textureHeight = 0
     textureSizeDDS = 0
@@ -32,21 +33,33 @@ class MetaData():
     indiceCounts = []
 
     #Ensure that this class can be called from multiple threads
-    metaDataLock = Lock() 
+    metaDataLock = Lock()
 
     def get_as_dict(self):
+        
+        boundsCenter, boundsSize = self.get_metadata_bounds()
 
         asDict = {
+            "sequenceVersion" : "1.2.2",
             "geometryType" : int(self.geometryType),
             "textureMode" : int(self.textureMode),
             "DDS" : self.DDS,
             "ASTC" : self.ASTC,
             "hasUVs" : self.hasUVs,
             "hasNormals" : self.hasNormals,
+            "useCompression" : self.useCompression,
             "maxVertexCount": self.maxVertexCount,
             "maxIndiceCount" : self.maxIndiceCount,
-            "boundsCenter" : self.boundsCenter,
-            "boundsSize" : self.boundsSize,
+            "boundsCenter" : { # Export bounds as dicts for easier JSON parsing to Vector3 in Unity
+                "x" : boundsCenter[0],
+                "y" : boundsCenter[1],
+                "z" : boundsCenter[2]
+            },
+            "boundsSize" : {
+                "x" : boundsSize[0],
+                "y" : boundsSize[1],
+                "z" : boundsSize[2]
+            },
             "textureWidth" : self.textureWidth,
             "textureHeight" : self.textureHeight,
             "textureSizeDDS" : self.textureSizeDDS,
@@ -57,39 +70,71 @@ def get_as_dict(self):
         }
 
         return asDict
-        
-    def set_metadata_Model(self, vertexCount, indiceCount, headerSize, bounds, geometryType, hasUV, hasNormals, listIndex):
-        
+
+    def set_metadata_Model(self, vertexCount, indiceCount, headerSize, geometryType, hasUV, hasNormals, useCompressions, listIndex):
+
         self.metaDataLock.acquire()
 
         self.geometryType = geometryType
         self.hasUVs = hasUV
         self.hasNormals = hasNormals
+        self.useCompression = useCompressions
 
         if(vertexCount > self.maxVertexCount):
             self.maxVertexCount = vertexCount
 
         if(indiceCount > self.maxIndiceCount):
             self.maxIndiceCount = indiceCount
 
-        self.boundsCenter = bounds.center().tolist()
-        self.boundsSize = [bounds.dim_x(), bounds.dim_y(), bounds.dim_z()]
-
-        # Flip bounds x axis, as we also flip the model's x axis to match Unity's coordinate system
-        self.boundsCenter[0] *= -1 # Min X
-
         self.headerSizes[listIndex] = headerSize
         self.verticeCounts[listIndex] = vertexCount
         self.indiceCounts[listIndex] = indiceCount
 
         self.metaDataLock.release()
 
+    def extend_bounds(self, newBoundsMin, newBoundsMax):
+
+        self.metaDataLock.acquire()
+
+        self.boundsMin = [
+            min(self.boundsMin[0], newBoundsMin[0]),
+            min(self.boundsMin[1], newBoundsMin[1]),
+            min(self.boundsMin[2], newBoundsMin[2]),
+        ]
+        self.boundsMax = [
+            max(self.boundsMax[0], newBoundsMax[0]),
+            max(self.boundsMax[1], newBoundsMax[1]),
+            max(self.boundsMax[2], newBoundsMax[2]),
+        ]
+
+        self.metaDataLock.release()
+    
+    def get_metadata_bounds(self):
+
+        boundsCenter = [
+            (self.boundsMax[0] + self.boundsMin[0]) / 2,
+            (self.boundsMax[1] + self.boundsMin[1]) / 2,
+            (self.boundsMax[2] + self.boundsMin[2]) / 2,
+        ]
+
+        boundsSize = [
+            self.boundsMax[0] - self.boundsMin[0],
+            self.boundsMax[1] - self.boundsMin[1],
+            self.boundsMax[2] - self.boundsMin[2],
+        ]
+
+        # Flip bounds x axis, as we also flip the model's x axis to match Unity's coordinate system
+        boundsCenter[0] *= -1
+
+        return boundsCenter, boundsSize
+
+
     def set_metadata_texture(self, DDS, ASTC, width, height, sizeDDS, sizeASTC, textureMode):
 
         self.metaDataLock.acquire()
 
         if(height > self.textureHeight):
-            self.textureHeight = height 
+            self.textureHeight = height
 
         if(width > self.textureWidth):
             self.textureWidth = width
@@ -113,6 +158,6 @@ def write_metaData(self, outputDir):
         outputPath = outputDir + "/sequence.json"
         content = self.get_as_dict()
         with open(outputPath, 'w') as f:
-            json.dump(content, f)    
+            json.dump(content, f)
 
         self.metaDataLock.release()

Converter/Sequence_Converter_UI.py

@@ -13,6 +13,18 @@ weight: 420
 toc: true
 ---
 
+### Version 1.2.2
+
+This version contains several new features, contributed by [Anwar Lu](https://github.com/MrGcGamer):
+
+- **Converter Tool MacOS support:** The converter tool now supports MacOS as well (texture compression is not yet supported)
+- **Sequence Compression:** Sequences can now be compressed to around half their size!
+
+Fixes:
+
+- [Issue #9](https://github.com/BuildingVolumes/Unity_Geometry_Sequence_Player/issues/11)
+- Several small bug fixes and additions
+
 ### Version 1.2.1
 
 This version contains a small improvement for the rendering bounds of Sequences. The bounds were not correctly calculated in previous version, leading to the sequence not being correctly culled from the camera view.

Converter/Sequence_Metadata.py

@@ -27,10 +27,14 @@ The Unity Asset Store version of the package is licensed under the [Unity Standa
 
 ## Credits
 
-- This website was created with the **[Doks](https://getdoks.org/)** theme made by **[Thulite](https://thulite.io/)**
+- The compression feature and MacOS support for the converter were made by [Anwar Lu](https://www.linkedin.com/in/anwar-lu/) - Thanks!
 
 - The sequences in the showreel, from the landing page and on Github, were created by:
 
   - ["A Windy Day2 by Loic Norgeot](https://sketchfab.com/3d-models/a-windy-day-fb78f4cc938144e6902dd5cff354d525)
 
   - ["Galactic Incident2 by Loic Norgeot](https://sketchfab.com/3d-models/galactic-incident-397b266af9604b9fbf0a4e5446cf864b)
+
+- This website was created with the **[Doks](https://getdoks.org/)** theme made by **[Thulite](https://thulite.io/)**
+
+- The converter tool is made possible by [PyMeshLab](https://github.com/cnr-isti-vclab/PyMeshLab), [DearPyGUI](https://github.com/hoffstadt/DearPyGui), [ASTCEncoder](https://github.com/ARM-software/astc-encoder) and [TexConv](https://github.com/microsoft/DirectXTex/wiki/texconv)

Geometry_Sequence_Player_Package

@@ -37,6 +37,11 @@ Go to the **Geometry Sequence Stream** component that can be found on the same G
 
 If you have a mesh sequence with textures, you can also control to which texture slot the texture will be applied. By default, textures will always be applied to the Main/Albedo/Diffuse slot, which is defined in the shader as _\_MainTexture_. But you can also apply the texture to any other slot. Either you select one or more predefined slots in the **Apply to texture slots** variable, or you enter the name of the texture slot into the **Custom texture slots** list. This has to be the name of the texture slot as found in the **shader**, not the material! Shader texture slot variables are often prefixed with an _Underscore.
 
+### Mesh normals
+
+By default, mesh normals won't be saved in the sequence, as it increases the sequence size and is not necessary in most cases. Unity will generate
+new normals during playback. However, if you need precise normals (for example for hard-surface meshes), you can also keep the original normals, by activating the "Save Normals" option in the sequence converter before converting your sequence.
+
 ## Pointcloud sequences
 
 Changing the appearance of the pointcloud works very differently compared to meshes, as pointclouds require special shaders for rendering correctly. If you don't assign a custom pointcloud material, there are some predefined settings you can use to easily and quickly the appearance. These settings can be found under the **Geometry Sequence Stream** component and include the **Point Size** as well as the **Point Emission Strength**.
@@ -74,3 +79,11 @@ If you don't set a custom material, a default pointcloud material will be loaded
 `Packages > Geometry Sequence Player > Runtime > Shader > Resources`
 
 You'll see three different sets of shaders, _Legacy_, _Shadergraph_ and _Polyspatial_. Clone one of the shaders appropriate for your chosen render path. Then, create a material that uses your freshly cloned shader and apply it under **Custom Material**. For quick iteration, we recommend to disable the **Instantiate Shader** option. If you're a little bit familiar with Shaderlab/Shadergraph, you should be able to get an idea of how the shaders work, by taking a look at the commented code/graph.
+
+### Pointcloud normals
+
+![Pointcloud normals example](pointcloud_normals.jpg)
+
+In comparison to meshes, pointcloud sequences usually don't contain any normals. If you want your pointcloud sequence to receive lighting and shadows inside Unity, you need to generate normals. The sequence converter comes with a build-in functionality to estimate pointcloud normals and save them in the sequence.
+
+[More info](/Unity_Geometry_Sequence_Player/docs/tutorials/preparing-your-sequences/#using-the-converter/)