it's a library binding to opengl and other low level libraries they're the misuse capitals of progra

it's a library binding to opengl and other low level libraries
they're the misuse capitals of programming
i think trying to go this far to prevent misuse is a bit of a waste of time, people will misuse it regardless

AquaOP•10/17/23, 9:33 PM

i misuse the entirety of C# so

AquaOP•10/17/23, 9:33 PM

if there's a will there's a way

Curin•10/17/23, 9:34 PM

and what happens when they see byte**const (which I don't know if C# can even replicate with base keywords)?

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

yeah C# can't replicate it, it's just all

byte**

byte**

which the user can do whatever they please with

AAqua it's a library binding to opengl and other low level libraries they're the misus...

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

i'll write some words on the proposals, but it's best to stick with this for now. we could go with an analyser based approach and go with stuff as you suggest, but this does still lose type safety a lot.

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

i feel like generalising any pointer to a single type (or single generic type) is extremely dangerous and becomes even more so when you start thinking about structs, which we haven't tackled yet

AquaOP•10/17/23, 9:39 PM

unsafe

unsafe

in C# is by its very nature "extremely dangerous"
if the user fucks it up, it should be because of something they did
not because the library provided a billion custom pointer types that caused the user to use the wrong one
i'm assuming this whole thing is so that silk can be used in a "safe" environment, which is fair enough, but there's only so safe you can get with opengl and other lower level libraries
try to make it too safe and you enter rust territory, and i don't think anyone really wants that
if you take a look at opentk, its still in a safe context but you can very easily screw it up just like anything else

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

you have a fence around your garden, right? people can just climb over that, stand on it, do unspeakable things to it, whatever. is this an argument for not having a fence at all?

AquaOP•10/17/23, 9:40 PM

no, but you could make the argument that it's pointless making the fence too tall. sure it makes it harder to climb over, but it also makes things worse for you as well

AquaOP•10/17/23, 9:40 PM

i think having some levels of type safety is good, just not a massive wall of custom types for the name of absolute type safety

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

i think as i said on the coffee & code this needs to be discussed in a formal working group meeting once we have something to discuss

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

also this is at least partially to help cut down on overload count separate from the safety issue

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

provides implicit conversions you can use instead of having a silly number of overloads

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

yeah that's the sole goal

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

we could also just go fully unsafe but have extension methods generated on-the-fly to do marshalling and the IDE experience would be even more terrible than this

Curin•10/17/23, 9:46 PM

yes, D2D in specific has a 16 ptr overload that could take spans for each, 16^16 is stupid

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

ultimately these days in the advent of TerraFX being an official DNF project Silk.NET has no reason to exist other than its overloading abilities, and the current implementation of this is known-problematic which is why we're trying to come up with another one which is less problematic. still problematic mind, but a less so in that you don't have to sift through hundreds of overloads.

AquaOP•10/17/23, 9:51 PM

if that's the case, could it be worth considering switching to a more safe/managed environment? instead of trying to get both safe and unsafe at once
there are no (sane) safe vulkan libraries for example, silk could fill that gap quite easily if tried
and by safe i don't mean arrays etc, i mean spans

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

but then you can't mix and match which was the reason our overloading system was so great

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

and we consistently got complaints that you couldn't do that when we tried it in 1.0

Curin•10/17/23, 9:53 PM

spans also don't work well for double ptr cases, which can be either lists of lists or a ptr to place a single object (DX has this a lot)

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

yeah

PPerksey and we consistently got complaints that you couldn't do that when we tried it in...

AquaOP•10/17/23, 9:55 PM

you'll never please everyone - last time i checked opentk was completely safe and i've not seen too many complaints about that (i use opentk as an example as i used it for a good year or so before switching to silk)
personally i can't see a time when you'd want to mix and match - you either use unsafe or safe
so silk could be the safer alternative to terrafx for example

CCurin spans also don't work well for double ptr cases, which can be either lists of li...

AquaOP•10/17/23, 9:55 PM

fair point

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

you'll never please everyone

but when both sides are really angry, it's annoying

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

yeah having this as a safe way to handle jagged arrays and ref to pointer situations is why I'm most interested

AAqua you'll never please everyone - last time i checked opentk was completely safe an...

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

https://discord.com/channels/521092042781229087/939645285896962088/1137442690687062089 ¯\_(ツ)_/¯

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

that and the new implementation of silkmarshal since that rules for strings

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

i'm only here because i didn't know what terrafx was and perks is a friend

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

I'm here for the overloads and the general offtopic channel tbh

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

i thought we settled on implicit casts for overloading and it worked reasonably well?

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

yeah that's this

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

we didn't settle, this is just us pursuing a prototype

dfkeenan🍍🍕•10/17/23, 9:59 PM

I don't know why I'm here.

PPerksey we didn't settle, this is just us pursuing a prototype

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

none of this has been formally agreed

AquaOP•10/17/23, 9:59 PM

i'm here because i enjoyed that silk offered a lot more options than opentk
i didn't care for unsafe initially
and i'm currently trying to play devil's advocate, that is all
and i'm trying to come at this objectively, subjectively my opinions are somewhat different to what i am saying

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

yeah but it's good enough

AAqua i'm here because i enjoyed that silk offered a lot more options than opentk i di...

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

oh yeah no it's appreciated

Maxine•10/17/23, 10:00 PM

all bureaucracy aside, i don't see any way of doing this in practicality that isn't the cast system

khitiara•10/17/23, 10:00 PM

unless we get ref struct as generics and as ref fields

khitiara•10/17/23, 10:00 PM

in which case it becomes a lot easier

Curin•10/17/23, 10:01 PM

Not to derail too much, but for the string conversions, going to strings is expected just to be explicit from a function right (need for array sizes), and then implicit from string arrays to our types?

Perksey•10/17/23, 10:03 PM

implicit from string/string array, explicit to string, to string array has to be a function

Perksey•10/17/23, 10:03 PM

with the ReadToString/ReadToStringArray functions as appropriate

Curin•10/17/23, 10:04 PM

okay, sounds good

Ddfkeenan🍍🍕I don't know why I'm here. 😂

Perksey•10/17/23, 10:22 PM

perhaps because you want to gaslight people into thinking pineapple on pizza is okay

yeah i saw your nickname change

dfkeenan🍍🍕•10/17/23, 11:16 PM

It's been like this for ages on another server. I decided to make it the same everywhere

Curin•10/18/23, 2:58 AM

/// <summary>
/// creates a <see cref="MutMut"/> from a pointer array
/// </summary>
/// <param name="array"></param>
public static implicit operator MutMut(byte*[] array)
{
    IL.Emit.Ldarg_0();
    IL.Emit.Ldc_I4_0();
    IL.Emit.Ldelema(TypeRef.Type(typeof(byte).MakePointerType()));
    IL.Emit.Newobj(
        MethodRef.Constructor(
            TypeRef.Type(typeof(MutMut)),
            TypeRef.Type(typeof(Mut))
        )
    );
    IL.Emit.Ret();
    throw IL.Unreachable();
}

/// <summary>
/// creates a <see cref="MutMut"/> from a pointer array
/// </summary>
/// <param name="array"></param>
public static implicit operator MutMut(byte*[] array)
{
    IL.Emit.Ldarg_0();
    IL.Emit.Ldc_I4_0();
    IL.Emit.Ldelema(TypeRef.Type(typeof(byte).MakePointerType()));
    IL.Emit.Newobj(
        MethodRef.Constructor(
            TypeRef.Type(typeof(MutMut)),
            TypeRef.Type(typeof(Mut))
        )
    );
    IL.Emit.Ret();
    throw IL.Unreachable();
}

So this code block gives me the following error, but I do have a constructor (public MutMut(ref Mut @Ref)). Any ideas how to fix this?

Fody/InlineIL: Type Silk.NET.Core.MutMut has no constructor with signature (Silk.NET.Core.Mut) (in Silk.NET.Core.MutMut Silk.NET.Core.MutMut::op_Implicit(System.Byte*[]) at instruction IL_0053: call System.Void InlineIL.IL/Emit::Newobj(InlineIL.MethodRef))

khitiara•10/18/23, 2:59 AM

need to makebyreftype the mut in the constructor specification

khitiara•10/18/23, 3:00 AM

ref mut and mut are diff types

/// <summary> /// creates a <see cref="MutMut"/> from a pointer array /// </summary> /// <param name="array"></param> public static implicit operator MutMut(byte*[] array) { IL.Emit.Ldarg_0(); IL.Emit.Ldc_I4_0(); IL.Emit.Ldelema(TypeRef.Type(typeof(byte).MakePointerType())); IL.Emit.Newobj( MethodRef.Constructor( TypeRef.Type(typeof(MutMut)), TypeRef.Type(typeof(Mut)) ) ); IL.Emit.Ret(); throw IL.Unreachable(); }

it's a library binding to opengl and other low level libraries they're the misuse capitals of progra

Similar Threads