native-m

#include <iostream>
#include <stack>
#include <array>
#include <algorithm>
#include <random>
#include <memory>
#include <SDL.h>

#undef main

native-m

#include <functional>

template<typename T>
class Property
{
public:
    using GetterFn = T&();
    using SetterFn = void(const T&);

    template<typename Getter, typename Setter>

native-m

#include <thread>
#include <vector>
#include <functional>
#include <condition_variable>
#include <queue>
#include <utility>

class ThreadPool
{
public:

native-m

#include <iostream>

using Hx::ECS::ECSContext;
using Hx::ECS::EntityManager;
using Hx::ECS::Entity;
using Hx::ECS::World;
using Hx::ECS::System;
using Hx::Components::Position2D;
using Hx::Components::Direction2D;
using Hx::Components::Sprite2D;

native-m

#include <Hx.hpp>
#include <iostream>

using Hx::App::Application;
using Hx::App::Game;
using Hx::Entity::Entity;
using Hx::Entity::EntityManager;
using Hx::Entity::PlayerSystem;
using Hx::Math::Vec2;

native-m

void
UpdateShadowMatrix()
{
	DirectX::XMMATRIX camInv;
	DirectX::XMMATRIX shadowView;
	RwCamera* rwcam = Scene.camera;
	float minDist = RwCameraGetNearClipPlane(rwcam);
	float maxDist = RwCameraGetFarClipPlane(rwcam);
	CVector sunPos;
	CVector camPos;

native-m

float rand(vec2 p)
{
    float t = floor(iTime * 20.) / 10.; // limit glitch FPS
    //t = exp(t);
    return fract(sin(dot(p, vec2(t * 12.9898, t * 78.233))) * 43758.5453);
}

float noise(vec2 uv, float blockiness)
{   
    vec2 lv = fract(uv);

native-m

# JPEG Emulator
# licensed under GPLv2 license
#
# What this thing does?
# It emulates jpeg DCT algorithm
#
# Python 3 is required to run this code
#
# HOW TO USE:
# 1. install numpy, scipy, and Pillow package

native-m

union IEEEFloat
{
	struct
	{
		int m : 23;
		int e : 8;
		int s : 1;
	};

	int i;

native-m

#include <Windows.h>
#include <d3d11.h>
#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <d3dcompiler.h>

#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3d11.lib")