Flipped textures

Common_glTF_Exporter/Common_glTF_Exporter.projitems

@@ -41,6 +41,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Materials\BitmapsUtils.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Materials\MaterialProperties.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Materials\MaterialTextures.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Materials\TextureLocation.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Model\GlbComponents.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Model\Links.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Model\LoadContext.cs" />
@@ -68,6 +69,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Utils\MaterialUtils.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utils\GeometryUtils.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utils\GLTFBinaryDataUtils.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Utils\RevitIniReader.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utils\SettingsConfig.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utils\Theme.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Version\DownloadFile.cs" />

Common_glTF_Exporter/Core/GlTFExportContext.cs

@@ -316,7 +316,8 @@ public void OnPolymesh(PolymeshTopology polymesh)
                     if (preferences.materials == MaterialsEnum.textures && currentMaterial?.EmbeddedTexturePath != null)
                     {
                         UV uv = uvs[index];
-                        geomItem.Uvs.Add(uv);
+                        UV flippedUV = new UV(uv.U, 1.0 - uv.V);
+                        geomItem.Uvs.Add(flippedUV);
                     }
                 }
             }

Common_glTF_Exporter/Materials/AssetProperties.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using Revit_glTF_Exporter;
 
 namespace Common_glTF_Exporter.Materials
 {
@@ -15,7 +16,7 @@ public static class AssetPropertiesUtils
             Autodesk.Revit.DB.Visual.Hardwood.HardwoodColor,
             Autodesk.Revit.DB.Visual.AdvancedMetal.SurfaceAlbedo          
         };
-        private const string AUTODESKPATHTEXTURES = @"Autodesk Shared\Materials\Textures\";
+
 
         public static Asset GetDiffuseBitmap(Asset theAsset)
         {
@@ -41,17 +42,25 @@ public static string GetTexturePath(Asset connectedAsset)
 
                 if (bitmapPathProp != null && !string.IsNullOrEmpty(bitmapPathProp.Value))
                 {
-                    string texturePath = bitmapPathProp.Value.Split('|')[0].Replace("/", "\\");
+                    string relativeOrAbsolutePath = bitmapPathProp.Value.Split('|')[0].Replace("/", "\\");
 
-                    if (!Path.IsPathRooted(texturePath))
+                    // If already absolute and the file exists, return it directly
+                    if (Path.IsPathRooted(relativeOrAbsolutePath) && File.Exists(relativeOrAbsolutePath))
                     {
-                        string materialsPath = Path.Combine(
-                            Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles),
-                            AUTODESKPATHTEXTURES);
-                        texturePath = Path.Combine(materialsPath, texturePath);
+                        return relativeOrAbsolutePath;
                     }
 
-                    return texturePath;
+                    // Otherwise, search each base path
+                    foreach (string basePath in MainWindow.TexturePaths)
+                    {
+                        string candidatePath = Path.Combine(basePath, relativeOrAbsolutePath);
+                        string fullPath = Path.GetFullPath(candidatePath);
+
+                        if (File.Exists(fullPath))
+                        {
+                            return fullPath;
+                        }
+                    }
                 }
             }
 
@@ -110,6 +119,27 @@ public static float GetScale(Asset connectedAsset, string textureName)
             return 1;
         }
 
+        public static float GetOffset(Asset connectedAsset, string textureName)
+        {
+            AssetPropertyDistance offset =
+                connectedAsset.FindByName(textureName) as AssetPropertyDistance;
+
+            if (offset != null)
+            {
+                double offsetValue;
+
+#if REVIT2019 || REVIT2020
+                offsetValue = UnitUtils.Convert(offset.Value, offset.DisplayUnitType, DisplayUnitType.DUT_DECIMAL_FEET);
+#else
+            offsetValue = UnitUtils.Convert(offset.Value, offset.GetUnitTypeId(), UnitTypeId.Feet);
+#endif
+
+                return (float)offsetValue;
+            }
+
+            return 0;
+        }
+
         public static Autodesk.Revit.DB.Color GetTint(Asset asset)
         {
             bool tintOn = true;

Common_glTF_Exporter/Materials/BitmapsUtils.cs

@@ -3,6 +3,7 @@
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 

Common_glTF_Exporter/Materials/MaterialProperties.cs

@@ -19,7 +19,7 @@ public static void SetProperties(MaterialNode node, float opacity, ref GLTFPBR p
             gl_mat.alphaCutoff = null;
         }
 
-        public static void SetMaterialColour(MaterialNode node, 
+        public static void SetMaterialColour(MaterialNode node,
             float opacity, ref GLTFPBR pbr, ref GLTFMaterial gl_mat)
         {
             if (gl_mat.EmbeddedTexturePath == null)
@@ -28,33 +28,57 @@ public static void SetMaterialColour(MaterialNode node,
                 float sg = node.Color.Green / 255f;
                 float sb = node.Color.Blue / 255f;
 
-                // A linear conversion is needed to reflect the real colour
-                float lr = SrgbToLinear(sr);
-                float lg = SrgbToLinear(sg);
-                float lb = SrgbToLinear(sb);
+                if (gl_mat.TintColour == null)
+                {
+                    // A linear conversion is needed to reflect the real colour
+                    float lr = SrgbToLinear(sr);
+                    float lg = SrgbToLinear(sg);
+                    float lb = SrgbToLinear(sb);
 
-                pbr.baseColorFactor = new List<float>(4)
+                    pbr.baseColorFactor = new List<float>(4)
+            {
+                lr,
+                lg,
+                lb,
+                opacity
+            };
+                }
+                else
                 {
-                    lr,
-                    lg,
-                    lb,
-                    opacity
-                };
+                    // Apply tint by multiplying base color by tint color
+                    float tr = gl_mat.TintColour.Red / 255f;
+                    float tg = gl_mat.TintColour.Green / 255f;
+                    float tb = gl_mat.TintColour.Blue / 255f;
+
+                    // Convert to linear space after applying tint
+                    float lr = SrgbToLinear(sr * tr);
+                    float lg = SrgbToLinear(sg * tg);
+                    float lb = SrgbToLinear(sb * tb);
+
+                    pbr.baseColorFactor = new List<float>(4)
+            {
+                lr,
+                lg,
+                lb,
+                opacity
+            };
+                }
             }
             else
             {
                 gl_mat.pbrMetallicRoughness.baseColorFactor = new List<float>(4)
-                {
-                    1,
-                    1,
-                    1,
-                    opacity
-                };
+        {
+            1,
+            1,
+            1,
+            opacity
+        };
             }
 
             gl_mat.pbrMetallicRoughness = pbr;
         }
 
+
         public static float SrgbToLinear(float srgb)
         {
             return srgb <= 0.04045f

Common_glTF_Exporter/Materials/MaterialTextures.cs

@@ -12,11 +12,13 @@
 using System.Windows.Media.Media3D;
 using Material = Autodesk.Revit.DB.Material;
 using System;
+using Common_glTF_Exporter.Utils;
 
 namespace Common_glTF_Exporter.Materials
 {
     public static class MaterialTextures
     {
+
         public static GLTFMaterial SetMaterialTextures(Material material, GLTFMaterial gl_mat,
     Document doc, float opacity)
         {
@@ -37,7 +39,7 @@ public static GLTFMaterial SetMaterialTextures(Material material, GLTFMaterial g
 
             Asset connectedAsset = AssetPropertiesUtils.GetDiffuseBitmap(theAsset);
             string texturePath = AssetPropertiesUtils.GetTexturePath(connectedAsset);
-
+            gl_mat.TintColour = AssetPropertiesUtils.GetTint(theAsset);
 
             if (!string.IsNullOrEmpty(texturePath) && File.Exists(texturePath))
             {
@@ -54,19 +56,29 @@ private static void SetTextureProperties(GLTFMaterial gl_mat, string texturePath
 
             float scaleX = AssetPropertiesUtils.GetScale(connectedAsset, UnifiedBitmap.TextureRealWorldScaleX);
             float scaleY = AssetPropertiesUtils.GetScale(connectedAsset, UnifiedBitmap.TextureRealWorldScaleY);
+            float offsetX = AssetPropertiesUtils.GetOffset(connectedAsset, UnifiedBitmap.TextureRealWorldOffsetX);
+            float offsetY = AssetPropertiesUtils.GetOffset(connectedAsset, UnifiedBitmap.TextureRealWorldOffsetY);
             float rotation = AssetPropertiesUtils.GetRotationRadians(connectedAsset);
+
             gl_mat.Fadevalue = AssetPropertiesUtils.GetFade(theAsset);
-            gl_mat.TintColour = AssetPropertiesUtils.GetTint(theAsset);
             gl_mat.BaseColor = AssetPropertiesUtils.GetAppearenceColor(theAsset);
 
+            float[] gltfScale = new float[] { 1f / scaleX, 1f / scaleY };
+            float[] gltfOffset = new float[]
+            {
+                -(offsetX / scaleX),
+                offsetY / scaleY - gltfScale[1]
+            };
+
             gl_mat.pbrMetallicRoughness.baseColorTexture = new GLTFTextureInfo
             {
                 index = -1,
                 extensions = new GLTFTextureExtensions
                 {
                     TextureTransform = new GLTFTextureTransform
                     {
-                        scale = new float[] { 1f / scaleX, 1f / scaleY },
+                        offset = gltfOffset,
+                        scale = gltfScale,
                         rotation = rotation
                     }
                 }

Common_glTF_Exporter/Materials/TextureLocation.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Common_glTF_Exporter.Utils;
+
+namespace Common_glTF_Exporter.Materials
+{
+    public static class TextureLocation
+    {
+        private const string AUTODESK_TEXTURES = @"Autodesk Shared\Materials\Textures\";
+
+        public static List<string> GetPaths()
+        {
+            var paths = new List<string>
+            {
+                Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles),
+                    AUTODESK_TEXTURES)
+            };
+
+            var externalPaths = RevitIniReader.GetAdditionalRenderAppearancePaths();
+            if (externalPaths?.Count > 0)
+            {
+                paths.AddRange(externalPaths);
+            }
+
+            return paths;
+        }
+    }
+}

Common_glTF_Exporter/Service/RevitCollectorService.cs

@@ -1,4 +1,5 @@
-using Autodesk.Revit.DB;
+using Autodesk.Revit.ApplicationServices;
+using Autodesk.Revit.DB;
 using Autodesk.Revit.UI;
 using System;
 using System.Collections.Generic;
@@ -23,5 +24,10 @@
         {
             return uiApplication.ActiveUIDocument.Document;
         }
+
+        public Application GetApplication() 
+        {
+            return uiApplication.Application;
+        }
     }
 }

Common_glTF_Exporter/Utils/RevitIniReader.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Revit_glTF_Exporter;
+using System.IO;
+using System.Linq;
+using Autodesk.Revit.ApplicationServices;
+
+namespace Common_glTF_Exporter.Utils
+{
+    public static class RevitIniReader
+    {
+        public static List<string> GetAdditionalRenderAppearancePaths()
+        {
+            string revitVersion = ExternalApplication.RevitCollectorService.GetApplication().VersionNumber;
+            string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+
+            string iniDir = Path.Combine(
+                appData,
+                "Autodesk",
+                "Revit",
+                $"Autodesk Revit {revitVersion}"
+            );
+
+            string iniPath = Path.Combine(iniDir, "Revit.ini");
+
+            if (!File.Exists(iniPath))
+                return null;
+
+            foreach (var line in File.ReadAllLines(iniPath))
+            {
+                if (line.StartsWith("AdditionalRenderAppearancePaths="))
+                {
+                    string pathString = line.Substring("AdditionalRenderAppearancePaths=".Length);
+                    var paths = pathString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+
+                    var absolutePaths = new List<string>();
+                    string userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+
+                    foreach (var p in paths)
+                    {
+                        string trimmedPath = p.Trim();
+
+                        // If already rooted, normalize it
+                        if (Path.IsPathRooted(trimmedPath))
+                        {
+                            absolutePaths.Add(Path.GetFullPath(trimmedPath));
+                        }
+                        else
+                        {
+                            // Combine with user profile to resolve relative path
+                            string fullPath = Path.GetFullPath(Path.Combine(userProfile, trimmedPath));
+                            absolutePaths.Add(fullPath);
+                        }
+                    }
+
+                    return absolutePaths;
+                }
+            }
+
+            return null;
+        }
+    }
+}