though if I just use the 2d to create the 3d we will end up with T*[][], will that still work?

CCurin though if I just use the 2d to create the 3d we will end up with T*[][], will th...

P

Perksey•10/17/23, 8:25 PM

I'm confused, isn't it

-    public static T*[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[]> array)
+    public static T**[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[][]> array)
        where T : unmanaged
    {
-        var ret = new T*[array.Length];
+        var ret = new T**[array.Length];
        for (var i = 0; i < array.Length; i++)
        {
-           var handle = GCHandle.Alloc(array[i], GCHandleType.Pinned);
+           var handle = GCHandle.Alloc(JaggedArrayToPointerArray(array[i]), GCHandleType.Pinned);
            var sentinel = new GCHandleSentinel(handle);
            var dep = new DependentHandle(ret, sentinel);
            if (!dep.IsAllocated)
            {
                throw new InvalidOperationException(
                    "Failed to allocate dependent handle to keep string alive"
                );
            }

            sentinel.DependentHandle = dep;
-           ret[i] = (T*)handle.AddrOfPinnedObject();
+           ret[i] = (T**)handle.AddrOfPinnedObject();
        }

        return ret;
    }

-    public static T*[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[]> array)
+    public static T**[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[][]> array)
        where T : unmanaged
    {
-        var ret = new T*[array.Length];
+        var ret = new T**[array.Length];
        for (var i = 0; i < array.Length; i++)
        {
-           var handle = GCHandle.Alloc(array[i], GCHandleType.Pinned);
+           var handle = GCHandle.Alloc(JaggedArrayToPointerArray(array[i]), GCHandleType.Pinned);
            var sentinel = new GCHandleSentinel(handle);
            var dep = new DependentHandle(ret, sentinel);
            if (!dep.IsAllocated)
            {
                throw new InvalidOperationException(
                    "Failed to allocate dependent handle to keep string alive"
                );
            }

            sentinel.DependentHandle = dep;
-           ret[i] = (T*)handle.AddrOfPinnedObject();
+           ret[i] = (T**)handle.AddrOfPinnedObject();
        }

        return ret;
    }

-    public static T*[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[]> array)
+    public static T**[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[][]> array)
        where T : unmanaged
    {
-        var ret = new T*[array.Length];
+        var ret = new T**[array.Length];
        for (var i = 0; i < array.Length; i++)
        {
-           var handle = GCHandle.Alloc(array[i], GCHandleType.Pinned);
+           var handle = GCHandle.Alloc(JaggedArrayToPointerArray(array[i]), GCHandleType.Pinned);
            var sentinel = new GCHandleSentinel(handle);
            var dep = new DependentHandle(ret, sentinel);
            if (!dep.IsAllocated)
            {
                throw new InvalidOperationException(
                    "Failed to allocate dependent handle to keep string alive"
                );
            }

            sentinel.DependentHandle = dep;
-           ret[i] = (T*)handle.AddrOfPinnedObject();
+           ret[i] = (T**)handle.AddrOfPinnedObject();
        }

        return ret;
    }

-    public static T*[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[]> array)
+    public static T**[] JaggedArrayToPointerArray<T>(ReadOnlySpan<T[][]> array)
        where T : unmanaged
    {
-        var ret = new T*[array.Length];
+        var ret = new T**[array.Length];
        for (var i = 0; i < array.Length; i++)
        {
-           var handle = GCHandle.Alloc(array[i], GCHandleType.Pinned);
+           var handle = GCHandle.Alloc(JaggedArrayToPointerArray(array[i]), GCHandleType.Pinned);
            var sentinel = new GCHandleSentinel(handle);
            var dep = new DependentHandle(ret, sentinel);
            if (!dep.IsAllocated)
            {
                throw new InvalidOperationException(
                    "Failed to allocate dependent handle to keep string alive"
                );
            }

            sentinel.DependentHandle = dep;
-           ret[i] = (T*)handle.AddrOfPinnedObject();
+           ret[i] = (T**)handle.AddrOfPinnedObject();
        }

        return ret;
    }

C

CurinOP•10/17/23, 8:26 PM

okay that is how you are handling it, I started going down this route after I sent that message

C

CurinOP•10/17/23, 8:26 PM

I was going too simple for the overload

P

Perksey•10/17/23, 8:27 PM

ah yeah, i think given we're really restricted on what we can have in generics i don't think we can be more generalised

C

CurinOP•10/17/23, 8:28 PM

 IL.Emit.Ldarg_0();
IL.Emit.Ldc_I4_0();
IL.Emit.Ldelema(TypeRef.Type(typeof(T).MakePointerType()));
IL.Emit.Newobj(
    MethodRef.Constructor(
        TypeRef.Type(typeof(ConstPtr2D<>).MakeGenericType(typeof(T))),
        TypeRef.Type(typeof(ConstPtr<>).MakeGenericType(typeof(T)).MakeByRefType())
    )
);
IL.Emit.Ret();
throw IL.Unreachable();

 IL.Emit.Ldarg_0();
IL.Emit.Ldc_I4_0();
IL.Emit.Ldelema(TypeRef.Type(typeof(T).MakePointerType()));
IL.Emit.Newobj(
    MethodRef.Constructor(
        TypeRef.Type(typeof(ConstPtr2D<>).MakeGenericType(typeof(T))),
        TypeRef.Type(typeof(ConstPtr<>).MakeGenericType(typeof(T)).MakeByRefType())
    )
);
IL.Emit.Ret();
throw IL.Unreachable();

 IL.Emit.Ldarg_0();
IL.Emit.Ldc_I4_0();
IL.Emit.Ldelema(TypeRef.Type(typeof(T).MakePointerType()));
IL.Emit.Newobj(
    MethodRef.Constructor(
        TypeRef.Type(typeof(ConstPtr2D<>).MakeGenericType(typeof(T))),
        TypeRef.Type(typeof(ConstPtr<>).MakeGenericType(typeof(T)).MakeByRefType())
    )
);
IL.Emit.Ret();
throw IL.Unreachable();

 IL.Emit.Ldarg_0();
IL.Emit.Ldc_I4_0();
IL.Emit.Ldelema(TypeRef.Type(typeof(T).MakePointerType()));
IL.Emit.Newobj(
    MethodRef.Constructor(
        TypeRef.Type(typeof(ConstPtr2D<>).MakeGenericType(typeof(T))),
        TypeRef.Type(typeof(ConstPtr<>).MakeGenericType(typeof(T)).MakeByRefType())
    )
);
IL.Emit.Ret();
throw IL.Unreachable();

C

CurinOP•10/17/23, 8:29 PM

and that is what actually goes in the function to convert our type to T* * * from T* *[]

C

CurinOP•10/17/23, 8:29 PM

or something like that atleast I just pulled that from ConstPtr2D

P

Perksey•10/17/23, 8:34 PM

ah yeah, that's an easy case though because we already know that we have a raw (untracked) pointer within the array, so the GC can just keep that array alive and not care about the pointers contained therein

P

Perksey•10/17/23, 8:35 PM

the jagged arrays are more complicated because ref fields aren't allowed for a reason - the GC currently can't see a ref within a ref so we have to manually keep the inner arrays alive

P

Perksey•10/17/23, 8:36 PM

this may immediately ring alarm bells like "but wait, that means a PtrPtr being created from a ref Ptr is super dangerous" and you'd be right if it weren't for the fact that we know that ref structs are on the stack anyway, so we don't need to worry about this

C

CurinOP•10/17/23, 8:37 PM

yep, ref structs are nice like that, its why you can really do some fun stuff with spans

M

Maxine•10/17/23, 8:39 PM

i can't wait until we have spans of spans/const generics/ref struct fields and all of this goes to waste

CCurin test output from the generator

P

Perksey•10/17/23, 8:39 PM

oh also don't forget being implicitly convertible from

NullPtr

NullPtr

NullPtr

NullPtr. basically just go over the existing manual types and see if there's anything missing from the generated ones (as this is basically what i'm doing now)

P

Perksey•10/17/23, 8:40 PM

and if that doesn't pull up anything obvious, getting the unit tests/playground project to light up sure will

MMaxine i can't wait until we have spans of spans/const generics/ref struct fields and a...

K

khitiara•10/17/23, 8:40 PM

same, thatll make this so much easier lmao

MMaxine i can't wait until we have spans of spans/const generics/ref struct fields and a...

P

Perksey•10/17/23, 8:40 PM

yep this is basically why this exists

M

Maxine•10/17/23, 8:40 PM

the destiny of a c# developer is to rewrite all of their code every new version

P

Perksey•10/17/23, 8:40 PM

good thing that we'll be on a major release every 2 years by then

P

Perksey•10/17/23, 8:40 PM

Silk.NET 4.0 will release on November 2025, this is a promise

P

Perksey•10/17/23, 8:41 PM

to coincide with .NET 10, the latest LTS

PPerksey oh also don't forget being implicitly convertible from `NullPtr`. basically just...

C

CurinOP•10/17/23, 8:41 PM

that sould already be there

P

Perksey•10/17/23, 8:41 PM

oh did i miss it

P

Perksey•10/17/23, 8:41 PM

one sec

P

Perksey•10/17/23, 8:41 PM

ah yeah there it is

P

Perksey•10/17/23, 8:41 PM

wait are the equality operators in there

C

CurinOP•10/17/23, 8:42 PM

not with nullptr I don't think, I'll get those in

P

Perksey•10/17/23, 8:42 PM

public static implicit operator PTRMUTPTR(Span<PTRMUT> span) => new(ref span.GetPinnableReference());
public static implicit operator PTRMUTPTR(Span<PTRMUT> span) => new(ref span.GetPinnableReference());
public static implicit operator PTRMUTPTR(Span<PTRMUT> span) => new(ref span.GetPinnableReference());
public static implicit operator PTRMUTPTR(Span<PTRMUT> span) => new(ref span.GetPinnableReference());

just realised this is not possible also (ref struct as generics, iirc this is why I included the very vague "unless the Silk.NET team deem it inappropriate or inapplicable" language)

C

CurinOP•10/17/23, 8:44 PM

okay, I can move that line to only make the spans for single dimension types

PPerksey > ` public static implicit operator PTRMUTPTR(Span<PTRMUT> span) => new(ref s...

C

CurinOP•10/17/23, 8:47 PM

Will the As span then not work for the higher dimensionals as well?

P

Perksey•10/17/23, 8:47 PM

yep they won't work either

K

Kai•10/17/23, 8:56 PM

saving that for later

M

Maxine•10/17/23, 8:56 PM

a bold promise to make

P

Perksey•10/17/23, 9:00 PM

my plan is to have 3.0 being the working copy up until the first .NET 10 preview releases, and then we branch off and start working on new stuff on a 4.0 branch, using the backport bot in arcade as necessary.

A

Aqua•10/17/23, 9:00 PM

silk.net 5.0:

Silk.NET.Everything.RunGame();

Silk.NET.Everything.RunGame();

Silk.NET.Everything.RunGame();

Silk.NET.Everything.RunGame();

game is ai generated

P

Perksey•10/17/23, 9:01 PM

Silk.NET.Everything.RunGame("a twin stick shooter where the player shoots cuboids and they explode into smaller cuboids");

Silk.NET.Everything.RunGame("a twin stick shooter where the player shoots cuboids and they explode into smaller cuboids");

Silk.NET.Everything.RunGame("a twin stick shooter where the player shoots cuboids and they explode into smaller cuboids");

Silk.NET.Everything.RunGame("a twin stick shooter where the player shoots cuboids and they explode into smaller cuboids");

C

CurinOP•10/17/23, 9:03 PM

Okay, I think we are good, but here is an example of each of the cases in case I missed something.

PTRMUTPTR.generic.gen.cs12.21KB

MUT.gen.cs10.92KB

MUT.generic.gen.cs12.82KB

PTRMUTPTR.gen.cs11.81KB

P

Perksey•10/17/23, 9:08 PM

public static implicit operator void***(PTRMUTPTR<T> ptr) => (void***)Unsafe.AsPointer(ref Unsafe.AsRef(in ptr.Ref));
public static implicit operator void***(PTRMUTPTR<T> ptr) => (void***)Unsafe.AsPointer(ref Unsafe.AsRef(in ptr.Ref));
public static implicit operator void***(PTRMUTPTR<T> ptr) => (void***)Unsafe.AsPointer(ref Unsafe.AsRef(in ptr.Ref));
public static implicit operator void***(PTRMUTPTR<T> ptr) => (void***)Unsafe.AsPointer(ref Unsafe.AsRef(in ptr.Ref));

still implicit

public static bool operator !=(object? lh, PTRMUTPTR<T> rh) => lh == null ? (void*)rh != null : true;
public static bool operator !=(object? lh, PTRMUTPTR<T> rh) => lh == null ? (void*)rh != null : true;
public static bool operator !=(object? lh, PTRMUTPTR<T> rh) => lh == null ? (void*)rh != null : true;
public static bool operator !=(object? lh, PTRMUTPTR<T> rh) => lh == null ? (void*)rh != null : true;

this doesn't feel correct, mainly because we're not using the value of

lh

lh

lh

lh, we're just null checking

public MUT(ref readonly T @Ref)
public MUT(ref readonly T @Ref)
public MUT(ref readonly T @Ref)
public MUT(ref readonly T @Ref)

should be

ref T

ref T

ref T

ref T

mutability does not match

P

Perksey•10/17/23, 9:08 PM

also there's no string operators, but i can do that if you haven't got a lot of time

PPerksey also there's no string operators, but i can do that if you haven't got a lot of ...

C

CurinOP•10/17/23, 9:14 PM

by string operators do you mean the string conversions?

P

Perksey•10/17/23, 9:14 PM

yeah

C

CurinOP•10/17/23, 9:17 PM

The base explicit conversion is there for the 1 dimensional variants, fully defined for the non-generic. For the generic, I just need to do the extension methods to let it call the correct functions assuming it is the correct types. Are you expecting anything for higher dimensions, or are we just worried about 1D case?

P

Perksey•10/17/23, 9:19 PM

ConstPtr2D supported string arrays as well, and was just about as complicated as the jagged array stuff

P

Perksey•10/17/23, 9:20 PM

i think generally the best route once the generation is working it to try and replace the original manual types, and see what's missing.

C

CurinOP•10/17/23, 9:20 PM

Also for your second comment, about the object equality, it is because we only really care about the case of an object being null, since the more specific overrides will take over if we are talking about other types we care about. I can use the !rh.Equals(lh) in place of true and make sure equals uses base.equals as its final, but in the end it should always turn out to be true anyways.

P

Perksey•10/17/23, 9:20 PM

what if you have a boxed raw pointer

K

khitiara•10/17/23, 9:20 PM

is boxing pointers even legal in c#?

M

Maxine•10/17/23, 9:20 PM

laws are made to be broken

Kkhitiara is boxing pointers even legal in c#?

A

Aqua•10/17/23, 9:21 PM

no

K

khitiara•10/17/23, 9:21 PM

lmao

P

Perksey•10/17/23, 9:21 PM

ah apparently not

though if I just use the 2d to create the 3d we will end up with T*[][], will that still work?

Similar Threads