std::auto_ptr<AdblockPlus::FilterEngine> CreateFilterEngine(const std::wstring& locale) { AdblockPlus::AppInfo appInfo; appInfo.version = ToUtf8String(IEPLUGIN_VERSION); appInfo.name = "adblockplusie"; #ifdef _WIN64 appInfo.application = "msie64"; #else appInfo.application = "msie32"; #endif // TODO: Set applicationVersion parameter appInfo.locale = ToUtf8String(locale); #ifdef ADBLOCK_PLUS_TEST_MODE appInfo.developmentBuild = true; #else appInfo.developmentBuild = false; #endif AdblockPlus::JsEnginePtr jsEngine = AdblockPlus::JsEngine::New(appInfo); jsEngine->SetEventCallback("updateAvailable", &OnUpdateAvailable); std::string dataPath = ToUtf8String(GetAppDataPath()); dynamic_cast<AdblockPlus::DefaultFileSystem*>(jsEngine->GetFileSystem().get())->SetBasePath(dataPath); std::auto_ptr<AdblockPlus::FilterEngine> filterEngine(new AdblockPlus::FilterEngine(jsEngine)); return filterEngine; }
bool CAdblockPlusClient::Matches(const std::wstring& url, const std::wstring& contentType, const std::wstring& domain) { Communication::OutputBuffer request; request << Communication::PROC_MATCHES << ToUtf8String(url) << ToUtf8String(contentType) << ToUtf8String(domain); Communication::InputBuffer response; if (!CallEngine(request, response)) return false; bool match; response >> match; return match; }
static vector<char> GetBytes(astring filePath) { vector<char> bytes; #ifdef _WIN32 ifstream fin(filePath.c_str(), ios::binary | ios::in); #else ifstream fin(ToUtf8String(filePath.c_str()).c_str(), ios::binary | ios::in); #endif ACE_ASSERT(!fin.fail(), "ファイルは開けませんでした"); while (!fin.eof()) { char byte; fin.read(&byte, 1); if (!fin.eof()) { bytes.push_back(byte); } } fin.close(); return bytes; }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- Window_Imp* Window_Imp_Win::Create(int32_t width, int32_t height, const achar* title, Log* logger, bool isFullScreen) { if (!glfwInit()) { if(logger != nullptr) logger->WriteLine("ウインドウシステムの初期化に失敗"); return nullptr; } glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE); auto titleUTF8 = ToUtf8String(title); GLFWmonitor* monitor = nullptr; if (isFullScreen) { monitor = glfwGetPrimaryMonitor(); } auto window = glfwCreateWindow(width, height, titleUTF8.c_str(), monitor, NULL); if (window == nullptr) { if (logger != nullptr) logger->WriteLine("ウインドウの作成に失敗"); glfwTerminate(); return nullptr; } glfwSwapInterval(1); return new Window_Imp_Win(window, width, height, logger, isFullScreen); }
std::vector<std::wstring> CAdblockPlusClient::GetElementHidingSelectors(const std::wstring& domain) { Communication::OutputBuffer request; request << Communication::PROC_GET_ELEMHIDE_SELECTORS << ToUtf8String(domain); Communication::InputBuffer response; if (!CallEngine(request, response)) return std::vector<std::wstring>(); return ReadStrings(response); }
bool CAdblockPlusClient::IsElemhideWhitelistedOnDomain(const std::wstring& url, const std::vector<std::string>& frameHierarchy) { Communication::OutputBuffer request; request << Communication::PROC_IS_ELEMHIDE_WHITELISTED_ON_URL << ToUtf8String(url) << frameHierarchy; Communication::InputBuffer response; if (!CallEngine(request, response)) return false; bool isWhitelisted; response >> isWhitelisted; return isWhitelisted; }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- void ImageHelper::SavePNGImage(const achar* filepath, int32_t width, int32_t height, void* data, bool rev) { /* 構造体確保 */ #if _WIN32 FILE *fp = _wfopen(filepath, L"wb"); #else FILE *fp = fopen(ToUtf8String(filepath).c_str(), "wb"); #endif if (fp == nullptr) return; png_structp pp = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); png_infop ip = png_create_info_struct(pp); /* 書き込み準備 */ png_init_io(pp, fp); png_set_IHDR(pp, ip, width, height, 8, /* 8bit以外にするなら変える */ PNG_COLOR_TYPE_RGBA, /* RGBA以外にするなら変える */ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); /* ピクセル領域確保 */ std::vector<png_byte> raw1D(height * png_get_rowbytes(pp, ip)); std::vector<png_bytep> raw2D(height * sizeof(png_bytep)); for (int32_t i = 0; i < height; i++) { raw2D[i] = &raw1D[i*png_get_rowbytes(pp, ip)]; } memcpy((void*) raw1D.data(), data, width * height * 4); /* 上下反転 */ if (rev) { for (int32_t i = 0; i < height / 2; i++) { png_bytep swp = raw2D[i]; raw2D[i] = raw2D[height - i - 1]; raw2D[height - i - 1] = swp; } } /* 書き込み */ png_write_info(pp, ip); png_write_image(pp, raw2D.data()); png_write_end(pp, ip); /* 開放 */ png_destroy_write_struct(&pp, &ip); fclose(fp); }
std::shared_ptr<NativeShader_Imp> ShaderCache::CreateFromCode( const achar* key, const char* vertexShaderCode, const char* pixelShaderCode, std::vector <VertexLayout>& layout, std::vector <Macro>& macro) { NativeShader_Imp* shader = nullptr; auto it = m_shaders.find(key); if (it != m_shaders.end()) { shader = it->second; SafeAddRef(shader); } else { shader = m_graphics->CreateShader_Imp_( vertexShaderCode, ToUtf8String(key).c_str(), pixelShaderCode, ToUtf8String(key).c_str(), layout, true, macro); if (shader != nullptr) { m_shaders[key] = shader; shader->SetKey(key); } } if (shader == nullptr) return nullptr; return std::shared_ptr<NativeShader_Imp>(shader, ShaderCacheReferenceDeleter()); }
bool CAdblockPlusClient::IsWhitelistedUrl(const std::wstring& url) { DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" start").c_str()); Communication::OutputBuffer request; request << Communication::PROC_IS_WHITELISTED_URL << ToUtf8String(url); Communication::InputBuffer response; if (!CallEngine(request, response)) return false; bool isWhitelisted; response >> isWhitelisted; DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" end").c_str()); return isWhitelisted; }
std::string CAdblockPlusClient::GetWhitelistingFilter(const std::wstring& url, const std::vector<std::string>& frameHierarchy) { DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" start").c_str()); Communication::OutputBuffer request; request << Communication::PROC_GET_WHITELISTING_FITER << ToUtf8String(url) << frameHierarchy; Communication::InputBuffer response; if (!CallEngine(request, response)) return ""; std::string filterText; response >> filterText; DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" end").c_str()); return filterText; }
void Generator::GenerateFontFile( astring fontPath, astring textPath) { auto result = RenderPng(fontPath, textPath); BinaryWriter writer; PushAff(writer, result); #ifdef _WIN32 ofstream file(m_sheetName + L".aff", ios::out | ios::binary); #else ofstream file(ToUtf8String(m_sheetName.c_str()) + ".aff", ios::out | ios::binary); #endif writer.WriteOut(file); }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- time_t GraphicsResourceContainer::GetModifiedTime(const achar* path) { #if _WIN32 HANDLE file = nullptr; FILETIME time; SYSTEMTIME st; file = CreateFileW(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (file == INVALID_HANDLE_VALUE) { CloseHandle(file); return 0; } GetFileTime( file, nullptr, nullptr, &time); CloseHandle(file); LONGLONG ll; ll = ((LONGLONG) time.dwHighDateTime << 32) + time.dwLowDateTime; return (time_t) ((ll - 116444736000000000) / 10000000); #else auto p = ToUtf8String(path); struct stat stat_buf; if(stat(p.c_str(), &stat_buf) == 0 ) { return stat_buf.st_mtime; } return 0; #endif }
std::wstring CAdblockPlusClient::GetPref(const std::wstring& name, const std::wstring& defaultValue) { DEBUG_GENERAL((L"GetPref: " + name + L" start").c_str()); Communication::OutputBuffer request; request << Communication::PROC_GET_PREF << ToUtf8String(name); Communication::InputBuffer response; if (!CallEngine(request, response)) return defaultValue; bool success; response >> success; if (success) { std::string value; response >> value; DEBUG_GENERAL((L"GetPref: " + name + L" end").c_str()); return ToUtf16String(value); } else {
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- Window_Imp* Window_Imp_X11::Create(int32_t width, int32_t height, const achar* title, Log* logger, bool isFullScreen) { if (!glfwInit()) { if (logger != nullptr) logger->WriteLine("ウインドウシステムの初期化に失敗"); return nullptr; } #ifdef __APPLE__ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); #endif glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE); auto titleUTF8 = ToUtf8String(title); GLFWmonitor* monitor = nullptr; if (isFullScreen) { monitor = glfwGetPrimaryMonitor(); } auto window = glfwCreateWindow(width, height, titleUTF8.c_str(), monitor, NULL); if (window == nullptr) { if (logger != nullptr) logger->WriteLine("ウインドウの作成に失敗"); glfwTerminate(); return nullptr; } glfwSwapInterval(1); return new Window_Imp_X11(window, width, height, logger, isFullScreen); }
void MaterialPropertyBlock_Imp::AddValuesTo(NativeShader_Imp* shader, std::vector<ShaderConstantValue>& dst) { for (auto& v : GetValues()) { auto v_ = v.second; auto str = ToUtf8String(v.first.c_str()); if (v.second.ValueType == ShaderVariableType::Texture2D) { v_.ID = shader->GetTextureID(str.c_str()); } else if (v.second.ValueType == ShaderVariableType::CubemapTexture) { v_.ID = shader->GetTextureID(str.c_str()); } else { v_.ID = shader->GetConstantBufferID(str.c_str()); } dst.push_back(v_); } }
void Updater::Download() { AdblockPlus::ServerResponse response = jsEngine->GetWebRequest()->GET(url, AdblockPlus::HeaderList()); if (response.status != AdblockPlus::WebRequest::NS_OK || response.responseStatus != 200) { std::stringstream ss; ss << "Update download failed (status: " << response.status << ", "; ss << "response: " << response.responseStatus << ")"; Debug(ss.str()); return; } AdblockPlus::FileSystemPtr fileSystem = jsEngine->GetFileSystem(); std::string utfTempFile = ToUtf8String(tempFile); try { // Remove left-overs from previous update attempts fileSystem->Remove(utfTempFile); } catch (const std::exception&) { } try { std::tr1::shared_ptr<std::istream> fileData(new std::istringstream(response.responseText)); fileSystem->Write(utfTempFile, fileData); } catch (const std::exception& e) { DebugException(e); return; } OnDownloadSuccess(); }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- void Window_Imp_Win::SetTitle( const achar* title ) { auto titleUTF8 = ToUtf8String(title); glfwSetWindowTitle(m_window, titleUTF8.c_str()); }
void CAdblockPlusClient::SetPref(const std::wstring& name, bool value) { Communication::OutputBuffer request; request << Communication::PROC_SET_PREF << ToUtf8String(name) << value; CallEngine(request); }
void CAdblockPlusClient::RemoveFilter(const std::wstring& text) { RemoveFilter(ToUtf8String(text)); }
void CAdblockPlusClient::AddFilter(const std::wstring& text) { Communication::OutputBuffer request; request << Communication::PROC_ADD_FILTER << ToUtf8String(text); CallEngine(request); }
void CAdblockPlusClient::RemoveSubscription(const std::wstring& url) { Communication::OutputBuffer request; request << Communication::PROC_REMOVE_SUBSCRIPTION << ToUtf8String(url); CallEngine(request); }
void Shader3D_Imp::CompileMass() { if (mass_shaders[0] != nullptr) return; auto g = (Graphics_Imp*) graphics; std::shared_ptr<NativeShader_Imp> shaders[2]; std::shared_ptr<NativeShader_Imp> shaders_light[2]; std::shared_ptr<NativeShader_Imp> shaders_depth[2]; std::shared_ptr<NativeShader_Imp> shaders_light_depth[2]; for (int32_t i = 0; i < 2; i++) { std::vector<asd::VertexLayout> vl; vl.push_back(asd::VertexLayout("Position", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("Normal", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("Binormal", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT)); vl.push_back(asd::VertexLayout("UVSub", asd::VertexLayoutFormat::R32G32_FLOAT)); vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM)); vl.push_back(asd::VertexLayout("BoneWeights", asd::VertexLayoutFormat::R8G8B8A8_UNORM)); vl.push_back(asd::VertexLayout("BoneIndexes", asd::VertexLayoutFormat::R8G8B8A8_UINT)); //vl.push_back(asd::VertexLayout("BoneIndexesOriginal", asd::VertexLayoutFormat::R8G8B8A8_UINT)); std::vector<asd::Macro> macro; std::vector<asd::Macro> macro_light; std::vector<asd::Macro> macro_depth; std::vector<asd::Macro> macro_light_depth; macro_depth.push_back(Macro("EXPORT_DEPTH", "1")); macro_light_depth.push_back(Macro("EXPORT_DEPTH", "1")); macro_light.push_back(Macro("LIGHTWEIGHT", "1")); macro_light_depth.push_back(Macro("LIGHTWEIGHT", "1")); if (i == 1) { macro.push_back(Macro("ANIMATION_IS_ENABLED", "1")); macro_light.push_back(Macro("ANIMATION_IS_ENABLED", "1")); macro_depth.push_back(Macro("ANIMATION_IS_ENABLED", "1")); macro_light_depth.push_back(Macro("ANIMATION_IS_ENABLED", "1")); } if (g->GetGraphicsDeviceType() == GraphicsDeviceType::DirectX11) { shaders[i] = g->CreateShader_Imp( mass_model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro); shaders_light[i] = g->CreateShader_Imp( lightweight_mass_model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_light); shaders_depth[i] = g->CreateShader_Imp( mass_model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_depth); shaders_light_depth[i] = g->CreateShader_Imp( lightweight_mass_model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_light_depth); } else if (g->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL) { shaders[i] = g->CreateShader_Imp( mass_model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro); shaders_light[i] = g->CreateShader_Imp( lightweight_mass_model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_light); shaders_depth[i] = g->CreateShader_Imp( mass_model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_depth); shaders_light_depth[i] = g->CreateShader_Imp( lightweight_mass_model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_light_depth); } mass_shaders[i] = shaders[i]; mass_shaders_light[i] = shaders_light[i]; mass_shaders_depth[i] = shaders_depth[i]; mass_shaders_light_depth[i] = shaders_light_depth[i]; } }
STDMETHODIMP CPluginUserSettings::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispparams, VARIANT* pVarResult, EXCEPINFO* pExcepinfo, UINT* pArgErr) { try { if (!pDispparams) { return E_POINTER; } if (pDispparams->cNamedArgs != 0) { return DISP_E_NONAMEDARGS; } CPluginSettings* settings = CPluginSettings::GetInstance(); switch (dispidMember) { case dispatchID_GetMessage: { if (pDispparams->cArgs != 2) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_BSTR || pDispparams->rgvarg[1].vt != VT_BSTR) { return DISP_E_TYPEMISMATCH; } if (pVarResult) { CComBSTR key = pDispparams->rgvarg[0].bstrVal; CComBSTR section = pDispparams->rgvarg[1].bstrVal; Dictionary* dictionary = Dictionary::GetInstance(); std::wstring message = dictionary->Lookup( ToUtf8String(ToWstring(section)), ToUtf8String(ToWstring(key)) ); pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(message.c_str()); } } break; case dispatchID_GetLanguageCount: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { auto languageList = settings->GetFilterLanguageTitleList(); pVarResult->vt = VT_I4; pVarResult->lVal = static_cast<LONG>(languageList.size()); } } break; case dispatchID_GetLanguageByIndex: { if (pDispparams->cArgs != 1) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_I4) { return DISP_E_TYPEMISMATCH; } if (pVarResult) { int index = pDispparams->rgvarg[0].lVal; auto languageTitleList = settings->GetFilterLanguageTitleList(); if (index < 0 || index >= static_cast<int>(languageTitleList.size())) return DISP_E_BADINDEX; std::wstring language; int loopIndex = 0; for (auto it = languageTitleList.begin(); it != languageTitleList.end(); ++it) { if (loopIndex == index) { language = it->first; break; } ++loopIndex; } pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(language.c_str()); } } break; case dispatchID_GetLanguageTitleByIndex: { if (pDispparams->cArgs != 1) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_I4) { return DISP_E_TYPEMISMATCH; } if (pVarResult) { int index = pDispparams->rgvarg[0].lVal; auto languageTitleList = settings->GetFilterLanguageTitleList(); if (index < 0 || index >= static_cast<int>(languageTitleList.size())) return DISP_E_BADINDEX; std::wstring languageTitle; int loopIndex = 0; for (auto it = languageTitleList.begin(); it != languageTitleList.end(); ++it) { if (loopIndex == index) { languageTitle = it->second; break; } loopIndex++; } pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(languageTitle.c_str()); } } break; case dispatchID_SetLanguage: { if (pDispparams->cArgs != 1) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_BSTR) { return DISP_E_TYPEMISMATCH; } CComBSTR url = pDispparams->rgvarg[0].bstrVal; settings->SetSubscription((BSTR)url); } break; case dispatchID_GetLanguage: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { std::wstring url = settings->GetSubscription(); pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(url.c_str()); } } break; case dispatchID_GetWhitelistDomains: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { auto whiteListDomains = settings->GetWhiteListedDomainList(); std::wstring commaSeparatedDomains; for (size_t i = 0; i < whiteListDomains.size(); i++) { if (!commaSeparatedDomains.empty()) { commaSeparatedDomains += ','; } commaSeparatedDomains += whiteListDomains[i]; } pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(commaSeparatedDomains.c_str()); } } break; case dispatchID_AddWhitelistDomain: { if (pDispparams->cArgs != 1) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_BSTR) { return DISP_E_TYPEMISMATCH; } CComBSTR domain = pDispparams->rgvarg[0].bstrVal; if (domain.Length()) { settings->AddWhiteListedDomain((BSTR)domain); } } break; case dispatchID_RemoveWhitelistDomain: { if (pDispparams->cArgs != 1) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_BSTR) { return DISP_E_TYPEMISMATCH; } CComBSTR domain = pDispparams->rgvarg[0].bstrVal; if (domain.Length()) { settings->RemoveWhiteListedDomain(std::wstring(domain)); } } break; case dispatchID_GetAppLocale: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(GetBrowserLanguage().c_str()); } } break; case dispatchID_GetDocumentationLink: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { pVarResult->vt = VT_BSTR; pVarResult->bstrVal = SysAllocString(CPluginClient::GetInstance()->GetDocumentationLink().c_str()); } } break; case dispatchID_IsAcceptableAdsEnabled: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { pVarResult->vt = VT_BOOL; pVarResult->boolVal = CPluginClient::GetInstance()->IsAcceptableAdsEnabled() ? VARIANT_TRUE : VARIANT_FALSE; } } break; case dispatchID_SetAcceptableAdsEnabled: { if (pDispparams->cArgs != 1) { return DISP_E_BADPARAMCOUNT; } if (pDispparams->rgvarg[0].vt != VT_BOOL) { return DISP_E_TYPEMISMATCH; } if (pDispparams->rgvarg[0].boolVal != VARIANT_FALSE) { CPluginClient* client = CPluginClient::GetInstance(); client->AddSubscription(client->GetPref(L"subscriptions_exceptionsurl", L"")); } else { CPluginClient* client = CPluginClient::GetInstance(); client->RemoveSubscription(client->GetPref(L"subscriptions_exceptionsurl", L"")); } } break; case dispatchID_IsUpdate: { if (pDispparams->cArgs != 0) { return DISP_E_BADPARAMCOUNT; } if (pVarResult) { pVarResult->vt = VT_BOOL; pVarResult->boolVal = CPluginClient::GetInstance()->GetPref(L"displayUpdatePage", false) ? VARIANT_TRUE : VARIANT_FALSE; } } break; default: return DISP_E_MEMBERNOTFOUND; break; } } catch (...) { return E_FAIL; } return S_OK; }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- void GraphicsResourceContainer::Reload() { for (auto info : Texture2Ds.m_reloadInfo) { if (info.second == nullptr) continue; auto info_ = info.second.get(); auto time = GetModifiedTime(info_->Path.c_str()); if (info_->ModifiedTime == time) continue; info_->ModifiedTime = time; // リロード処理 #if _WIN32 auto fp = _wfopen(info_->Path.c_str(), L"rb"); if (fp == nullptr) continue; #else auto fp = fopen(ToUtf8String(info_->Path.c_str()).c_str(), "rb"); if (fp == nullptr) continue; #endif fseek(fp, 0, SEEK_END); auto size = ftell(fp); fseek(fp, 0, SEEK_SET); auto data = new uint8_t[size]; fread(data, 1, size, fp); fclose(fp); info.first->Reload(data, size); SafeDeleteArray(data); } for (auto info : Models.m_reloadInfo) { if (info.second == nullptr) continue; auto info_ = info.second.get(); auto time = GetModifiedTime(info_->Path.c_str()); if (info_->ModifiedTime == time) continue; info_->ModifiedTime = time; // リロード処理 #if _WIN32 auto fp = _wfopen(info_->Path.c_str(), L"rb"); if (fp == nullptr) continue; #else auto fp = fopen(ToUtf8String(info_->Path.c_str()).c_str(), "rb"); if (fp == nullptr) continue; #endif std::vector<uint8_t> data; fseek(fp, 0, SEEK_END); auto size = ftell(fp); fseek(fp, 0, SEEK_SET); data.resize(size); fread(&data[0], 1, size, fp); fclose(fp); info.first->Reload(data, info_->Path.c_str()); } }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- Shader3D_Imp* Shader3D_Imp::Create( Graphics* graphics, const achar* shaderText, const achar* shaderFileName, Log* log) { auto g = (Graphics_Imp*) graphics; std::shared_ptr<NativeShader_Imp> shader; std::shared_ptr<NativeShader_Imp> shader_light; std::shared_ptr<NativeShader_Imp> shader_depth; std::shared_ptr<NativeShader_Imp> shader_light_depth; std::vector<asd::VertexLayout> vl; vl.push_back(asd::VertexLayout("Position", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("Normal", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("Binormal", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT)); vl.push_back(asd::VertexLayout("UVSub", asd::VertexLayoutFormat::R32G32_FLOAT)); vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM)); vl.push_back(asd::VertexLayout("BoneWeights", asd::VertexLayoutFormat::R8G8B8A8_UNORM)); vl.push_back(asd::VertexLayout("BoneIndexes", asd::VertexLayoutFormat::R8G8B8A8_UINT)); vl.push_back(asd::VertexLayout("BoneIndexesOriginal", asd::VertexLayoutFormat::R8G8B8A8_UINT)); std::vector<asd::Macro> macro; std::vector<asd::Macro> macro_light; std::vector<asd::Macro> macro_depth; std::vector<asd::Macro> macro_light_depth; macro_depth.push_back(Macro("EXPORT_DEPTH", "1")); macro_light_depth.push_back(Macro("EXPORT_DEPTH", "1")); macro_light.push_back(Macro("LIGHTWEIGHT", "1")); macro_light_depth.push_back(Macro("LIGHTWEIGHT", "1")); if (g->GetGraphicsDeviceType() == GraphicsDeviceType::DirectX11) { shader = g->CreateShader_Imp( model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro); shader_light = g->CreateShader_Imp( lightweight_model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro_light); shader_depth = g->CreateShader_Imp( model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro_depth); shader_light_depth = g->CreateShader_Imp( lightweight_model_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro_light_depth); } else if (g->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL) { shader = g->CreateShader_Imp( model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro); shader_light = g->CreateShader_Imp( lightweight_model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro_light); shader_depth = g->CreateShader_Imp( model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro_depth); shader_light_depth = g->CreateShader_Imp( lightweight_model_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText).c_str(), ToUtf8String(shaderFileName).c_str(), vl, true, macro_light_depth); } else { assert(0); } if (shader == nullptr) return nullptr; return new Shader3D_Imp( g, shader, shader_light, shader_depth, shader_light_depth, shaderText, shaderFileName); }
void Shader3D_Imp::CompileTerrain() { if (terrain_shader != nullptr) return; auto g = (Graphics_Imp*) graphics; std::shared_ptr<NativeShader_Imp> shader; std::shared_ptr<NativeShader_Imp> shader_light; std::vector<asd::VertexLayout> vl; vl.push_back(asd::VertexLayout("Position", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("Normal", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("Binormal", asd::VertexLayoutFormat::R32G32B32_FLOAT)); vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT)); vl.push_back(asd::VertexLayout("UVSub", asd::VertexLayoutFormat::R32G32_FLOAT)); vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM)); //vl.push_back(asd::VertexLayout("BoneWeights", asd::VertexLayoutFormat::R8G8B8A8_UNORM)); //vl.push_back(asd::VertexLayout("BoneIndexes", asd::VertexLayoutFormat::R8G8B8A8_UINT)); //vl.push_back(asd::VertexLayout("BoneIndexesOriginal", asd::VertexLayoutFormat::R8G8B8A8_UINT)); std::vector<asd::Macro> macro; std::vector<asd::Macro> macro_light; macro_light.push_back(Macro("LIGHTWEIGHT", "1")); if (g->GetGraphicsDeviceType() == GraphicsDeviceType::DirectX11) { shader = g->CreateShader_Imp( terrain_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro); shader_light = g->CreateShader_Imp( lightweight_terrain_internal_vs_dx, "shader2d_dx_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_light); } else if (g->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL) { shader = g->CreateShader_Imp( terrain_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro); shader_light = g->CreateShader_Imp( lightweight_terrain_internal_vs_gl, "shader3d_gl_vs", ToUtf8String(shaderText.c_str()).c_str(), ToUtf8String(shaderFileName.c_str()).c_str(), vl, true, macro_light); } terrain_shader = shader; terrain_shader_light = shader_light; }