moved nativeapi

source/funkin/utils/native/HiddenProcess.hx

@@ -0,0 +1,121 @@
+package funkin.utils.native;
+
+#if cpp
+/*
+* Copyright (C)2005-2019 Haxe Foundation
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+
+import cpp.NativeProcess;
+
+private class Stdin extends haxe.io.Output {
+	var p:Dynamic;
+	var buf:haxe.io.Bytes;
+
+	public function new(p:Dynamic) {
+		this.p = p;
+		buf = haxe.io.Bytes.alloc(1);
+	}
+
+	public override function close() {
+		super.close();
+		NativeProcess.process_stdin_close(p);
+	}
+
+	public override function writeByte(c) {
+		buf.set(0, c);
+		writeBytes(buf, 0, 1);
+	}
+
+	public override function writeBytes(buf:haxe.io.Bytes, pos:Int, len:Int):Int {
+		try {
+			return NativeProcess.process_stdin_write(p, buf.getData(), pos, len);
+		} catch (e:Dynamic) {
+			throw new haxe.io.Eof();
+		}
+		return 0;
+	}
+}
+
+private class Stdout extends haxe.io.Input {
+	var p:Dynamic;
+	var out:Bool;
+	var buf:haxe.io.Bytes;
+
+	public function new(p:Dynamic, out) {
+		this.p = p;
+		this.out = out;
+		buf = haxe.io.Bytes.alloc(1);
+	}
+
+	public override function readByte() {
+		if (readBytes(buf, 0, 1) == 0)
+			throw haxe.io.Error.Blocked;
+		return buf.get(0);
+	}
+
+	public override function readBytes(str:haxe.io.Bytes, pos:Int, len:Int):Int {
+		var result:Int;
+		try {
+			result = out ? NativeProcess.process_stdout_read(p, str.getData(), pos, len) : NativeProcess.process_stderr_read(p, str.getData(), pos, len);
+		} catch (e:Dynamic) {
+			throw new haxe.io.Eof();
+		}
+		if (result == 0)
+			throw new haxe.io.Eof();
+		return result;
+	}
+}
+
+class HiddenProcess {
+	var p:Dynamic;
+
+	public var stdout(default, null):haxe.io.Input;
+	public var stderr(default, null):haxe.io.Input;
+	public var stdin(default, null):haxe.io.Output;
+
+	public function new(cmd:String, ?args:Array<String>, ?detached:Bool):Void {
+		if (detached)
+			throw "Detached process is not supported on this platform";
+		p = try NativeProcess.process_run_with_show(cmd, args, 0) catch (e:Dynamic) throw "Process creation failure : " + cmd;
+		stdin = new Stdin(p);
+		stdout = new Stdout(p, true);
+		stderr = new Stdout(p, false);
+	}
+
+	public function getPid():Int {
+		return NativeProcess.process_pid(p);
+	}
+
+	public function exitCode(block:Bool = true):Null<Int> {
+		return NativeProcess.process_exit(p);
+	}
+
+	public function close():Void {
+		NativeProcess.process_close(p);
+	}
+
+	public function kill():Void {
+		NativeProcess.process_kill(p);
+	}
+}
+#else
+typedef HiddenProcess = sys.io.Process;
+#end

source/funkin/utils/native/Linux.hx

@@ -0,0 +1,31 @@
+package funkin.utils.native;
+
+#if linux
+@:cppFileCode("#include <stdio.h>")
+class Linux {
+	@:functionCode('
+		FILE *meminfo = fopen("/proc/meminfo", "r");
+
+		if(meminfo == NULL)
+			return -1;
+
+		char line[256];
+		while(fgets(line, sizeof(line), meminfo))
+		{
+			int ram;
+			if(sscanf(line, "MemTotal: %d kB", &ram) == 1)
+			{
+				fclose(meminfo);
+				return (ram / 1024);
+			}
+		}
+
+		fclose(meminfo);
+		return -1;
+	')
+	public static function getTotalRam():Float
+	{
+		return 0;
+	}
+}
+#end

source/funkin/utils/native/Mac.hx

@@ -0,0 +1,21 @@
+package funkin.utils.native;
+
+#if mac
+@:cppFileCode("#include <sys/sysctl.h>")
+class Mac {
+	@:functionCode('
+	int mib [] = { CTL_HW, HW_MEMSIZE };
+	int64_t value = 0;
+	size_t length = sizeof(value);
+
+	if(-1 == sysctl(mib, 2, &value, &length, NULL, 0))
+		return -1; // An error occurred
+
+	return value / 1024 / 1024;
+	')
+	public static function getTotalRam():Float
+	{
+		return 0;
+	}
+}
+#end

source/funkin/utils/native/Windows.hx

@@ -0,0 +1,193 @@
+package funkin.utils.native;
+
+import funkin.utils.NativeAPI.MessageBoxIcon;
+#if windows
+@:buildXml('
+<target id="haxe">
+	<lib name="dwmapi.lib" if="windows" />
+	<lib name="shell32.lib" if="windows" />
+	<lib name="gdi32.lib" if="windows" />
+	<lib name="ole32.lib" if="windows" />
+	<lib name="uxtheme.lib" if="windows" />
+</target>
+')
+
+// majority is taken from microsofts doc 
+@:cppFileCode('
+#include "mmdeviceapi.h"
+#include "combaseapi.h"
+#include <iostream>
+#include <Windows.h>
+#include <cstdio>
+#include <tchar.h>
+#include <dwmapi.h>
+#include <winuser.h>
+#include <Shlobj.h>
+#include <wingdi.h>
+#include <shellapi.h>
+#include <uxtheme.h>
+
+#define SAFE_RELEASE(punk)  \\
+			  if ((punk) != NULL)  \\
+				{ (punk)->Release(); (punk) = NULL; }
+
+static long lastDefId = 0;
+
+class AudioFixClient : public IMMNotificationClient {
+	LONG _cRef;
+	IMMDeviceEnumerator *_pEnumerator;
+	
+	public:
+	AudioFixClient() :
+		_cRef(1),
+		_pEnumerator(NULL)
+	{
+		HRESULT result = CoCreateInstance(__uuidof(MMDeviceEnumerator),
+							  NULL, CLSCTX_INPROC_SERVER,
+							  __uuidof(IMMDeviceEnumerator),
+							  (void**)&_pEnumerator);
+		if (result == S_OK) {
+			_pEnumerator->RegisterEndpointNotificationCallback(this);
+		}
+	}
+
+	~AudioFixClient()
+	{
+		SAFE_RELEASE(_pEnumerator);
+	}
+
+	ULONG STDMETHODCALLTYPE AddRef()
+	{
+		return InterlockedIncrement(&_cRef);
+	}
+
+	ULONG STDMETHODCALLTYPE Release()
+	{
+		ULONG ulRef = InterlockedDecrement(&_cRef);
+		if (0 == ulRef)
+		{
+			delete this;
+		}
+		return ulRef;
+	}
+
+	HRESULT STDMETHODCALLTYPE QueryInterface(
+								REFIID riid, VOID **ppvInterface)
+	{
+		return S_OK;
+	}
+
+	HRESULT STDMETHODCALLTYPE OnDeviceAdded(LPCWSTR pwstrDeviceId)
+	{
+		return S_OK;
+	};
+
+	HRESULT STDMETHODCALLTYPE OnDeviceRemoved(LPCWSTR pwstrDeviceId)
+	{
+		return S_OK;
+	}
+
+	HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(
+								LPCWSTR pwstrDeviceId,
+								DWORD dwNewState)
+	{
+		return S_OK;
+	}
+
+	HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(
+								LPCWSTR pwstrDeviceId,
+								const PROPERTYKEY key)
+	{
+		return S_OK;
+	}
+
+	HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(
+		EDataFlow flow, ERole role,
+		LPCWSTR pwstrDeviceId)
+	{
+		::funkin::_hx_system::Main_obj::audioDisconnected = true;
+		return S_OK;
+	};
+};
+
+AudioFixClient *curAudioFix;
+')
+@:dox(hide)
+class Windows {
+
+	public static var __audioChangeCallback:Void->Void = function() {
+		trace("test");
+	};
+
+
+	@:functionCode('
+	if (!curAudioFix) curAudioFix = new AudioFixClient();
+	')
+	public static function registerAudio() {
+		funkin.system.Main.audioDisconnected = false;
+	}
+
+	@:functionCode('
+		int darkMode = enable ? 1 : 0;
+		HWND window = GetActiveWindow();
+		if (S_OK != DwmSetWindowAttribute(window, 19, &darkMode, sizeof(darkMode))) {
+			DwmSetWindowAttribute(window, 20, &darkMode, sizeof(darkMode));
+		}
+	')
+	public static function setDarkMode(enable:Bool) {}
+
+	@:functionCode('
+	// https://stackoverflow.com/questions/15543571/allocconsole-not-displaying-cout
+
+	if (!AllocConsole())
+		return;
+
+	freopen("CONIN$", "r", stdin);
+	freopen("CONOUT$", "w", stdout);
+	freopen("CONOUT$", "w", stderr);
+	')
+	public static function allocConsole() {
+	}
+
+	
+	@:functionCode('
+		HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE); 
+		SetConsoleTextAttribute(console, color);
+	')
+	public static function setConsoleColors(color:Int) {
+
+	}
+
+	@:functionCode('
+		system("CLS");
+		std::cout<< "" <<std::flush;
+	')
+	public static function clearScreen() {
+
+	}
+
+
+	@:functionCode('
+		MessageBox(GetActiveWindow(), message, caption, icon | MB_SETFOREGROUND);
+	')
+	public static function showMessageBox(caption:String, message:String, icon:MessageBoxIcon = MSG_WARNING) {
+		
+	}
+
+	@:functionCode('
+		SetProcessDPIAware();
+	')
+	public static function registerAsDPICompatible() {}
+
+	@:functionCode("
+		// simple but effective code
+		unsigned long long allocatedRAM = 0;
+		GetPhysicallyInstalledSystemMemory(&allocatedRAM);
+		return (allocatedRAM / 1024);
+	")
+	public static function getTotalRam():Float
+	{
+		return 0;
+	}
+}
+#end