加入组织申请

[DotnetInstall]

申请书

昵称: 在这里就叫我DotnetInstall吧

QQ 号: 暂不愿透露

擅长的领域: C++, C#, C, 后端全栈开发, 游戏引擎架构

自我介绍:
作为一名拥有8年开发经验的学生（本人即将高考），我专注于高性能计算、游戏引擎开发，图形学开发以及AI研究。在过去的几年中，我不仅为知名开源项目如Unreal Engine 5贡献了代码（非我的大账号，这是我处理一些事物的后注册新号），还独立开发了自己的游戏引擎和系统级应用。我对底层系统架构和性能优化有着深刻理解，能够设计和实现既高效又可扩展的复杂软件系统，同时我还是独立游戏开发者，并在IndieNova上获得认证

能力证明材料:

1. Unreal Engine 贡献 - 我为UE5的Nanite几何系统优化了内存使用，提升了约15%的渲染性能（非本账号），具体文件可看附件

2. 系统开发 - 设计并实现了多个底层系统组件，包括自定义内存分配器、多线程任务调度器等。

3. 其他开源贡献 - 如新制作的Unity Modding工具等，同时拥有forge模组开发经营，forge开发经验以及对MC渲染逻辑有所研究，有启动器开发经验

4.竞赛 - 拿过牌子但是已经退役好几年了，具体信息就不说了（不喜欢竞赛），仅做陈述用，可以忽略（说实话我特别讨厌信息竞赛，跟计算机没啥关系，恶心）

附：我本人还参与过其他游戏饭制内容的开发且是核心开发者，如果实在需要可以回复我我会考虑补加
能力证明（代码片段展示）:

// 1. 高效内存池实现
template<typename T, size_t BlockSize = 4096>
class MemoryPool {
private:
    struct Block {
        char data[BlockSize];
        Block* next;
    };
    
    union Slot {
        T element;
        Slot* next;
    };
    
    Block* currentBlock;
    Slot* freeSlots;
    size_t itemsInCurrentBlock;
    
    static constexpr size_t slotsPerBlock = BlockSize / sizeof(Slot);
    
public:
    MemoryPool() : currentBlock(nullptr), freeSlots(nullptr), itemsInCurrentBlock(0) {}
    
    ~MemoryPool() {
        while (currentBlock) {
            Block* temp = currentBlock->next;
            operator delete(currentBlock);
            currentBlock = temp;
        }
    }
    
    T* allocate() {
        if (freeSlots) {
            T* result = reinterpret_cast<T*>(freeSlots);
            freeSlots = freeSlots->next;
            return result;
        }
        
        if (!currentBlock || itemsInCurrentBlock >= slotsPerBlock) {
            Block* newBlock = static_cast<Block*>(operator new(sizeof(Block)));
            newBlock->next = currentBlock;
            currentBlock = newBlock;
            itemsInCurrentBlock = 0;
        }
        
        Slot* currentSlot = reinterpret_cast<Slot*>(currentBlock->data) + itemsInCurrentBlock++;
        return reinterpret_cast<T*>(currentSlot);
    }
    
    void deallocate(T* p) {
        if (!p) return;
        Slot* slot = reinterpret_cast<Slot*>(p);
        slot->next = freeSlots;
        freeSlots = slot;
    }
    
    template<typename... Args>
    T* construct(Args&&... args) {
        T* p = allocate();
        new (p) T(std::forward<Args>(args)...);
        return p;
    }
    
    void destroy(T* p) {
        if (p) {
            p->~T();
            deallocate(p);
        }
    }
};

// 2. 多线程任务系统
class TaskSystem {
private:
    struct Task {
        std::function<void()> func;
        Task* next;
    };
    
    std::atomic<Task*> head{nullptr};
    std::atomic<Task*> tail{nullptr};
    std::atomic<bool> isRunning{true};
    MemoryPool<Task> taskPool;
    std::vector<std::thread> threads;
    std::mutex mutex;
    std::condition_variable cv;
    
public:
    TaskSystem(size_t threadCount = std::thread::hardware_concurrency()) {
        for (size_t i = 0; i < threadCount; ++i) {
            threads.emplace_back([this] {
                while (isRunning.load(std::memory_order_acquire) || head.load(std::memory_order_acquire)) {
                    Task* task = nullptr;
                    {
                        std::unique_lock<std::mutex> lock(mutex);
                        cv.wait(lock, [this] { 
                            return !isRunning.load(std::memory_order_acquire) || 
                                   head.load(std::memory_order_acquire) != nullptr; 
                        });
                        
                        task = dequeueTask();
                    }
                    
                    if (task) {
                        task->func();
                        taskPool.destroy(task);
                    }
                }
            });
        }
    }
    
    ~TaskSystem() {
        shutdown();
        for (auto& thread : threads) {
            if (thread.joinable()) {
                thread.join();
            }
        }
    }
    
    template<typename F>
    void enqueue(F&& f) {
        Task* task = taskPool.construct();
        task->func = std::forward<F>(f);
        task->next = nullptr;
        
        Task* oldTail = tail.exchange(task, std::memory_order_acq_rel);
        if (oldTail) {
            oldTail->next = task;
        } else {
            head.store(task, std::memory_order_release);
        }
        
        cv.notify_one();
    }
    
    Task* dequeueTask() {
        Task* currentHead = head.load(std::memory_order_acquire);
        if (!currentHead) {
            return nullptr;
        }
        
        Task* next = currentHead->next;
        head.store(next, std::memory_order_release);
        
        if (!next) {
            tail.store(nullptr, std::memory_order_release);
        }
        
        return currentHead;
    }
    
    void shutdown() {
        isRunning.store(false, std::memory_order_release);
        cv.notify_all();
    }
};

// 3. C#高性能ECS系统核心
public sealed class EntityWorld {
    private readonly Dictionary<Type, ComponentPool> _componentPools = new();
    private readonly Dictionary<int, HashSet<Type>> _entityComponents = new();
    private readonly Stack<int> _freeEntityIds = new();
    private int _nextEntityId = 0;

    public int CreateEntity() {
        int id = _freeEntityIds.Count > 0 ? _freeEntityIds.Pop() : _nextEntityId++;
        _entityComponents[id] = new HashSet<Type>();
        return id;
    }

    public void DestroyEntity(int entityId) {
        if (!_entityComponents.TryGetValue(entityId, out var components)) return;
        
        foreach (var type in components) {
            GetComponentPool(type).Remove(entityId);
        }
        
        _entityComponents.Remove(entityId);
        _freeEntityIds.Push(entityId);
    }

    public T AddComponent<T>(int entityId) where T : struct {
        var type = typeof(T);
        if (!_entityComponents.TryGetValue(entityId, out var components)) {
            throw new ArgumentException($"Entity {entityId} does not exist");
        }
        
        components.Add(type);
        return ((ComponentPool<T>)GetComponentPool(type)).Add(entityId);
    }

    public void RemoveComponent<T>(int entityId) where T : struct {
        var type = typeof(T);
        if (_entityComponents.TryGetValue(entityId, out var components)) {
            components.Remove(type);
            GetComponentPool(type).Remove(entityId);
        }
    }

    public ref T GetComponent<T>(int entityId) where T : struct {
        return ref ((ComponentPool<T>)GetComponentPool(typeof(T))).Get(entityId);
    }

    public bool HasComponent<T>(int entityId) where T : struct {
        return _entityComponents.TryGetValue(entityId, out var components) && 
               components.Contains(typeof(T));
    }

    private ComponentPool GetComponentPool(Type type) {
        if (!_componentPools.TryGetValue(type, out var pool)) {
            pool = (ComponentPool)Activator.CreateInstance(
                typeof(ComponentPool<>).MakeGenericType(type));
            _componentPools[type] = pool;
        }
        return pool;
    }

    private abstract class ComponentPool {
        public abstract void Remove(int entityId);
    }

    private class ComponentPool<T> : ComponentPool where T : struct {
        private readonly Dictionary<int, int> _entityToIndex = new();
        private readonly Dictionary<int, int> _indexToEntity = new();
        private readonly List<T> _components = new();

        public ref T Get(int entityId) {
            if (!_entityToIndex.TryGetValue(entityId, out var index)) {
                throw new ArgumentException($"Entity {entityId} does not have component {typeof(T).Name}");
            }
            return ref _components[index];
        }

        public T Add(int entityId) {
            if (_entityToIndex.ContainsKey(entityId)) {
                return _components[_entityToIndex[entityId]];
            }
            
            var component = new T();
            _entityToIndex[entityId] = _components.Count;
            _indexToEntity[_components.Count] = entityId;
            _components.Add(component);
            return component;
        }

        public override void Remove(int entityId) {
            if (!_entityToIndex.TryGetValue(entityId, out var index)) return;
            
            int lastIndex = _components.Count - 1;
            int lastEntity = _indexToEntity[lastIndex];
            
            _components[index] = _components[lastIndex];
            _entityToIndex[lastEntity] = index;
            _indexToEntity[index] = lastEntity;
            
            _entityToIndex.Remove(entityId);
            _indexToEntity.Remove(lastIndex);
            _components.RemoveAt(lastIndex);
        }
    }
}

其他想说的内容:
用新号来注册的原因是希望能够在一个新地方重新出发，而且这也很有趣不是吗
下方附一个我得自制引擎底层渲染代码（我最多只能提供这些，要不然这个号不保（）但足以说明我的水平），比较古老了，还有我的Nanite贡献文件（比较多，挑了比较有代表的一部分，为了证明原创性我都加了自己的注释，Nanite直接从pr里摘过来的所以是英语注释）
NaniteVisibility.zip
Renderer.zip
一些自制启动器截图

[MoYuan-CN]

在 CE 社区群找到我私信一下，我给你发 QQ 组织群的群号
GitHub 邀请已发