Main.cpp

#include <windows.h>
#include "tp_stub.h"
#include "ncbind.hpp"
#include <string>
#include <cstdio>
#include "SteamAchievements.h"

#include <steam_api.h>

// x64 縺ｮ繧､繝ｳ繝昴�繝医Λ繧､繝悶Λ繝ｪ縺ｯ steam_api64.lib縲�Make 蛛ｴ縺ｧ繧よ欠螳壹＠縺ｦ縺�ｋ縺後
// 蜊倅ｽ薙�繝ｭ繧ｸ繧ｧ繧ｯ繝医〒繝薙Ν繝峨☆繧句ｴ蜷医�縺溘ａ縺ｫ縺薙％縺ｧ繧ょ粋繧上○縺ｦ縺翫￥縲
#ifdef _MSC_VER
# ifndef STEAMAPI_LIB
#  if defined(_M_AMD64) || defined(_M_X64)
#   define STEAMAPI_LIB "steam_api64.lib"
#  else
#   define STEAMAPI_LIB "steam_api.lib"
#  endif
# endif
# pragma comment(lib,STEAMAPI_LIB)
#endif

//繝ｩ繧､繝悶Λ繝ｪ莠呈鋤縺後Ο繧ｹ繝医＠縺ｦ繧九ｈ縺�↑縺ｮ縺ｧ莉ｮ蟇ｾ遲悶�讖溯�逧�↓辟｡蜉ｹ縺九←縺�°縺ｯ荳肴�
// k_iClientVideoCallbacks 縺ｯ譁ｰ縺励＞ SDK 縺ｧ縺ｯ蜈ｬ髢九�繝�ム縺九ｉ豸医∴縺ｦ縺�ｋ縺溘ａ縲
// 蛟､ (4600) 繧堤峩謗･鄂ｮ縺上ゆｸ｡譁ｹ縺ｮ蝙九′ SDK 蛛ｴ縺ｧ螳夂ｾｩ貂医∩縺ｪ繧峨％縺ｮ荳蠑上�荳崎ｦ√

// SDK 1.60 以降は isteamvideo.h が BroadcastUpload*_t を定義済み。
// #ifndef は型名には効かない (マクロではない) ため、isteamvideo.h の
// インタフェース版数マクロの有無で「SDK 側にあるか」を判定する。
#ifndef STEAMVIDEO_INTERFACE_VERSION
#if !defined(BroadcastUploadStart_t) || !defined(BroadcastUploadStop_t)
namespace { enum { __k_iSteamVideoCallbacks = 4600 }; }
#endif

#ifndef BroadcastUploadStart_t
STEAM_CALLBACK_BEGIN(BroadcastUploadStart_t, __k_iSteamVideoCallbacks + 4)
STEAM_CALLBACK_END(0)
#endif

#ifndef BroadcastUploadStop_t
STEAM_CALLBACK_BEGIN(BroadcastUploadStop_t, __k_iSteamVideoCallbacks + 5)
STEAM_CALLBACK_MEMBER(0, EBroadcastUploadResult, m_eResult)
STEAM_CALLBACK_END(1)
#endif
#endif // STEAMVIDEO_INTERFACE_VERSION


// ttstr繧旦TF8譁�ｭ怜�縺ｸ螟画鋤
std::string
convertTtstrToUtf8String(ttstr &buf)
{
  int len = TVPWideCharToUtf8String(buf.c_str(), NULL);
  char *dat = new char[len];
  len = TVPWideCharToUtf8String(buf.c_str(), dat);
  std::string result(dat, len);
  delete[] dat;
  return result;
}

// std::string繧稚tstr縺ｫ螟画鋤
ttstr
convertUtf8StringToTtstr(const char *buf, size_t length=-1)
{
	if (length < 0) {
		length = strlen(buf);
	}
	tjs_uint len = TVPUtf8ToWideCharString(buf, NULL);
	tjs_char *dat = new tjs_char[len];
	len = TVPUtf8ToWideCharString(buf, dat);
	ttstr result(dat, len);
	delete[] dat;
	return result;
}

ttstr
convertUtf8StringToTtstr(const std::string &buf)
{
	return convertUtf8StringToTtstr(buf.c_str(), buf.length());
}

extern void initStorage();
extern void doneStorage();

class SteamScreenshotCallback;
class SteamBroadcastCallback;
class LayerImageToRGB;

/**
 * Steam諠�ｱ蝓ｺ遉弱け繝ｩ繧ｹ
 */
class Steam : public tTVPContinuousEventCallbackIntf {
public:
	// 蛻晄悄蛹 (驕�ｻｶ蛻晄悄蛹悶°繧牙他縺ｰ繧後ｋ縺ｮ縺ｧ莠碁㍾蜻ｼ縺ｳ蜃ｺ縺励↓閠舌∴繧九％縺ｨ)
	static void registerSteam() {
		if (!instance) {
			instance = new Steam();
			instance->init();
			initStorage();
		}
	}
	// 隗｣髯､
	static void unregisterSteam() {
		if (instance) {
			doneStorage();
			delete instance;
			instance = 0;
		}
	}

	// -------------------------------------------------------------------
	// 驕�ｻｶ蛻晄悄蛹
	//
	// SteamAPI_Init() 縺ｯ Steam 繧ｯ繝ｩ繧､繧｢繝ｳ繝医′蜍輔＞縺ｦ縺�↑縺�→螟ｱ謨励＠縲（nit() 縺
	// 萓句､悶ｒ謚輔￡繧九ゅ�繝ｩ繧ｰ繧､繝ｳ隱ｭ縺ｿ霎ｼ縺ｿ譎ゅ↓蛻晄悄蛹悶＠縺ｦ縺励∪縺�→縲ヾteam 辟｡縺励〒縺ｯ
	// 襍ｷ蜍輔☆繧峨〒縺阪↑縺�ゅ◎縺薙〒逋ｻ骭ｲ譎ゅ�譛ｬ迚ｩ縺ｮ Steam 繧ｯ繝ｩ繧ｹ繧貞ｷｮ縺玲崛縺医◆
	// 繝励Ο繧ｭ繧ｷ縺縺代ｒ鄂ｮ縺阪∵怙蛻昴↓ Steam.* 縺悟盾辣ｧ縺輔ｌ縺滓凾轤ｹ縺ｧ蛻晄悄蛹悶☆繧九
	//
	// RestartAppIfNecessary 縺縺代�縲郡team 邨檎罰縺ｧ襍ｷ蜍輔＠逶ｴ縺吶∋縺阪°縲阪�蛻､螳壹↑縺ｮ縺ｧ縲
	// 蛻晄悄蛹悶ｒ襍ｷ縺薙＆縺壹↓邏騾壹＠縺吶ｋ (縺薙ｌ繧貞他縺ｶ譎らせ縺ｧ縺ｯ縺ｾ縺蛻晄悄蛹悶〒縺阪↑縺)縲
	// -------------------------------------------------------------------
	class SteamDelayRegister : public tTJSDispatch {
		tTJSVariantClosure closure;
		bool terminate;
		bool PassThroughCheck(const tjs_char * membername, tjs_uint32 *hint) {
			// 蛻晄悄蛹悶ｒ襍ｷ縺薙＆縺ｪ縺�Γ繝ｳ繝 (繝｡繧ｽ繝�ラ蜷阪ｒ螟峨∴縺溘ｉ縺薙％繧ょ粋繧上○繧)
			if (membername && ttstr(membername) == TJS_W("RestartAppIfNecessary")) return true;
			if (membername && !terminate) {
				tTJSVariant v;
				if (TJS_SUCCEEDED(closure.PropGet(0, membername, hint, &v, 0))) {
					Steam::registerSteam();   // 驕�ｻｶ蛻晄悄蛹門ｮ溯｡
					SetClosure(TJS_W("Steam"), closure);
					this->Release();
					terminate = true;
				}
			}
			return false;
		}
		static bool GetClosure(const tjs_char * membername, tTJSVariantClosure &closure) {
			bool r = false;
			iTJSDispatch2 * global = TVPGetScriptDispatch();
			if (global) {
				tTJSVariant v;
				if (TJS_SUCCEEDED(global->PropGet(0, membername, 0, &v, global))) {
					closure = v.AsObjectClosure();
					r = true;
				}
				global->Release();
			}
			return r;
		}
		static bool SetClosure(const tjs_char * membername, const tTJSVariantClosure &closure) {
			bool r = false;
			iTJSDispatch2 * global = TVPGetScriptDispatch();
			if (global) {
				tTJSVariant v(closure.Object, closure.ObjThis);
				r = TJS_SUCCEEDED(global->PropSet(TJS_MEMBERENSURE|TJS_IGNOREPROP, membername, 0, &v, global));
				global->Release();
			}
			return r;
		}
	public:
		SteamDelayRegister() : closure(NULL,NULL), terminate(false) {
			GetClosure(TJS_W("Steam"), closure);
		}
		~SteamDelayRegister() {
			closure.Release();
		}
		void SetSelf() {
			SetClosure(TJS_W("Steam"), tTJSVariantClosure(this, this));
		}
		// FuncCall 縺ｨ PropGet 縺縺大ｷｮ縺玲崛縺医ｌ縺ｰ蜈･蜿｣繧呈款縺輔∴繧峨ｌ繧
		tjs_error TJS_INTF_METHOD FuncCall(tjs_uint32 flag, const tjs_char * membername, tjs_uint32 *hint, tTJSVariant *result, tjs_int numparams, tTJSVariant **param, iTJSDispatch2 *objthis) {
			PassThroughCheck(membername, hint);
			return closure.FuncCall(flag, membername, hint, result, numparams, param, objthis);
		}
		tjs_error TJS_INTF_METHOD PropGet(tjs_uint32 flag, const tjs_char * membername, tjs_uint32 *hint, tTJSVariant *result, iTJSDispatch2 *objthis) {
			PassThroughCheck(membername, hint);
			return closure.PropGet(flag, membername, hint, result, objthis);
		}
	};
	static void setupSteam() {
		SteamDelayRegister *delay = new SteamDelayRegister();   // Steam.* 蜿ら�縺ｧ閾ｪ蜍慕ｴ譽�＆繧後ｋ
		delay->SetSelf();
	}

	// Steam 繧ｯ繝ｩ繧､繧｢繝ｳ繝育ｵ檎罰縺ｧ襍ｷ蜍輔＠逶ｴ縺吝ｿ�ｦ√′縺ゅｋ縺 (蛻晄悄蛹門燕縺ｫ蜻ｼ縺ｹ繧)
	static bool RestartAppIfNecessary(tTVInteger appid) {
		return SteamAPI_RestartAppIfNecessary(static_cast<uint32>(appid));
	}

	// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ逕ｨ(蟶ｸ縺ｫ萓句､)
	static tjs_error Factory(Steam **obj, tjs_int numparams, tTJSVariant **param, iTJSDispatch2 *objthis) {
		TVPThrowExceptionMessage(TJSGetMessageMapMessage(TJS_W("TVPCannotCreateInstance")).c_str());
		return TJS_E_FAIL;
	}

	// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
	Steam() : inited(false), achieve(0), screenshot(0), broadcast(0) {}

	// 繝�せ繝医Λ繧ｯ繧ｿ
	virtual ~Steam();

	// 蛻晄悄蛹
	void init() {
		if ((inited = SteamAPI_Init())) {
			ISteamUtils *utils = SteamUtils();
			if (utils) {
				utils->SetOverlayNotificationPosition(k_EPositionTopLeft);
			}
			achieve = new SteamAchievements();
			TVPAddContinuousEventHook(this);
		} else {
			TVPThrowExceptionMessage(TJS_W("Steam must be running to play this game (SteamAPI_Init() failed)"));
		}
	}

	// ---------------------------------------------------------
	// 螳溽ｸｾ
	// ---------------------------------------------------------

	static bool requestInitialize() {
		if (instance && instance->achieve) {
			return instance->achieve->requestInitialize();
		}
		return false;
	}

	static bool getInitialized() {
		if (instance && instance->achieve) {
			return instance->achieve->getInitialized();
		}
		return false;
	}
	
	static int getAchievementsCount() {
		if (instance && instance->achieve) {
			return instance->achieve->getAchievementsCount();
		}
		return 0;
	}
	
	static tTJSVariant getAchievement(tTJSVariant n) {
		if (instance && instance->achieve) {
			return instance->achieve->getAchievement(n);
		}
		return tTJSVariant();
	}

	static bool setAchievement(tTJSVariant n) {
		if (instance && instance->achieve) {
			return instance->achieve->setAchievement(n);
		}
		return false;
	}

	static bool clearAchievement(tTJSVariant n) {
		if (instance && instance->achieve) {
			return instance->achieve->clearAchievement(n);
		}
		return false;
	}

	// ---------------------------------------------------------
	// 諠�ｱ
	// ---------------------------------------------------------
	
	// 迴ｾ蝨ｨ縺ｮ險隱槭ｒ蜿門ｾ
	static ttstr getLanguage() {
		ttstr ret;
		ISteamApps *app = SteamApps();
		if (app) {
			std::string lang = app->GetCurrentGameLanguage();
			ret = convertUtf8StringToTtstr(lang);
		}
		return ret;
	}

	// ---------------------------------------------------------
	// 繝ｦ繝ｼ繧ｶ諠�ｱ
	//
	// 繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ縺ｮ鄂ｮ縺榊ｴ謇繧偵Θ繝ｼ繧ｶ縺斐→縺ｫ蛻�￠繧狗畑騾斐ｒ諠ｳ螳壹＠縺ｦ縺�ｋ縲
	// Steam 閾ｪ霄ｫ縺ｮ userdata 繝輔か繝ｫ繝縺ｯ 32bit 縺ｮ繧｢繧ｫ繧ｦ繝ｳ繝 ID 縺ｧ蛻�°繧後ｋ縺ｮ縺ｧ縲
	// 縺昴ｌ縺ｫ蜷医ｏ縺帙ｋ縺ｪ繧 accountID 繧剃ｽｿ縺�
	// ---------------------------------------------------------

	// SteamID (64bit) 繧呈枚蟄怜�縺ｧ霑斐☆縲 譛ｪ繝ｭ繧ｰ繧､繝ｳ遲峨〒蜿悶ｌ縺ｪ縺�→縺阪�遨ｺ譁�ｭ怜�縲
	// TJS 縺ｮ謨ｴ謨ｰ縺ｯ 64bit 隨ｦ蜿ｷ莉倥″縺ｪ縺ｮ縺ｧ迴ｾ螳溘� SteamID 縺ｯ謨ｰ蛟､縺ｧ繧り｡ｨ縺帙ｋ縺後
	// 繝輔か繝ｫ繝蜷阪↑縺ｩ縺ｫ菴ｿ縺�畑騾斐ｒ閠�∴縺ｦ譁�ｭ怜�縺ｧ霑斐☆縲
	static ttstr getSteamID() {
		ISteamUser *user = SteamUser();
		if (!user) return ttstr();
		uint64 id = user->GetSteamID().ConvertToUint64();
		if (id == 0) return ttstr();
		char buf[32];
		snprintf(buf, sizeof buf, "%llu", (unsigned long long)id);
		return convertUtf8StringToTtstr(buf);
	}

	// 繧｢繧ｫ繧ｦ繝ｳ繝 ID (32bit)縲 Steam 縺ｮ userdata 繝輔か繝ｫ繝蜷阪→蜷後§蛟､縲
	// 蜿悶ｌ縺ｪ縺�→縺阪� 0縲
	static tTVInteger getAccountID() {
		ISteamUser *user = SteamUser();
		if (!user) return 0;
		return static_cast<tTVInteger>(user->GetSteamID().GetAccountID());
	}

	// Steam 縺ｫ繝ｭ繧ｰ繧､繝ｳ貂医∩縺
	static bool getLoggedOn() {
		ISteamUser *user = SteamUser();
		return user ? user->BLoggedOn() : false;
	}

	// 陦ｨ遉ｺ蜷 (繝壹Ν繧ｽ繝雁錐)縲 蜿悶ｌ縺ｪ縺�→縺阪�遨ｺ譁�ｭ怜�縲
	static ttstr getPersonaName() {
		ISteamFriends *friends = SteamFriends();
		if (!friends) return ttstr();
		const char *name = friends->GetPersonaName();
		return name ? convertUtf8StringToTtstr(name) : ttstr();
	}

	// 蜍穂ｽ應ｸｭ縺ｮ AppID縲 蜿悶ｌ縺ｪ縺�→縺阪� 0縲
	static tTVInteger getAppID() {
		ISteamUtils *utils = SteamUtils();
		return utils ? static_cast<tTVInteger>(utils->GetAppID()) : 0;
	}

	// ---------------------------------------------------------
	// 繧ｯ繝ｩ繧ｦ繝
	// ---------------------------------------------------------

	static bool getCloudEnabled() {
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			return storage->IsCloudEnabledForApp();
		}
		return false;
	}

	static void setCloudEnabled(bool enabled) {
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			storage->SetCloudEnabledForApp(enabled);
		}
	}

	static tTJSVariant getCloudQuota() {
		tTJSVariant ret;
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			uint64 total;
			uint64 available;
			if (storage->GetQuota(&total, &available)) {
				iTJSDispatch2 *dict = TJSCreateDictionaryObject();
				if (dict) {
					ncbPropAccessor obj(dict);
					obj.SetValue(TJS_W("total"), static_cast<tTVInteger>(total));
					obj.SetValue(TJS_W("available"), static_cast<tTVInteger>(available));
					ret = tTJSVariant(dict, dict);
					dict->Release();
				}
			}
		}
		return ret;
	}

	static int getCloudFileCount() {
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			return storage->GetFileCount();
		}
		return 0;
	}

	static tTJSVariant getCloudFileInfo(int n) {
		tTJSVariant ret;
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			int32 size;
			std::string name = storage->GetFileNameAndSize(n, &size);
			int64 time = storage->GetFileTimestamp(name.c_str());
			iTJSDispatch2 *dict = TJSCreateDictionaryObject();
			if (dict) {
				ncbPropAccessor obj(dict);
				obj.SetValue(TJS_W("filename"), convertUtf8StringToTtstr(name));
				obj.SetValue(TJS_W("size"), size);
				obj.SetValue(TJS_W("time"), time);
				ret = tTJSVariant(dict, dict);
				dict->Release();
			}
		}
		return ret;
	}

	static bool deleteCloudFile(ttstr name) {
		bool ret = false;
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			ttstr n = name;
			n.ToLowerCase();
			std::string filename = convertTtstrToUtf8String(n);
			ret = storage->FileDelete(filename.c_str());
		}
		return ret;
	}

	static bool copyCloudFile(ttstr src, ttstr dest) {
		bool ret = false;
		ISteamRemoteStorage *storage = SteamRemoteStorage();
		if (storage) {
			ttstr n = src;
			n.ToLowerCase();
			std::string srcfile = convertTtstrToUtf8String(n);
			n = dest;
			n.ToLowerCase();
			std::string destfile = convertTtstrToUtf8String(n);
			if (storage->FileExists(srcfile.c_str())) {
				int size = storage->GetFileSize(srcfile.c_str());
				unsigned char *buffer = new unsigned char[size];
				if (buffer) {
					if (storage->FileRead(srcfile.c_str(), buffer, size) == size) {
						if (storage->FileWrite(destfile.c_str(), buffer, size)) {
							ret = true;
						}
					}
					delete[] buffer;
				}
			}
		}
		return ret;
	}
	// ---------------------------------------------------------
	// 繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ繧ｷ繝ｧ繝�ヨ蛻ｶ蠕｡
	// ---------------------------------------------------------
	
	/**
	 * 繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ繧ｷ繝ｧ繝�ヨ蜃ｦ逅�ｒ繧｢繝励Μ蛛ｴ縺九ｉ襍ｷ蜍輔＆縺帙ｋ
	 */
	static void triggerScreenshot() {
		ISteamScreenshots *shots = SteamScreenshots();
		if (shots) {
			shots->TriggerScreenshot();
		}
	}

	/**
	 * @param callback 繧偵ヵ繝�け縺吶ｋ繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ髢｢謨ｰ(void縺ｪ繧蛾幕謾ｾ)
	 * @return 逋ｻ骭ｲ繝ｻ隗｣髯､縺ｫ謌仙粥縺励◆繧液rue
	 */
	static bool hookScreenshots(tTJSVariant callback) {
		if (instance) {
			return instance->_hookScreenshots(callback);
		}
		return false;
	}
	
	/**
	 * 繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ繧ｷ繝ｧ繝�ヨ縺ｮ逋ｻ骭ｲ
	 * @param layer 逕ｻ蜒
	 * @param location 蝣ｴ謇譁�ｭ怜�
	 */
	static void writeScreenshot(iTJSDispatch2 *layer, ttstr location) {
		if (instance) {
			instance->_writeScreenshot(layer, location);
		}
	}

	// ---------------------------------------------------------
	// 繝悶Ο繝ｼ繝峨く繝｣繧ｹ繝亥宛蠕｡
	// ---------------------------------------------------------
	
	static bool isBroadcasting() {
		int numViewers = 0;
		ISteamVideo *video = SteamVideo();
		return video && video->IsBroadcasting(&numViewers);
	}

	static bool hookBroadcasting(tTJSVariant callback) {
		if (instance) {
			return instance->_hookBroadcasting(callback);
		}
		return false;
	}

	// ---------------------------------------------------------
	// DLC諠�ｱ
	// ---------------------------------------------------------


	// only use this member if you need to check ownership of another game related to yours, a demo for example
	static bool isIsSubscribedApp(uint32 appID) {
		bool ret = false;
		ISteamApps *app = SteamApps();
		if (app) {
			ret = app->BIsSubscribedApp( (AppId_t)appID );
		}
		return ret;
	}

	// Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed
	static bool isDlcInstalled(uint32 appID) {
		bool ret = false;
		ISteamApps *app = SteamApps();
		if (app) {
			ret = app->BIsDlcInstalled( (AppId_t)appID );
		}
		return ret;
	}

	/**
	 * @return DLC縺ｮ蛟区焚繧定ｿ斐☆
	 */
	static int getDLCCount() {
		int ret = 0;
		ISteamApps *app = SteamApps();
		if (app) {
			ret = app->GetDLCCount();
		}
		return ret;
	}

	/**
	 * @param no DLC縺ｮ逡ｪ蜿ｷ 
	 * @rerurn DLC諠�ｱ
	      appID
		  aAvailable
		  chName
	 * 
	 */
	static tTJSVariant getDLCData(int no) {
		tTJSVariant ret;
		ISteamApps *app = SteamApps();
		if (app) {
			AppId_t appId;
			bool available;
			char chName[4096];
			if (app->BGetDLCDataByIndex(no, &appId, &available, chName, sizeof chName-1)) {
				ttstr name = convertUtf8StringToTtstr(chName);
				iTJSDispatch2 *dict = TJSCreateDictionaryObject();
				if (dict) {
					ncbPropAccessor obj(dict);
					obj.SetValue(TJS_W("appId"), appId);
					obj.SetValue(TJS_W("available"), available);
					obj.SetValue(TJS_W("chName"), name);
					ret = tTJSVariant(dict, dict);
					dict->Release();
				}
			}
		}
		return ret;
	}

public:
	virtual void TJS_INTF_METHOD OnContinuousCallback(tjs_uint64 tick) {
		SteamAPI_RunCallbacks();
	}

protected:
	static Steam *instance;

	bool _hookScreenshots(tTJSVariant callback);
	bool _hookBroadcasting(tTJSVariant callback);
	void _writeScreenshot(iTJSDispatch2 *layer, ttstr location);
	
	bool inited;
	SteamAchievements *achieve;
	SteamScreenshotCallback *screenshot;
	SteamBroadcastCallback  *broadcast;

};


/**
 * SteamCallback繧ｯ繝ｩ繧ｹ
 */
class SteamCallback : public tTJSVariantClosure {
public:
	SteamCallback() : tTJSVariantClosure(NULL, NULL) {}
	virtual ~SteamCallback() { Release(); }
	bool setCallback(tTJSVariant const &var) {
		if (var.Type() == tvtObject) {
			tTJSVariantClosure closure(var.AsObjectClosureNoAddRef());
			Object  = closure.Object;
			ObjThis = closure.ObjThis;
			AddRef();
		} else {
			Object  = NULL;
			ObjThis = NULL;
		}
		return Object != NULL;
	}
	bool invokeCallback(tjs_uint numparams , tTJSVariant * * params) const {
		tTJSVariant result;
		return Object && Try_iTJSDispatch2_FuncCall(Object, 0, NULL, NULL, &result, numparams, params, ObjThis) == TJS_S_OK;
	}
private:
	tTJSVariantClosure callback;
};

/**
 * SteamScreenshotCallback繧ｯ繝ｩ繧ｹ
 */
class SteamScreenshotCallback : public SteamCallback {
public:
	SteamScreenshotCallback() : SteamCallback()
		,m_CallbackScreenshotRequested(this, &SteamScreenshotCallback::OnScreenShotRequested)
//		,m_CallbackScreenshotReady(this, &SteamScreenshotCallback::OnScreenShotReady)
	{
	}
	STEAM_CALLBACK(SteamScreenshotCallback, OnScreenShotRequested, ScreenshotRequested_t, m_CallbackScreenshotRequested);
//	STEAM_CALLBACK(SteamScreenshotCallback, OnScreenShotReady, ScreenshotReady_t, m_CallbackScreenshotReady);
};
void
SteamScreenshotCallback::OnScreenShotRequested(ScreenshotRequested_t *pCallback)
{
	// 諱舌ｉ縺輯teamAPI_RunCallbacks() 縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｧ蜻ｼ縺ｰ繧後ｋ縺ｨ諤昴ｏ繧後ｋ
	invokeCallback(0, NULL);

	// FuncCall 縺ｧ縺ｪ縺上※ TVPPostEvent 縺ｪ繧薙◆繧峨�縺後ｈ縺九▲縺溘°繧
	//::TVPPostEvent(source, target, TJS_W("onSteamScreenShotRequested"), 0, TVP_EPT_EXCLUSIVE, numargs, args);
}
/*
// 繧ｹ繧ｯ繝ｪ繝ｼ繝ｳ繧ｷ繝ｧ繝�ヨ繧呈聴縺｣縺溷ｾ後↓蜻ｼ縺ｰ繧後ｋ�滂ｼ医ち繧ｰ莉倥￠繧�ocation繧定ｨｭ螳壹☆繧句ｴ蜷医↑縺ｩ�
void
SteamScreenshotCallback::OnScreenShotReady(ScreenshotReady_t *pCallback)
{
	ISteamScreenshots *shots = SteamScreenshots();
	if (shots) {
		ScreenshotHandle hScreenshot = pCallback->m_hLocal;

		//shorts->SetLocation(hScreenshot, pchLocation);
		//shorts->TagPublishedFile(hScreenshot, unPublishedFileID);
	}
}
 */


/**
 * SteamBroadcastCallback繧ｯ繝ｩ繧ｹ
 */
class SteamBroadcastCallback : public SteamCallback {
public:
	SteamBroadcastCallback() : SteamCallback()
		,m_CallbackBroadcastStart(this, &SteamBroadcastCallback::OnBroadcastStart)
		,m_CallbackBroadcastStop(this, &SteamBroadcastCallback::OnBroadcastStop)
	{
	}
	STEAM_CALLBACK(SteamBroadcastCallback, OnBroadcastStart, BroadcastUploadStart_t, m_CallbackBroadcastStart);
	STEAM_CALLBACK(SteamBroadcastCallback, OnBroadcastStop, BroadcastUploadStop_t, m_CallbackBroadcastStop);
};
void
SteamBroadcastCallback::OnBroadcastStart(BroadcastUploadStart_t *pCallback)
{
	tTJSVariant state(1), *args = &state;
	invokeCallback(1, &args);
}
void
SteamBroadcastCallback::OnBroadcastStop(BroadcastUploadStop_t *pCallback)
{
	tTJSVariant state(0), *args = &state;
	invokeCallback(1, &args);
}


class    LayerImageToRGB {
public:
	/**/ LayerImageToRGB() : buffer(0), size(0), width(0), height(0) {}
	/**/~LayerImageToRGB() { term(); }

	void init(iTJSDispatch2 *lay) {
		term();
		if (!lay) return;

		const BYTE *ptr;
		long pitch;
		if (!GetLayerSize(lay, width, height) ||
			!GetLayerImage(lay, ptr, pitch)) return;

		size = width * height * 3;
		buffer = new BYTE[size];

		BYTE *w = buffer;
		for (size_t y = 0; y < height; y++) {
			const BYTE* r = ptr + pitch * y;
			for (size_t x = 0; x < width; x++, r+=4) {
				*w++ = r[2];
				*w++ = r[1];
				*w++ = r[0];
			}
		}
	}

	void term() {
		if (buffer) delete[] buffer;
		buffer = 0;
		size = width = height = 0;
	}

	inline void  *getRGB()   const { return buffer; }
	inline uint32 getSize()  const { return size;   }
	inline int   getWidth()  const { return width;  }
	inline int   getHeight() const { return height; }

private:
	BYTE *buffer;
	size_t size, width, height;

	static iTJSDispatch2 *LayerClass;
	static bool GetLayerSize(iTJSDispatch2 *lay, size_t &w, size_t &h) {
		static ttstr hasImage   (TJS_W("hasImage"));
		static ttstr imageWidth (TJS_W("imageWidth"));
		static ttstr imageHeight(TJS_W("imageHeight"));

		tTVInteger lw, lh;
		if (!LayerPropGet(lay, hasImage) ||
			(lw = LayerPropGet(lay, imageWidth )) <= 0 ||
			(lh = LayerPropGet(lay, imageHeight)) <= 0) return false;
		w = (size_t)lw;
		h = (size_t)lh;
		return true;
	}
	static bool GetLayerImage(iTJSDispatch2 *lay, const BYTE* &ptr, long &pitch) {
		static ttstr mainImageBufferPitch(TJS_W("mainImageBufferPitch"));
		static ttstr mainImageBuffer(TJS_W("mainImageBuffer"));

		tTVInteger lpitch, lptr;
		if ((lpitch = LayerPropGet(lay, mainImageBufferPitch)) == 0 ||
			(lptr   = LayerPropGet(lay, mainImageBuffer)) == 0) return false;
		pitch = (long)lpitch;
		ptr = reinterpret_cast<const BYTE*>(lptr);
		return true;
	}
	static tTVInteger LayerPropGet(iTJSDispatch2 *lay, ttstr &prop, tTVInteger defval = 0) {
		if (!LayerClass) {
			tTJSVariant var;
			TVPExecuteExpression(TJS_W("Layer"), &var);
			LayerClass = var.AsObjectNoAddRef();
		}
		tTJSVariant val;
		return (TJS_FAILED(LayerClass->PropGet(0, prop.c_str(), prop.GetHint(), &val, lay))) ? defval : val.AsInteger();
	}
};
iTJSDispatch2 *LayerImageToRGB::LayerClass = 0;

// ---------------------------------------------------------
// 螳溯｣

Steam::~Steam() {
	if (achieve) {
		delete achieve;
		achieve = 0;
	}
	if (screenshot) {
		delete screenshot;
		screenshot = 0;
	}
	if (broadcast) {
		delete broadcast;
		broadcast = 0;
	}
	if (inited){
		TVPRemoveContinuousEventHook(this);
		SteamAPI_Shutdown();
	}
}
bool Steam::_hookScreenshots(tTJSVariant callback) {
	ISteamScreenshots *shots = SteamScreenshots();
	if (shots) {
		if(!screenshot) {
			screenshot = new SteamScreenshotCallback();
		}
		if (screenshot) {
			bool bHook = screenshot->setCallback(callback);
			shots->HookScreenshots(bHook);
			return true;
		}
	}
	return false;
}

bool Steam::_hookBroadcasting(tTJSVariant callback) {
	if(!broadcast) {
		broadcast = new SteamBroadcastCallback();
	}
	if (broadcast) {
		broadcast->setCallback(callback);
		return true;
	}
	return false;
}

void Steam::_writeScreenshot(iTJSDispatch2 *layer, ttstr location) {
	if (!layer) return;
	ISteamScreenshots *shots = SteamScreenshots();
	if (shots) {
		LayerImageToRGB *image = new LayerImageToRGB();
		try {
			image->init(layer);
			ScreenshotHandle handle = shots->WriteScreenshot(image->getRGB(), image->getSize(), image->getWidth(), image->getHeight());
			if (!location.IsEmpty()) {
				std::string text = convertTtstrToUtf8String(location);
				shots->SetLocation(handle, text.c_str());
			}
		} catch (...) {
			delete image;
			throw;
		}
		delete image;
	}
}




Steam *Steam::instance = 0;

NCB_REGISTER_CLASS(Steam) {
	Factory(&Class::Factory);
	NCB_METHOD(getLanguage);

	// Steam 譛ｪ蛻晄悄蛹悶〒繧ょ他縺ｹ繧 (驕�ｻｶ蛻晄悄蛹悶ｒ襍ｷ縺薙＆縺ｪ縺)縲
	// 窶ｻ繝｡繝ｳ繝仙錐繧貞､峨∴縺溘ｉ SteamDelayRegister::PassThroughCheck 繧ら峩縺吶％縺ｨ
	NCB_METHOD(RestartAppIfNecessary);

	// 繝ｦ繝ｼ繧ｶ諠�ｱ (繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ縺ｮ鄂ｮ縺榊ｴ謇繧偵Θ繝ｼ繧ｶ縺斐→縺ｫ蛻�￠繧狗畑騾)
	NCB_PROPERTY_RO(steamID, getSteamID);
	NCB_PROPERTY_RO(accountID, getAccountID);
	NCB_PROPERTY_RO(loggedOn, getLoggedOn);
	NCB_PROPERTY_RO(personaName, getPersonaName);
	NCB_PROPERTY_RO(appID, getAppID);

	NCB_METHOD(requestInitialize);
	NCB_PROPERTY_RO(initialized, getInitialized);
	NCB_PROPERTY_RO(achievementsCount, getAchievementsCount);
	NCB_METHOD(getAchievement);
	NCB_METHOD(setAchievement);
	NCB_METHOD(clearAchievement);

	NCB_PROPERTY(cloudEnabled, getCloudEnabled, setCloudEnabled);
	NCB_METHOD(getCloudQuota);
	NCB_PROPERTY_RO(cloudFileCount, getCloudFileCount);
	NCB_METHOD(getCloudFileInfo);
	NCB_METHOD(deleteCloudFile);
	NCB_METHOD(copyCloudFile);

	NCB_METHOD(triggerScreenshot);
	NCB_METHOD(hookScreenshots);
	NCB_METHOD(writeScreenshot);

	NCB_METHOD(isBroadcasting);
	NCB_METHOD(hookBroadcasting);

	NCB_METHOD(isIsSubscribedApp);
	NCB_METHOD(isDlcInstalled);
	NCB_METHOD(getDLCCount);
	NCB_METHOD(getDLCData);
}

// 隱ｭ縺ｿ霎ｼ縺ｿ譎ゅ↓ SteamAPI_Init() 縺ｾ縺ｧ貂医∪縺帙※縺励∪縺�→縲ヾteam 繧ｯ繝ｩ繧､繧｢繝ｳ繝医′
// 蜍輔＞縺ｦ縺�↑縺�腸蠅�〒縺ｯ繝励Λ繧ｰ繧､繝ｳ繧貞�繧後◆譎らせ縺ｧ襍ｷ蜍輔〒縺阪↑縺上↑繧九
// 逋ｻ骭ｲ逶ｴ蠕後�繝励Ο繧ｭ繧ｷ縺縺醍ｽｮ縺阪∵怙蛻昴↓ Steam.* 縺悟盾辣ｧ縺輔ｌ縺滓凾轤ｹ縺ｧ蛻晄悄蛹悶☆繧九
NCB_REGISTER_CALLBACK(PostRegist, Steam::setupSteam, 0, 0_setupSteam);
NCB_REGISTER_CALLBACK(PostRegist, 0, Steam::unregisterSteam, 0_unregisterSteam);