protected override TransformationResult TransformRecord(TransformationContext context, TranslatedRecord declaration)
    {
        TranslatedRecord?baseType = TryGetSimpleBaseType(context.Library, declaration);

        if (baseType is null)
        {
            return(declaration);
        }

        TranslatedRecord immediateBaseType = baseType;

        HashSet <string> takenNames = new(declaration.Members.Select(m => m.Name));

        bool FilterAndLog(TranslatedDeclaration parentMember)
        {
            //TODO: Virtual destructors don't lift correctly because their VTable entries are attributed to a non-existent destructor on the derived type
            if (parentMember is TranslatedFunction {
                SpecialFunctionKind : SpecialFunctionKind.Destructor, IsVirtual : true
            })
            {
                return(false);
            }

            // Otherwise just do a name check
            return(takenNames.Add(parentMember.Name));
        }
    private TranslatedRecord?TryGetSimpleBaseType(TranslatedLibrary library, TranslatedRecord declaration)
    {
        if (declaration.NonVirtualBaseField is null || declaration.NonVirtualBaseField.Offset != 0)
        {
            return(null);
        }

        if (declaration.NonVirtualBaseField.Type is not TranslatedTypeReference baseType)
        {
            return(null);
        }

        if (baseType.TryResolve(library) is not TranslatedRecord baseRecord)
        {
            return(null);
        }

        return(baseRecord);
    }
Beispiel #3
0
 protected override TransformationResult TransformRecord(TransformationContext context, TranslatedRecord declaration)
 {
     if (declaration.Name is "ImVec4" or "ImColor")
     {
         Debug.Assert(declaration.Size == sizeof(float) * 4);
         return(new ExternallyDefinedTypeDeclaration("Vector4", declaration)
         {
             Namespace = "System.Numerics"
         });
     }
        protected override TransformationResult TransformRecord(TransformationContext context, TranslatedRecord declaration)
        {
            // Private/protected records are always stripped
            if (declaration.Accessibility is AccessModifier.Private or AccessModifier.Protected)
            {
                return(null);
            }

            return(base.TransformRecord(context, declaration));
        }
        protected override TransformationResult TransformRecord(TransformationContext context, TranslatedRecord declaration)
        {
            // A PhysX enum record is one that has no members except a single EnumDeclaration.
            if (declaration.Members.Count == 1 && declaration.TotalMemberCount == 1 && declaration.Members[0] is TranslatedEnum enumDeclaration)
            {
                return(enumDeclaration with
                {
                    Name = declaration.Name,
                    TranslateAsLooseConstants = false
                });
            }

            // A handful of types (such as PxVehicleDifferential4WData) are more complicated and still have a nested name-irrelevant enum
            // Handle those types by creating aliases to their enum constants
            int i = -1;

            foreach (TranslatedDeclaration member in declaration.Members)
            {
                i++;

                if (member is TranslatedEnum {
                    Name: "Enum", TranslateAsLooseConstants: false
                } nestedEnum)
                {
                    ImmutableList <TranslatedDeclaration> .Builder membersBuilder = declaration.Members.ToBuilder();
                    membersBuilder.InsertRange(i + 1, nestedEnum.Values.Select(v => new EnumAliasDeclaration(v)));

                    return(declaration with
                    {
                        Members = membersBuilder.ToImmutable()
                    });
                }
            }

            return(declaration);
        }