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