GTANAdam

// using System;
// using System.Diagnostics;
// using System.Runtime.CompilerServices;

[MethodImpl(MethodImplOptions.AggressiveInlining)]
unsafe static void BlockCopy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int count)
{
    Debug.Assert(src != null);
    Debug.Assert(dst != null);
    Debug.Assert(srcOffset >= 0 && srcOffset < src.Length);

GTANAdam

$ apk add sshfs
$ modprobe fuse
$ mkdir /mnt/server
$ sshfs root@192.168.1.12:/ /mnt/server

GTANAdam

#!/bin/sh
radio2_restart && radio5_restart

GTANAdam

#pragma once

#include <vector>

#ifdef THREAD_SAFE_EVENTS
    #include <shared_mutex>

    #define MUTEX       std::shared_mutex rwmutex;
    #define RWLOCK      rwmutex.lock();
    #define RWUNLOCK    rwmutex.unlock();

GTANAdam

Precompiled headers basically improve build times by reducing the amount of code compiling each time a build 
command is invoked.
This feature is available in Visual Studio for Windows C/C++ development 
via project "Properties" -> "C/C++" -> "Precompiled Headers", 
but this feature is missing for Linux C/C++ Development (Visual Studio) and 
requires a workaround since GCC/Clang support pch.

The workaround:
- Creating a "precompile.sh" bash script and appending the content above.
- Set in your project's properties in "Properties" -> "Build Events" -> "WSL Pre-Build Event", the following:

GTANAdam

#pragma once

// LINKER_INCLUDE_UNUSED: Forces linker to keep unused functions that were declared elsewhere
// LINKER_KEEP_UNUSED: Forces linker to keep unused functions that are delcared within the current file

#define EXPORT extern "C" _declspec(dllexport)

#if defined(LINKER_INCLUDE_UNUSED)
    #if defined(_WIN64)
        #define LINKER_KEEP(s) EXPORT __pragma(comment (linker, "/export:"#s))

GTANAdam

#pragma once
#include <thread>

namespace std_ex {
	template <typename Callable, typename... Args>
	std::thread thread(Callable&& f, Args&& ... args) {
		return std::thread(f, args...);
	}
}

GTANAdam

public unsafe static void MarshalPtrToStructureArray<T>(IntPtr sPtr, ulong arrSize, ref T[] output) where T : unmanaged
{
    fixed (T* dPtr = output)
    {
        ulong dataSize = arrSize * (uint)Marshal.SizeOf(typeof(T));
        Unsafe.CopyBlock(dPtr, (void*)sPtr, (uint)dataSize);
        
        // Alternatively, .NET Framework >= 4.6
        // ulong dataSize = arrSize * (uint)Marshal.SizeOf<T>();
        // Buffer.MemoryCopy((void*)sPtr, dPtr, dataSize, dataSize);