bool Context::RequireSDL(unsigned int sdlFlags)
{
// Always increment, the caller must match with ReleaseSDL(), regardless of
// what happens.
++sdlInitCounter;
// Need to call SDL_Init() at least once before SDL_InitSubsystem()
if (sdlInitCounter == 1)
{
ATOMIC_LOGDEBUG("Initialising SDL");
if (SDL_Init(0) != 0)
{
ATOMIC_LOGERRORF("Failed to initialise SDL: %s", SDL_GetError());
return false;
}
}
Uint32 remainingFlags = sdlFlags & ~SDL_WasInit(0);
if (remainingFlags != 0)
{
if (SDL_InitSubSystem(remainingFlags) != 0)
{
ATOMIC_LOGERRORF("Failed to initialise SDL subsystem: %s", SDL_GetError());
return false;
}
}
return true;
}
int LicenseSystem::ParseResponse(const String& response, LicenseParse& parse)
{
ATOMIC_LOGINFOF("%s", response.CString());
if (response.StartsWith("AC_ACTIVATIONSEXCEEDED"))
{
return 1;
}
if (response.StartsWith("AC_IDNOTACTIVATED"))
{
return 4;
}
if (response.StartsWith("AC_FAILED"))
{
return 2;
}
if (!response.StartsWith("WINDOWS"))
{
ATOMIC_LOGERRORF("Error Parsing Server Response %s", response.CString());
return 3;
}
String codes = response;
codes.Replace("\n", "");
codes.Replace("\r", "");
Vector<String> cvector = codes.Split(' ');
for (unsigned i = 0; i < cvector.Size(); i++)
{
Vector<String> feature = cvector[i].Split('=');
if (feature.Size() != 2)
continue;
if (feature[0] == "WINDOWS")
parse.licenseWindows_ = !feature[1].StartsWith("0");
else if (feature[0] == "MAC")
parse.licenseMac_ = !feature[1].StartsWith("0");
else if (feature[0] == "ANDROID")
parse.licenseAndroid_ = !feature[1].StartsWith("0");
else if (feature[0] == "IOS")
parse.licenseIOS_ = !feature[1].StartsWith("0");
else if (feature[0] == "HTML5")
parse.licenseHTML5_ = !feature[1].StartsWith("0");
else if (feature[0] == "THREED")
parse.licenseModule3D_ = !feature[1].StartsWith("0");
}
return 0;
}
bool AEEditorPrefs::SavePreferences(JSONValue& prefs)
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String path = GetPreferencesPath();
SharedPtr<File> file(new File(context_, path, FILE_WRITE));
SharedPtr<JSONFile> jsonFile(new JSONFile(context_));
jsonFile->GetRoot() = prefs;
if (!file->IsOpen())
{
ATOMIC_LOGERRORF("Unable to open Atomic Editor preferences for writing: %s", path.CString());
return false;
}
jsonFile->Save(*file, " ");
file->Close();
return true;
}
void PlatformAndroid::RefreshAndroidTargets()
{
if (refreshAndroidTargetsProcess_.NotNull())
return;
ToolPrefs* prefs = GetSubsystem<ToolEnvironment>()->GetToolPrefs();
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String androidSDKPath = prefs->GetAndroidSDKPath();
if (!fileSystem->DirExists(androidSDKPath))
{
ATOMIC_LOGERRORF("The Android SDK path %s does not exist", androidSDKPath.CString());
return;
}
SubprocessSystem* subs = GetSubsystem<SubprocessSystem>();
String androidCommand = GetAndroidCommand();
Vector<String> args;
PrependAndroidCommandArgs(args);
args.Push("list");
args.Push("targets");
targetOutput_.Clear();
refreshAndroidTargetsProcess_ = subs->Launch(androidCommand, args);
if (refreshAndroidTargetsProcess_.NotNull())
{
SubscribeToEvent(refreshAndroidTargetsProcess_, E_SUBPROCESSCOMPLETE, ATOMIC_HANDLER(PlatformAndroid, HandleRefreshAndroidTargetsEvent));
SubscribeToEvent(refreshAndroidTargetsProcess_, E_SUBPROCESSOUTPUT, ATOMIC_HANDLER(PlatformAndroid, HandleRefreshAndroidTargetsEvent));
}
}
VertexDeclaration::VertexDeclaration(Graphics* graphics, ShaderVariation* vertexShader, VertexBuffer** vertexBuffers) :
inputLayout_(0)
{
PODVector<D3D11_INPUT_ELEMENT_DESC> elementDescs;
unsigned prevBufferDescs = 0;
for (unsigned i = 0; i < MAX_VERTEX_STREAMS; ++i)
{
if (!vertexBuffers[i])
continue;
const PODVector<VertexElement>& srcElements = vertexBuffers[i]->GetElements();
bool isExisting = false;
for (unsigned j = 0; j < srcElements.Size(); ++j)
{
const VertexElement& srcElement = srcElements[j];
const char* semanticName = ShaderVariation::elementSemanticNames[srcElement.semantic_];
// Override existing element if necessary
for (unsigned k = 0; k < prevBufferDescs; ++k)
{
if (elementDescs[k].SemanticName == semanticName && elementDescs[k].SemanticIndex == srcElement.index_)
{
isExisting = true;
elementDescs[k].InputSlot = i;
elementDescs[k].AlignedByteOffset = srcElement.offset_;
elementDescs[k].InputSlotClass = srcElement.perInstance_ ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA;
elementDescs[k].InstanceDataStepRate = srcElement.perInstance_ ? 1 : 0;
break;
}
}
if (isExisting)
continue;
D3D11_INPUT_ELEMENT_DESC newDesc;
newDesc.SemanticName = semanticName;
newDesc.SemanticIndex = srcElement.index_;
newDesc.Format = d3dElementFormats[srcElement.type_];
newDesc.InputSlot = (UINT)i;
newDesc.AlignedByteOffset = srcElement.offset_;
newDesc.InputSlotClass = srcElement.perInstance_ ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA;
newDesc.InstanceDataStepRate = srcElement.perInstance_ ? 1 : 0;
elementDescs.Push(newDesc);
}
prevBufferDescs = elementDescs.Size();
}
if (elementDescs.Empty())
return;
const PODVector<unsigned char>& byteCode = vertexShader->GetByteCode();
HRESULT hr = graphics->GetImpl()->GetDevice()->CreateInputLayout(&elementDescs[0], (UINT)elementDescs.Size(), &byteCode[0],
byteCode.Size(), (ID3D11InputLayout**)&inputLayout_);
if (FAILED(hr))
{
ATOMIC_SAFE_RELEASE(inputLayout_);
ATOMIC_LOGERRORF("Failed to create input layout for shader %s due to missing vertex element(s) (HRESULT %x)",
vertexShader->GetFullName().CString(), (unsigned)hr);
}
}
void LicenseSystem::HandleVerification(StringHash eventType, VariantMap& eventData)
{
CurlRequest* request = (CurlRequest*) (eventData[CurlComplete::P_CURLREQUEST].GetPtr());
bool licenseError = false;
bool resetLicense = false;
if (serverVerification_.NotNull())
{
assert(request == serverVerification_);
if (serverVerification_->GetError().Length())
{
ATOMIC_LOGERRORF("Unable to verify with server: %s", serverVerification_->GetError().CString());
}
else
{
LicenseParse parse;
int code = ParseResponse(serverVerification_->GetResponse(), parse);
if (code == 4)
{
// not activated
resetLicense = true;
licenseError = true;
}
else if (code == 2)
{
// something is wrong with the key
resetLicense = true;
licenseError = true;
}
else if (code == 3)
{
// something is wrong on the activation server
licenseError = true;
}
else if (code == 1)
{
// exceeded code, should not happen here as we aren't activating
resetLicense = true;
licenseError = true;
}
else if (code == 0)
{
// we should raise an error if there is a mismatch between local and server keys
// when the local says there are more enabled than server?
// otherwise, they could be being added
bool mismatch = false;
if (parse.licenseWindows_ != licenseWindows_)
mismatch = true;
if (parse.licenseMac_ != licenseMac_)
mismatch = true;
if (parse.licenseWindows_ != licenseWindows_)
mismatch = true;
if (parse.licenseAndroid_ != licenseAndroid_)
mismatch = true;
if (parse.licenseIOS_ != licenseIOS_)
mismatch = true;
if (parse.licenseHTML5_ != licenseHTML5_)
mismatch = true;
if (parse.licenseModule3D_ != licenseModule3D_)
mismatch = true;
if (mismatch)
{
ATOMIC_LOGERROR("License Mismatch, reseting");
licenseWindows_ = parse.licenseWindows_;
licenseMac_ = parse.licenseMac_;
licenseAndroid_ = parse.licenseAndroid_;
licenseIOS_= parse.licenseIOS_;
licenseHTML5_= parse.licenseHTML5_;
licenseModule3D_= parse.licenseModule3D_;
SaveLicense();
}
CreateOrUpdateLicenseCache();
SendEvent(E_LICENSE_SUCCESS);
}
}
UnsubscribeFromEvents(serverVerification_);
serverVerification_ = 0;
}
if (resetLicense)
{
RemoveLicense();
ResetLicense();
}
if (licenseError)
{
ATOMIC_LOGINFO("There was an issue with the atomic-cli activation. Please reactivate or contact [email protected] if this problem persists");
SendEvent(E_LICENSE_ERROR);
}
}
bool File::OpenInternal(const String& fileName, FileMode mode, bool fromPackage)
{
Close();
compressed_ = false;
readSyncNeeded_ = false;
writeSyncNeeded_ = false;
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (fileSystem && !fileSystem->CheckAccess(GetPath(fileName)))
{
ATOMIC_LOGERRORF("Access denied to %s", fileName.CString());
return false;
}
if (fileName.Empty())
{
ATOMIC_LOGERROR("Could not open file with empty name");
return false;
}
#ifdef __ANDROID__
if (ATOMIC_IS_ASSET(fileName))
{
if (mode != FILE_READ)
{
ATOMIC_LOGERROR("Only read mode is supported for Android asset files");
return false;
}
assetHandle_ = SDL_RWFromFile(ATOMIC_ASSET(fileName), "rb");
if (!assetHandle_)
{
ATOMIC_LOGERRORF("Could not open Android asset file %s", fileName.CString());
return false;
}
else
{
fileName_ = fileName;
mode_ = mode;
position_ = 0;
if (!fromPackage)
{
size_ = SDL_RWsize(assetHandle_);
offset_ = 0;
}
checksum_ = 0;
return true;
}
}
#endif
#ifdef _WIN32
handle_ = _wfopen(GetWideNativePath(fileName).CString(), openMode[mode]);
#else
handle_ = fopen(GetNativePath(fileName).CString(), openMode[mode]);
#endif
// If file did not exist in readwrite mode, retry with write-update mode
if (mode == FILE_READWRITE && !handle_)
{
#ifdef _WIN32
handle_ = _wfopen(GetWideNativePath(fileName).CString(), openMode[mode + 1]);
#else
handle_ = fopen(GetNativePath(fileName).CString(), openMode[mode + 1]);
#endif
}
if (!handle_)
{
ATOMIC_LOGERRORF("Could not open file %s", fileName.CString());
return false;
}
if (!fromPackage)
{
fseek((FILE*)handle_, 0, SEEK_END);
long size = ftell((FILE*)handle_);
fseek((FILE*)handle_, 0, SEEK_SET);
if (size > M_MAX_UNSIGNED)
{
ATOMIC_LOGERRORF("Could not open file %s which is larger than 4GB", fileName.CString());
Close();
size_ = 0;
return false;
}
size_ = (unsigned)size;
offset_ = 0;
}
fileName_ = fileName;
mode_ = mode;
position_ = 0;
checksum_ = 0;
return true;
}
