almost there with this one, LZMA and LZ4 don't work

.vscode/settings.json

@@ -3,6 +3,7 @@
         "D:\\SteamLibrary\\steamapps\\common\\Blender\\4.3\\scripts\\addons",
         "C:\\Users\\Onan\\AppData\\Roaming\\Blender Foundation\\Blender\\4.3\\extensions\\user_default\\",//C:/Users/Onan/AppData/Roaming/Blender Foundation/Blender/4.0/scripts/addons
         "D:\\blender stuff\\blendercodestuff\\4.3",
+        "D:\\SteamLibrary\\steamapps\\common\\Blender\\4.3\\python\\lib\\site-packages",
         "/Users/frankche/Documents/blendercoding/4.1/",
         "/Users/frankche/Library/Application Support/Blender/4.3/extensions/user_default/"
     ],

core/common.py

@@ -1,11 +1,14 @@
 import bpy
+
 import numpy as np
-from .dictionaries import bone_names
 import threading
 import time
 import webbrowser
 import typing
+import struct
+from io import BytesIO
 
+from .dictionaries import bone_names
 from ..core.register import register_wrap
 from typing import List, Optional, Tuple
 from bpy.types import Object, ShapeKey, Mesh, Context, Material, PropertyGroup
@@ -497,3 +500,63 @@ def transfer_vertex_weights(context: Context, obj: bpy.types.Object, source_grou
 
     return True
 
+#Binary tools
+
+import ctypes
+def ReadCSharp_str(data: BytesIO) -> str:
+    return data.read(read7bitEncoded_int(data)).decode('utf-16-le')
+
+def WriteCSharp_str(data: BytesIO, string: str) -> str:
+    write7bitEncoded_int(len(string)*2)
+    return data.write(string.encode("utf-16-le"))
+
+def read7bitEncoded_ulong(data: BytesIO) -> np.int64:
+        num: ctypes.c_uint = ctypes.c_uint(0)
+        num2: int = 0
+        flag: bool = True
+        
+        while (flag):
+            b: ctypes.c_ubyte = ctypes.c_ubyte(struct.unpack('<B', data.read(1))[0])
+            flag = ((b & 128) > 0)
+            num |= ((b & 127) << num2)
+            num2 += 7
+            if not flag:
+                break
+
+        return num
+
+def read7bitEncoded_int(data: BytesIO) -> ctypes.c_int:
+        num: ctypes.c_int = ctypes.c_int(0)
+        num2:ctypes.c_int = ctypes.c_int(0)
+        while (num2 != 35):
+            b: ctypes.c_ubyte = ctypes.c_ubyte(struct.unpack('<B', data.read(1))[0])
+            num |= int(b & 127) << num2
+            num2 += 7
+            if ((b & 128) == 0):
+                return num
+        return -1
+
+def write7bitEncoded_ulong(data: BytesIO, integer: ctypes.c_ulong) -> None:
+    while integer > ctypes.c_ulong(0):
+        b: ctypes.c_ubyte = ctypes.c_ubyte(integer & ctypes.c_ulong(127))
+        integer >>= 7
+        if integer > ctypes.c_ulong(0):
+            b |= 128
+        data.write(b)
+        if integer <= ctypes.c_ulong(0):
+            return
+
+def write7bitEncoded_int(data: BytesIO, value: ctypes.c_int) -> None:
+    num: ctypes.c_uint = ctypes.c_uint(value)
+    while(num >= ctypes.c_ubyte(128)):
+        data.write(ctypes.c_ubyte(num | ctypes.c_ubyte(128)))
+        num >>= 7
+    data.Write(ctypes.c_ubyte(num))
+
+
+#encoding FrooxEngine/C# types in binary:
+
+
+
+
+

core/export_resonite.py

@@ -1,36 +0,0 @@
-import bpy
-
-from typing import List, Optional
-from .common import get_armature
-from bpy.types import Object, ShapeKey, Mesh, Context, Operator
-from functools import lru_cache
-from ..core.register import register_wrap
-from ..functions.translations import t
-
-
-@register_wrap
-class AvatarToolKit_OT_ExportResonite(Operator):
-    bl_idname = 'avatar_toolkit.export_resonite'
-    bl_label = t("Importer.export_resonite.label")
-    bl_description = t("Importer.export_resonite.desc")
-    bl_options = {'REGISTER', 'UNDO'}
-    filepath: bpy.props.StringProperty()
-
-
-    @classmethod
-    def poll(cls, context: Context):
-        if get_armature(context) is None:
-            return False
-        return True
-
-    def execute(self, context: Context):
-        #settings stolen from cats.
-        bpy.ops.export_scene.gltf('INVOKE_AREA',
-            export_image_format = 'WEBP',
-            export_image_quality = 75,
-            export_materials = 'EXPORT',
-            export_animations = True,
-            export_animation_mode = 'ACTIONS',
-            export_nla_strips_merged_animation_name = 'Animation',
-            export_nla_strips = True)
-        return {'FINISHED'}

core/importer.py

@@ -43,6 +43,7 @@ import_types: dict[str, typing.Callable[[str, list[dict[str,str]], str], None]]
     "vrm": (lambda directory, files, filepath: bpy.ops.import_scene.vrm(filepath=filepath)),
     "pmx": (lambda directory, files, filepath : import_pmx(filepath)),
     "pmd": (lambda directory, files, filepath : import_pmd(filepath)),
+    "animx": (lambda directory, files, filepath : bpy.ops.avatar_toolkit.animx_importer(directory=directory,files=files,filepath=filepath)),
 }
 
 def concat_imports_filter(imports):

core/preferences.json

@@ -1,3 +1,4 @@
 {
-    "language": 0
+    "language": 0,
+    "last_update_check": 1734208835.8049936
 }

core/resonite_loader/common.py

@@ -0,0 +1,56 @@
+import ctypes
+import typing
+import struct 
+from io import BytesIO
+
+def ReadCSharp_str(data: BytesIO) -> str:
+    charamount = read7bitEncoded_int(data)
+    print(charamount)
+    return data.read(charamount).decode('utf-8', errors="replace")
+
+def WriteCSharp_str(data: BytesIO, string: str) -> str:
+    write7bitEncoded_int(len(string))
+    return data.write(string.encode("utf-8", errors="replace"))
+
+def read7bitEncoded_ulong(data: BytesIO) -> int:
+        num: int = int(0)
+        num2: int = 0
+        flag: bool = True
+        
+        while (flag):
+            b: int = int(struct.unpack('<B', data.read(1))[0])
+            flag = ((b & 128) > 0)
+            num |= ((b & 127) << num2)
+            num2 += 7
+            if not flag:
+                break
+
+        return num
+
+def read7bitEncoded_int(data: BytesIO) -> int:
+        num: int= int(0)
+        num2:int = int(0)
+        while (num2 != 35):
+            b: int = int(struct.unpack('<B', data.read(1))[0])
+            num |= int(b & 127) << num2
+            num2 += 7
+            if ((b & 128) == 0):
+                return num
+        return -1
+
+def write7bitEncoded_ulong(data: BytesIO, integer: int) -> None:
+    while integer > int(0):
+        b: int = ctypes.c_ubyte(integer & int(127))
+        integer >>= 7
+        if integer > int(0):
+            b |= 128
+        data.write(b)
+        if integer <= int(0):
+            return
+
+def write7bitEncoded_int(data: BytesIO, value: int) -> None:
+    num: int = int(value)
+    while(num >= int(128)):
+        data.write(int(num | int(128)))
+        num >>= 7
+    data.Write(int(num))

core/resonite_loader/resonite_animx.py

@@ -0,0 +1,472 @@
+from __future__ import annotations
+
+import lz4.block
+from . import resonite_types
+from . import common
+
+import ctypes
+import typing
+import struct 
+from io import BytesIO
+
+KeyframeInterpolation: dict[str, int] = {
+    "Hold": 1,
+    "Linear": 2,
+    "Tangent": 3,
+    "CubicBezier": 4
+}
+
+class KeyFrame():
+    time: resonite_types.float = 0
+    interpolation: resonite_types.int = 0
+    value: resonite_types.ResoType
+    left_tan: resonite_types.ResoType
+    right_tan: resonite_types.ResoType
+
+
+    def __getattr__(self, name: str):
+        if name == "interpolation":
+            interp: int = 0
+            if (self.__dict__["left_tan"] != None and self.__dict__["right_tan"] != None):
+                interp = 3
+            
+
+            return resonite_types.int(interp)
+        return self.__dict__[name]
+    def __setattr__(self, name, value):
+        self.__dict__[name] = value
+
+    
+    
+
+    def __init__(self):
+        pass
+    
+
+    def RequiresTangents(self) -> bool:
+        if KeyframeInterpolation[self.interpolation.x] == "Tangent" or KeyframeInterpolation[self.interpolation.x] == "CubicBezier":
+            return True
+        return False
+
+class ResoTrack(resonite_types.ResoType):
+    _node: resonite_types.string
+    _property: resonite_types.string
+    Owner: AnimX
+    FrameType: type[resonite_types.ResoType]
+    keyframes: list[KeyFrame] = []
+
+    def __init__(self,FrameType):
+        self.FrameType = FrameType
+
+    def write(self, data: BytesIO):
+        self._node.write(data)
+        self._property.write(data)
+        common.write7bitEncoded_ulong(data, len(self.keyframes))
+
+    def read(self, data:BytesIO):
+        self._node.read(data)
+        self._property.read(data)
+        track_amount: int = int(common.read7bitEncoded_ulong(data))
+        for i in range(0, track_amount):
+            self.keyframes.append(KeyFrame())
+
+    def removeKeyframe(self, time: float | int) -> bool:
+        """Takes a time and removes one with the same time"""
+        if (time < 0):
+            raise IndexError("Keyframe time cannot be lower than 0. Value: " + str(time))
+        if(type(time) == float):
+            num: int = -1
+            for num2 in range(0,len(self.keyframes)):
+                if (self.keyframes[num2].time.x == float(time)):
+                    num = num2
+            
+            if num == -1:
+                return False
+
+            self.keyframes.remove(self.keyframes[num])
+            return True
+        else:
+            if (int(time) >= len(self.keyframes)):
+                raise IndexError("Keyframe time cannot be bigger than the amount of keyframes. Value: " + str(time))
+            self.keyframes.remove(self.keyframes[int(time)])
+            
+
+
+    
+    def replaceKeyframe(self, keyframe: KeyFrame) -> bool:
+        """Takes a keyframe and replaces one with the same time"""
+        if (keyframe.time.x < 0):
+            raise IndexError("Keyframe time cannot be lower than 0. Value: " + str(keyframe.time.x))
+        
+
+        num: int = 0
+
+        if (keyframe.time.x == self.keyframes[self.GetKeyframeIndex(keyframe.time.x)].time.x):
+            num = len(self.keyframes)
+        else:
+            return False
+
+        self.keyframes[num] = keyframe
+        return True
+    
+    def addKeyframe(self, keyframe: KeyFrame) -> int:
+        if (keyframe.time.x < 0):
+            raise IndexError("Keyframe time cannot be lower than 0. Value: " + str(keyframe.time.x))
+        num: int 
+        if (len(self.keyframes) == 0):
+            num = 0
+        elif (keyframe.time.x >= self.keyframes[-1].time.x):
+            num = len(self.keyframes)
+        else:
+            num = self.GetKeyframeIndex(keyframe.time.x) + 1
+
+        self.keyframes.insert(num, keyframe)
+        
+        return num
+    
+    def GetKeyframeIndex(self, time:float | int)-> int:
+        if(type(time) == float):
+            if (len(self.keyframes) > 0):
+                num: int = 0
+                if (self.keyframes[-1].time < float(time)):
+                    num = len(self.keyframes)
+                
+                while (num < len(self.keyframes) and self.keyframes[num].time < time):
+                    num += 1
+                
+                return num - 1
+            
+            return -1
+        else:
+            return int(time)
+
+
+class RawTrack(ResoTrack):
+    interval: resonite_types.float = 0
+
+    def __getattr__(self, name: str):
+        if name == "interval":
+            return self.Owner.interval.x
+        return self.__dict__[name]
+
+    def __init__(self, FrameType):
+        super().__init__(FrameType)
+
+    def write(self, data: BytesIO):
+        super().write(data)
+        self.interval.write(data)
+        for key in self.keyframes:
+            key.value.write(data)
+
+
+    def read(self, data:BytesIO):
+        super().read(data)
+        self.interval.read(data)
+        for key in self.keyframes:
+            key.value.read(data)
+
+    def addKeyframe(self, keyframe: KeyFrame) -> int:
+        num: int = super().addKeyframe(keyframe)
+        for i in range(0,len(self.keyframes)):
+            self.keyframes[i].time = i
+        return num
+    def removeKeyframe(self, time: float | int) -> bool:
+        success: bool = super().removeKeyframe(int(time))
+        for i in range(0,len(self.keyframes)):
+            self.keyframes[i].time = i
+        return success
+
+
+    
+
+class DiscreteTrack(ResoTrack):
+    
+    def __init__(self, FrameType):
+        super().__init__(FrameType)
+
+    def write(self, data: BytesIO):
+        super().write(data)
+
+
+    def read(self, data:BytesIO):
+        super().read(data)
+
+    def addKeyframe(self, keyframe: KeyFrame) -> int:
+        num: int = super().addKeyframe(keyframe)
+        return num
+    def removeKeyframe(self, time: float | int) -> bool:
+        success: bool = super().removeKeyframe(time)
+        return success
+        
+
+
+
+class CurveTrack(ResoTrack):
+    interpolations: bool = False
+    tangents: bool = False
+    sharedinterpolation: resonite_types.int = -1
+
+    def __getattr__(self, name: str):
+        if name == "interpolations":
+            for key in self.keyframes:
+                if key.interpolation.x  != self.sharedinterpolation.x:
+                    return True 
+        elif name == "tangents":
+            for key in self.keyframes:
+                if key.interpolation.x == 3 or key.interpolation.x == 4:
+                    return True 
+        return self.__dict__[name]
+
+    def __init__(self, FrameType):
+        super().__init__(FrameType)
+
+    def write(self, data: BytesIO):
+        super().write(data)
+        resonite_types.byte((1 if self.interpolations else 0) | (2 if self.tangents else 0)).write(data)
+
+
+        if(self.interpolations):
+            for key in self.keyframes:
+                key.interpolation.write(data)
+        else:
+            self.sharedinterpolation.write(data)
+
+        for key in self.keyframes:
+            key.value.write(data)
+            key.time.write(data)
+        
+        if(self.tangents):
+            for key in self.keyframes:
+                key.left_tan.write(data)
+                key.right_tan.write(data)
+
+    def read(self, data:BytesIO):
+        super().read(data)
+        flags: int = struct.unpack("<B",data.read(1))
+        self.interpolations = flags & 1
+        self.tangents = flags & 2
+
+        if(self.interpolations):
+            for key in self.keyframes:
+                key.interpolation.read(data)
+        else:
+            self.sharedinterpolation.read(data)
+
+        for key in self.keyframes:
+            key.value.read(data)
+            key.time.read(data)
+        
+        if(self.tangents):
+            for key in self.keyframes:
+                key.left_tan.read(data)
+                key.right_tan.read(data)
+        
+
+
+
+    
+
+    
+
+
+class BezierTrack(ResoTrack):
+    """PLACE HOLDER CLASS, DO NOT USE"""
+
+
+    def __init__(self, FrameType):
+        super().__init__(FrameType)
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        #raise Exception("BezierTrack track type is unsupported in resonite's code")
+
+    def write(self, data: BytesIO):
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        raise Exception("BezierTrack track type is unsupported in resonite's code")
+    def read(self, data:BytesIO):
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        raise Exception("BezierTrack track type is unsupported in resonite's code")
+    
+    def removeKeyframe(self, keyframe: KeyFrame) -> bool:
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        raise Exception("BezierTrack track type is unsupported in resonite's code")
+
+    def replaceKeyframe(self, keyframe: KeyFrame) -> bool:
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        raise Exception("BezierTrack track type is unsupported in resonite's code")
+    def addKeyframe(self, keyframe: KeyFrame) -> int:
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        raise Exception("BezierTrack track type is unsupported in resonite's code")
+    
+    def GetKeyframeIndex(self, time:float)-> int:
+        """PLACE HOLDER METHOD, DO NOT USE"""
+        raise Exception("BezierTrack track type is unsupported in resonite's code")
+#This is weird, but thank you python - @989onan
+TrackTypes: list[type[ResoTrack]] = [
+    RawTrack,
+    DiscreteTrack,
+    CurveTrack,
+    BezierTrack
+]
+    
+#TODO: add all types here
+#wooooo - @989onan
+elementTypes: list[type[resonite_types.ResoType]] = [
+    resonite_types.bool,
+    resonite_types.bool2,
+    resonite_types.bool3,
+    resonite_types.bool4,
+    resonite_types.byte,
+    resonite_types.ushort,
+    resonite_types.uint,
+    resonite_types.ulong,
+    resonite_types.sbyte,
+    resonite_types.short,
+    resonite_types.int,
+    resonite_types.long,
+    resonite_types.int2,
+    resonite_types.int3,
+    resonite_types.int4,
+    resonite_types.uint2,
+    resonite_types.uint3,
+    resonite_types.uint4,
+    resonite_types.long2,
+    resonite_types.long3,
+    resonite_types.long4,
+    resonite_types.float,
+    resonite_types.float2,
+    resonite_types.float3,
+    resonite_types.float4,
+    resonite_types.floatQ,
+    resonite_types.float2x2,
+    resonite_types.float3x3,
+    resonite_types.float4x4,
+    resonite_types.double,
+    resonite_types.double2,
+    resonite_types.double3,
+    resonite_types.double4,
+    resonite_types.doubleQ,
+    resonite_types.double2x2,
+    resonite_types.double3x3,
+    resonite_types.double4x4,
+    resonite_types.color,
+    resonite_types.color32,
+    resonite_types.string
+    ]
+
+
+most_recent_AnimX_vers: int = 1
+
+class AnimX():
+
+
+    """
+    To use Raw Track properly, please set interval (seconds between frames) after reading/creating.\n
+    Represents data to be written to or read from an AnimX file. 
+    """
+
+    file_version: resonite_types.int = resonite_types.int()
+    track_amount: resonite_types.int = resonite_types.int()
+    global_duration: resonite_types.float = resonite_types.float()
+    name: resonite_types.string = resonite_types.string()
+
+    tracks: list[ResoTrack] = []
+
+    interval: resonite_types.float = resonite_types.float(1/25) #default value
+
+    def __init__(self):
+        pass
+
+
+    
+    def read(self, file: str) -> bool:
+        """
+        Takes an absolute file path and reads a binary animx file with it, and populates this class object with the data.
+        """
+        with open(file, 'rb') as filecontents:
+            data: BytesIO = BytesIO(filecontents.read())
+            magic_word = common.ReadCSharp_str(data)
+            if magic_word != 'AnimX':
+                print("AnimX != "+magic_word)
+                return False
+            self.file_version.read(data)
+            if self.file_version.x > 1:
+                raise Exception("AnimX version is higher than the supported one")
+            
+            self.track_amount.x = common.read7bitEncoded_ulong(data)
+            self.global_duration.read(data)
+            print(self.track_amount.x)
+
+            self.name.read(data)
+            
+            
+            match (struct.unpack('<B', data.read(1))[0]):
+                case 0:
+                    pass
+                case 1:
+                    from lz4.frame import decompress #why do you have to be a wheel? - @989onan
+                    data =  BytesIO(decompress(data.read()))
+                case 2:
+                    import lzma#HALLLOOOYAH HALLOYAH!! - @989onan
+                    filters = [{"id": "", "preset": lzma.PRESET_DEFAULT}]
+                    data =  BytesIO(lzma.decompress(data.read(), filters=filters))
+                case _:
+                    raise Exception("Invalid encoding")
+            
+            for i in range(0,self.track_amount.x):
+                trackType2: int = 0
+                num4: int = 0
+                if (self.file_version == 0):
+                    b: ctypes.c_ubyte = ctypes.c_ubyte(struct.unpack('<B', data.read(1))[0])
+                    num3: int = int(b & 1)
+                    trackType: int = 0
+                    if (num3 != 0):
+                        if (num3 != 1):
+                            raise Exception("[InvalidDataException]: Invalid track type data: " + str(b))
+                        trackType = 2
+                    else:
+                        trackType = 0
+                    trackType2 = trackType
+                    num4 = b >> 1
+                else:
+                    trackType2 = int(struct.unpack('<B', data.read(1))[0])
+                    num4 = int(struct.unpack('<B', data.read(1))[0])
+                animationTrack: ResoTrack = AnimX.GetTrackType(trackType2, elementTypes[num4], data)
+                animationTrack.Owner = self
+                self.tracks.append(animationTrack)
+
+        return True
+
+    def write(self, file: str) -> bool:
+        """
+        Takes an absolute file path and writes a binary animx file into it's contents, replacing them using this class's data.
+        """
+        with open(file, 'rb') as filecontents:
+            data: BytesIO = BytesIO(filecontents)
+            common.WriteCSharp_str(data, 'AnimX')
+            self.file_version.x = most_recent_AnimX_vers #we wanna write an up to date file version type.
+            self.file_version.write(data)
+            
+            self.track_amount.x = len(self.tracks)
+            common.write7bitEncoded_ulong(self.track_amount.x)
+            self.global_duration.write(data)
+
+
+            self.name.write(data)
+
+            data.write(struct.pack('<B', 0)) #default encoding, so we don't have to use lzma.
+            
+            
+            for i in range(0,self.track_amount.x):
+
+                data.write(struct.pack('<B', TrackTypes.index(type(self.tracks[i])))[0])
+                data.write(struct.pack('<B', elementTypes.index(self.tracks[i].FrameType)))
+                self.tracks[i].write(data)
+
+        return True
+
+    @classmethod
+    def GetTrackType(cls, trackType2: int, value_type: int, data: BytesIO) -> ResoTrack:
+        TrackType: type[ResoTrack] = TrackTypes[trackType2] 
+        Track: ResoTrack = TrackType[elementTypes[value_type]](elementTypes[value_type])
+        Track.read(data)
+        return Track
+    

core/resonite_loader/resonite_types.py

@@ -0,0 +1,655 @@
+import ctypes
+import typing
+from io import BytesIO
+import struct
+from . import common
+
+class ResoType():
+    
+
+    
+
+    def __init__(self):
+        pass
+
+    def write(self, data: BytesIO):
+        pass
+
+    def read(cls, data: BytesIO):
+        pass
+
+#These below are collection of the basic resonite typing made from C#. This is in order to store data in a sane way and decode/encode it.
+
+class color(ResoType):
+    r: float = 0
+    g: float = 0
+    b: float = 0
+    a: float = 0
+
+
+    def __init__(self):
+        pass
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<ffff", self.r, self.g, self.b, self.a))
+        
+    def read(self,data):
+        self.r, self.g, self.b, self.a = struct.unpack("<ffff", data.read(4*4))[0]
+
+
+class color32(ResoType):
+    r: int = 0
+    g: int = 0
+    b: int = 0
+    a: int = 0
+
+
+    def __init__(self):
+        pass
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<BBBB", self.r, self.g, self.b, self.a))
+        
+    def read(self,data):
+        self.r, self.g, self.b, self.a = struct.unpack("<BBBB", data.read(4))[0]
+
+class string(ResoType):
+    x: str
+
+    def __str__(self) -> str:
+        return self.x
+
+    def __init__(self,value=""):
+        self.x = value
+    
+    def write(self, data: BytesIO):
+        common.WriteCSharp_str(data,self.x)
+        
+    def read(self,data):
+        
+        self.x = common.ReadCSharp_str(data)
+
+
+class byte(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self):
+        pass
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<B", self.x))
+        
+    def read(self,data):
+        self.x = struct.unpack("<B", data.read(1))[0]
+
+class sbyte(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self,value=0):
+        self.x = value
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<b", self.x))
+        
+    def read(self,data):
+        self.x = struct.unpack("<b", data.read(1))[0]
+
+class ushort(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self,value=0):
+        self.x = value
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<H", self.x))
+        
+    def read(self,data):
+        self.x = struct.unpack("<H", data.read(2))[0]
+
+class short(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self):
+        pass
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<h", self.x))
+        
+    def read(self,data):
+        self.x = struct.unpack("<h", data.read(2))[0]
+
+class bool(ResoType):
+    x: bool = False
+
+
+    def __bool__(self) -> bool:
+        return self.x
+    def __init__(self,value=False):
+        self.x = value
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("?", self.x))
+        
+    def read(self,data):
+        self.x = struct.unpack("?", data.read(1))[0]
+
+class bool2(bool):
+    y: bool = False
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        byte: ctypes.c_ubyte = ctypes.c_ubyte(struct.unpack("<B",data.read(1))[0])
+        self.x = (byte & 1) > 0
+        self.y = (byte & 2) > 0
+
+    def createflags(self) -> ctypes.c_byte:
+        flags: ctypes.c_ubyte = ctypes.c_ubyte(0)
+        flags |= (1 if self.x else 0)
+        flags |= (2 if self.y else 0)
+        return flags
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<B", self.createflags()))
+        
+
+class bool3(bool2):
+    z: bool = False
+    
+    def __init__(self):
+        pass
+
+    def read(self,data):
+        byte: ctypes.c_ubyte = ctypes.c_ubyte(struct.unpack("<B",data.read(1))[0])
+        self.x = (byte & 1) > 0
+        self.y = (byte & 2) > 0
+        self.z = (byte & 4) > 0
+
+    def createflags(self) -> ctypes.c_byte:
+        flags: ctypes.c_ubyte = ctypes.c_ubyte(0)
+        flags |= (1 if self.x else 0)
+        flags |= (2 if self.y else 0)
+        flags |= (3 if self.z else 0)
+        return flags
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<B", self.createflags()))
+    
+
+class bool4(bool3):
+    w: bool = False
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        byte: ctypes.c_ubyte = ctypes.c_ubyte(struct.unpack("<B",data.read(1))[0])
+        self.x = (byte & 1) > 0
+        self.y = (byte & 2) > 0
+        self.z = (byte & 4) > 0
+        self.w = (byte & 8) > 0
+
+    def createflags(self) -> ctypes.c_ubyte:
+        flags: ctypes.c_ubyte = ctypes.c_ubyte(0)
+        flags |= (1 if self.x else 0)
+        flags |= (2 if self.y else 0)
+        flags |= (4 if self.z else 0)
+        flags |= (8 if self.w else 0)
+        return flags
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<B", self.createflags()))
+    
+
+
+class int(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self,value=0):
+        self.x = value
+
+    def read(self,data: BytesIO):
+        self.x = struct.unpack("<i", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<i", self.x))
+
+class int2(int):
+    y: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().write(data)
+        self.y = struct.unpack("<i", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<i", self.y))
+
+class int3(int2):
+    z: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().write(data)
+        self.z = struct.unpack("<i", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<i", self.z))
+    
+class int4(int3):
+    w: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().write(data)
+        self.w = struct.unpack("<i", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<i", self.w))
+
+
+
+
+
+
+class uint(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self,value=0):
+        self.x = value
+
+    def read(self,data: BytesIO):
+        self.x = struct.unpack("<I", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<I", self.x))
+
+class uint2(uint):
+    y: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().write(data)
+        self.y = struct.unpack("<I", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<I", self.y))
+
+class uint3(uint2):
+    z: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().write(data)
+        self.z = struct.unpack("<I", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<I", self.z))
+    
+class uint4(uint3):
+    w: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().write(data)
+        self.w = struct.unpack("<I", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<I", self.w))
+
+
+
+
+
+class ulong(ResoType):
+    x: int = 0
+
+    def __int__(self):
+        return self.x
+
+    def __init__(self,value=0):
+        self.x = value
+
+    def read(self,data: BytesIO):
+        self.x = struct.unpack("<Q", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<Q", self.x))
+
+
+class long(ResoType):
+    x: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.x = struct.unpack("<q", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<q", self.x))
+
+class long2(long):
+    y: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.y = struct.unpack("<q", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<q", self.y))
+
+class long3(long2):
+    z: int = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.z = struct.unpack("<q", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<q", self.z))
+    
+class long4(long3):
+    w: int = 0
+
+    def __init__(self):
+        pass
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.w = struct.unpack("<q", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<q", self.w))
+
+
+
+
+
+
+
+
+class double(ResoType):
+    x: float = 0
+
+    def __float__(self):
+        return self.x
+
+    def __init__(self,value=0):
+        self.x = value
+
+    def read(self,data: BytesIO):
+        self.x = struct.unpack("<d", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<d", self.x))
+
+class double2(double):
+
+    y: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.y = struct.unpack("<d", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<d", self.y))
+
+class double3(double2):
+    z: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.z = struct.unpack("<d", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<d", self.z))
+    
+class double4(double3):
+    w: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.w = struct.unpack("<d", data.read(8))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<d", self.w))
+
+class double2x2(ResoType):
+    m00: float = 0
+    m01: float = 0
+    m10: float = 0
+    m11: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.m00,self.m01,self.m10,self.m11 = struct.unpack("<dddd", data.read(8*(2*2)))
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<dddd", self.m00,self.m01, self.m10,self.m11))
+
+
+class double3x3(double2x2):
+    m02: float = 0
+    m12: float = 0
+    m22: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.m00,self.m01,self.m02,self.m10,self.m11,self.m12,self.m20,self.m21,self.m22 = struct.unpack("<ddddddddd", data.read(8*(3*3)))
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<ddddddddd", self.m00,self.m01,self.m02,self.m10,self.m11,self.m12,self.m20,self.m21,self.m22))
+
+
+class double4x4(double3x3):
+    m03: float = 0
+    m13: float = 0
+    m23: float = 0
+    m33: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.m00,self.m01,self.m02,self.m03,self.m10,self.m11,self.m12,self.m13,self.m20,self.m21,self.m22,self.m23,self.m30,self.m31,self.m32,self.m33 = struct.unpack("<dddddddddddddddd", data.read(8*(4*4)))
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<dddddddddddddddd", self.m00,self.m01,self.m02,self.m03,self.m10,self.m11,self.m12,self.m13,self.m20,self.m21,self.m22,self.m23,self.m30,self.m31,self.m32,self.m33))
+
+class doubleQ(double4):
+
+    def __init__(self):
+        pass
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+    
+    @classmethod
+    def read(cls, data: BytesIO):
+        super().read(data)
+
+
+
+
+
+class float(ResoType):
+    x: float = 0
+
+    def __float__(self):
+        return self.x
+
+    def __init__(self, value=0):
+        self.x = value
+
+    def read(self,data: BytesIO):
+        self.x = struct.unpack("<f", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<f", self.x))
+
+class float2(float):
+
+    y: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.y = struct.unpack("<f", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<f", self.y))
+
+class float3(float2):
+    z: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.z = struct.unpack("<f", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<f", self.z))
+    
+class float4(float3):
+    w: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        super().read(data)
+        self.w = struct.unpack("<f", data.read(4))[0]
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+        data.write(struct.pack("<f", self.w))
+
+class float2x2(ResoType):
+    m00: float = 0
+    m01: float = 0
+    m10: float = 0
+    m11: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.m00,self.m01,self.m10,self.m11 = struct.unpack("<ffff", data.read(4*(2*2)))
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<ffff", self.m00,self.m01, self.m10,self.m11))
+
+
+class float3x3(float2x2):
+    m02: float = 0
+    m12: float = 0
+    m22: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.m00,self.m01,self.m02,self.m10,self.m11,self.m12,self.m20,self.m21,self.m22 = struct.unpack("<fffffffff", data.read(4*(3*3)))
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<fffffffff", self.m00,self.m01,self.m02,self.m10,self.m11,self.m12,self.m20,self.m21,self.m22))
+
+
+class float4x4(float3x3):
+    m03: float = 0
+    m13: float = 0
+    m23: float = 0
+    m33: float = 0
+
+    def __init__(self):
+        pass
+
+    def read(self,data: BytesIO):
+        self.m00,self.m01,self.m02,self.m03,self.m10,self.m11,self.m12,self.m13,self.m20,self.m21,self.m22,self.m23,self.m30,self.m31,self.m32,self.m33 = struct.unpack("<ffffffffffffffff", data.read(4*(4*4)))
+    
+    def write(self, data: BytesIO):
+        data.write(struct.pack("<ffffffffffffffff", self.m00,self.m01,self.m02,self.m03,self.m10,self.m11,self.m12,self.m13,self.m20,self.m21,self.m22,self.m23,self.m30,self.m31,self.m32,self.m33))
+
+class floatQ(float4):
+
+    def __init__(self):
+        pass
+    
+    def write(self, data: BytesIO):
+        super().write(data)
+    
+    @classmethod
+    def read(cls, data: BytesIO):
+        super().read(data)

core/resonite_utils.py

@@ -1,11 +1,17 @@
 import bpy
+import bpy_extras
 
-from typing import List, Optional
+from .common import get_armature, get_selected_armature, simplify_bonename, is_valid_armature
-from .common import get_armature
 from bpy.types import Object, ShapeKey, Mesh, Context, Operator
 from functools import lru_cache
 from ..core.register import register_wrap
 from ..functions.translations import t
+from ..core.dictionaries import bone_names
+
+import re
+from .resonite_loader import resonite_animx, resonite_types
+import os
+
 
 
 @register_wrap
@@ -34,16 +40,6 @@ class AvatarToolKit_OT_ExportResonite(Operator):
             export_nla_strips_merged_animation_name = 'Animation',
             export_nla_strips = True)
         return {'FINISHED'}
-    
-
-import bpy
-from ..core.register import register_wrap
-from typing import List, Optional
-import re
-from bpy.types import Operator, Context, Object
-from ..core.dictionaries import bone_names
-from ..core.common import get_selected_armature, simplify_bonename, is_valid_armature
-from ..functions.translations import t
 
 @register_wrap
 class AvatarToolKit_OT_ConvertToResonite(Operator):
@@ -151,3 +147,97 @@ class AvatarToolKit_OT_ConvertToResonite(Operator):
             self.report({'INFO'}, t("Tools.bones_translated_success"))
 
         return {'FINISHED'}
+
+
+@register_wrap
+class AvatarToolKit_OT_AnimX_Importer(Operator,bpy_extras.io_utils.ImportHelper):
+    bl_idname = 'avatar_toolkit.animx_importer'
+    bl_label = t('Tools.animx_importer.label')
+    bl_description = t('Tools.animx_importer.desc')
+    bl_options = {'REGISTER', 'UNDO'}
+
+    #fps = bpy.props.FloatProperty(default=25) #25 fps
+    
+    filter_glob: bpy.props.StringProperty(
+        default="*.animx",
+        options={'HIDDEN'}
+    )
+    files: bpy.props.CollectionProperty(type=bpy.types.OperatorFileListElement, options={'HIDDEN', 'SKIP_SAVE'})
+    filepath: bpy.props.StringProperty()
+
+    directory:bpy.props.StringProperty(subtype='DIR_PATH')
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return True
+        
+    def execute(self, context: Context) -> set:
+        
+        Froox_animations: list[resonite_animx.AnimX] = []
+
+        #decoding using self contained library:
+        files = [file.name for file in self.files]
+        files.append(self.filepath)
+        for file in files:
+            froox_animation: resonite_animx.AnimX = resonite_animx.AnimX()
+            froox_animation.interval.x = 1/25
+            froox_animation.read(file = os.path.join(self.directory,file))
+            Froox_animations.append(froox_animation)
+
+        #Load data into Blender Animations.
+        for froox_animation in Froox_animations:
+            action: bpy.types.Action = bpy.data.actions.new(froox_animation.name.x)
+            action.use_fake_user = True
+            for track in froox_animation.tracks:
+                print("hit here1")
+                print(track.FrameType)
+                if(track.FrameType != type(resonite_types.float) and track.FrameType != type(resonite_types.double)):
+                    continue
+
+                data_path: str = track._node.x+"."+track._property.x
+                fcurve_reso = action.fcurves.new(data_path,None,track._node.x)
+                
+                print("hit here2")
+                match(type(track)):
+                    case (type(resonite_animx.RawTrack)):
+                        rawtrack: resonite_animx.RawTrack = track
+
+                        
+                        
+                        for frame in rawtrack.keyframes:
+                            key: bpy.types.Keyframe = fcurve_reso.keyframe_points.insert(frame.time, float(frame.value))
+                            
+
+                    case (type(resonite_animx.DiscreteTrack)):
+                        discretetrack: resonite_animx.RawTrack = track
+                        for frame in rawtrack.keyframes:
+                            key: bpy.types.Keyframe = fcurve_reso.keyframe_points.insert(frame.time, float(frame.value))
+
+
+                    case(type(resonite_animx.CurveTrack)):
+                        curvetrack: resonite_animx.RawTrack = track
+                        for frame in curvetrack.keyframes:
+                            key: bpy.types.Keyframe = fcurve_reso.keyframe_points.insert(frame.time, float(frame.value))
+                            key.handle_left = float(frame.left_tan)
+                            key.handle_left = float(frame.right_tan)
+
+
+                    case(type(resonite_animx.BezierTrack)):
+                        beziertrack: resonite_animx.RawTrack = track
+                        # Bezier is not supported rn, ignore.
+
+
+
+        
+
+
+
+        return {'FINISHED'}
+    
+
+    
+
+
+
+    
+

functions/resonite_functions.py

@@ -1,115 +0,0 @@
-import bpy
-from ..core.register import register_wrap
-from typing import List, Optional
-import re
-from bpy.types import Operator, Context, Object
-from ..core.dictionaries import bone_names
-from ..core.common import get_selected_armature, simplify_bonename, is_valid_armature
-from ..functions.translations import t
-
-@register_wrap
-class AvatarToolKit_OT_ConvertToResonite(Operator):
-    bl_idname = 'avatar_toolkit.convert_to_resonite'
-    bl_label = t('Tools.convert_to_resonite.label')
-    bl_description = t('Tools.convert_to_resonite.desc')
-    bl_options = {'REGISTER', 'UNDO'}
-
-    @classmethod
-    def poll(cls, context: Context) -> bool:
-        armature = get_selected_armature(context)
-        return armature is not None and is_valid_armature(armature)
-        
-    def execute(self, context: Context) -> set:
-        armature = get_selected_armature(context)
-        if not armature:
-            self.report({'WARNING'}, t("Tools.no_armature_selected"))
-            return {'CANCELLED'}
-
-        translate_bone_fails = 0
-        untranslated_bones = set()
-
-        reverse_bone_lookup = dict()
-        for (preferred_name, name_list) in bone_names.items():
-            for name in name_list:
-                reverse_bone_lookup[name] = preferred_name
-
-        resonite_translations = {
-            'hips': "Hips",
-            'spine': "Spine",
-            'chest': "Chest",
-            'neck': "Neck",
-            'head': "Head",
-            'left_eye': "Eye.L",
-            'right_eye': "Eye.R",
-            'right_leg': "UpperLeg.R",
-            'right_knee': "Calf.R",
-            'right_ankle': "Foot.R",
-            'right_toe': 'Toes.R',
-            'right_shoulder': "Shoulder.R",
-            'right_arm': "UpperArm.R",
-            'right_elbow': "ForeArm.R",
-            'right_wrist': "Hand.R",
-            'left_leg': "UpperLeg.L",
-            'left_knee': "Calf.L",
-            'left_ankle': "Foot.L",
-            'left_toe': "Toes.L",
-            'left_shoulder': "Shoulder.L",
-            'left_arm': "UpperArm.L",
-            'left_elbow': "ForeArm.L",
-            'left_wrist': "Hand.R",
-
-            'pinkie_1_l': "pinkie1.L",
-            'pinkie_2_l': "pinkie2.L",
-            'pinkie_3_l': "pinkie3.L",
-            'ring_1_l': "ring1.L",
-            'ring_2_l': "ring2.L",
-            'ring_3_l': "ring3.L",
-            'middle_1_l': "middle1.L",
-            'middle_2_l': "middle2.L",
-            'middle_3_l': "middle3.L",
-            'index_1_l': "index1.L",
-            'index_2_l': "index2.L",
-            'index_3_l': "index3.L",
-            'thumb_1_l': "thumb1.L",
-            'thumb_2_l': "thumb2.L",
-            'thumb_3_l': "thumb3.L",
-
-            'pinkie_1_r': "pinkie1.R",
-            'pinkie_2_r': "pinkie2.R",
-            'pinkie_3_r': "pinkie3.R",
-            'ring_1_r': "ring1.R",
-            'ring_2_r': "ring2.R",
-            'ring_3_r': "ring3.R",
-            'middle_1_r': "middle1.R",
-            'middle_2_r': "middle2.R",
-            'middle_3_r': "middle3.R",
-            'index_1_r': "index1.R",
-            'index_2_r': "index2.R",
-            'index_3_r': "index3.R",
-            'thumb_1_r': "thumb1.R",
-            'thumb_2_r': "thumb2.R",
-            'thumb_3_r': "thumb3.R"
-        }
-
-        context.view_layer.objects.active = armature
-        bpy.ops.object.mode_set(mode='EDIT')
-
-        bpy.ops.object.mode_set(mode='OBJECT')
-        bone.name = re.compile(re.escape("<noik>"), re.IGNORECASE).sub("",bone.name) #remove "NOIK" from bones before translating again, in case an update was done that fixes a translation.
-        for bone in armature.data.bones:
-            if simplify_bonename(bone.name) in reverse_bone_lookup and reverse_bone_lookup[simplify_bonename(bone.name)] in resonite_translations:
-                bone.name = resonite_translations[reverse_bone_lookup[simplify_bonename(bone.name)]]
-            else:
-                untranslated_bones.add(bone.name)
-                
-                bone.name = bone.name+"<noik>"
-                translate_bone_fails += 1
-            
-        bpy.ops.object.mode_set(mode='OBJECT')
-
-        if translate_bone_fails > 0:
-            self.report({'INFO'}, t("Tools.bones_translated_with_fails").format(translate_bone_fails=translate_bone_fails))
-        else:
-            self.report({'INFO'}, t("Tools.bones_translated_success"))
-
-        return {'FINISHED'}

functions/uv_tools.py

@@ -287,6 +287,9 @@ class AvatarToolkit_OT_AlignUVEdgesToTarget(Operator):
                         uv_lay.uv[corner].vector = lerped_point #put the vertcies at the point we calculated. 
                 except:
                     print("This is probably fine? - @989onan") #TODO: What happened here? The magic of making code so complex you forget if this is even an issue. - @989onan
+                    #Note: The above print statement may require reading what this entire operator does before understanding if the above print statment means anything
+                    #so if you value your time, just do a bunch of tests until the above print stament is ran or something
+                    #if in doubt and you cannot get it to run, just spend some time trying to understand the operator - @989onan
             
             print("Finished mesh \""+source+"\" for UV's")