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;
}
