benloong

import Foundation

extension Array {
    
    func random2(_ lower: Int, _ upper: Int) -> Int {
        return random() % (upper - lower) + lower
    }

    func randomTake<T>(_ n: Int) -> [T] {

benloong

    public bool Raycast(Ray r, out float distance)
    {
        Vector3 min = this.min;
        Vector3 max = this.max;

        float tmin = float.NegativeInfinity, tmax = float.PositiveInfinity;

        Vector3 dir_inv = new Vector3();

benloong

using UnityEngine;
using System.Collections;
using UnityEditor;

public class ExportSprites  {

	[MenuItem("Assets/Create/SpriteScriptableObject")]
	static void Export()
	{
		foreach (var sprite in Selection.objects) {

benloong

Shader "UI/Dissolve"
{
    Properties
    {
        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
        _Color ("Tint", Color) = (1,1,1,1)

        _StencilComp ("Stencil Comparison", Float) = 8
        _Stencil ("Stencil ID", Float) = 0
        _StencilOp ("Stencil Operation", Float) = 0

benloong

#pragma once

#include<type_traits>


template <typename T> class Delegate;

template<class R, class ...Args>
class Delegate <R(Args...)> final
{

benloong

using UnityEngine;
using UnityEngine.EventSystems;

public class PageViewController : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerDownHandler, IPointerUpHandler
{
    public enum Direction
    {
        Horizontal,
        Vertical
    }

benloong

template<typename L1, typename L2>
struct S : L1, L2
{
    S(L1 l1, L2 l2) :L1( std::move(l1) ), L2( std::move(l2) )
    {

    }
    using L1::operator();
    using L2::operator();

benloong

#include <future>

struct SpinLock {
    std::atomic_flag spin_flag = ATOMIC_FLAG_INIT;
  
    void lock() {
        for (size_t k = 0; spin_flag.test_and_set(std::memory_order_acquire); k++)
        {
            if (k < 4)
            {

benloong

#pragma once

#include<memory>

template<int alignment>
struct aligned_allocator
{
    static_assert((alignment&(alignment - 1)) == 0, "alignment must be power of 2.");

    void* allocate(size_t size) {

benloong

#pragma once
#include<memory>

template<typename T, size_t ChunkSize = 1024>
struct pool_allocator
{
    using alloc_type = T;
    using pointer_type = alloc_type*;

    pool_allocator()