void CreateWorld() { Virtual::Cameras::FirstPersonCameraOptions options; g_camera.reset(new Virtual::Cameras::FirstPersonCamera(options)); g_camera->SetPositionAndTarget(Math::vec3(0, 5, 5), Math::vec3(0,0,0), Math::vec3(0,1,0)); Utility::WorldDesc world_desc; if (!Utility::Parser::LoadWorld(System::Environment::Instance()->GetModelFolder() + L"shop_interior2.pmd", world_desc)) { out_error() << "Can't load world descriptor from file" << std::endl; exit(-1); } g_world.reset(new Virtual::World(world_desc)); }
void configDynOptions(const InitializationMap& events) { if (events.exist("dyn_denys")) { const vle::value::Set& denyvs = events.getSet("dyn_denys"); vle::value::Set::const_iterator isb = denyvs.begin(); vle::value::Set::const_iterator ise = denyvs.end(); for (; isb != ise; isb++) { denys.insert((*isb)->toString().value()); } } if (events.exist("dyn_type")) { std::string dyn_type = events.getString("dyn_type"); if (dyn_type == "Var") { dyn_type = MONO; } else if (dyn_type == "Vect") { dyn_type = MULTI; } else if (dyn_type == "ValueVle") { dyn_type = VALUE_VLE; } else { dyn_type = MONO; } } else { dyn_type = MONO; } if (events.exist("dyn_sync")) { if (events.get("dyn_sync")->isInteger()) { dyn_sync = events.getInt("dyn_sync"); } else { dyn_sync = (unsigned int) events.getBoolean("dyn_sync"); } } if (events.exist("dyn_sync_out")) { if (events.get("dyn_sync_out")->isBoolean()) { dyn_sync_out = events.getBoolean("dyn_sync_out"); } } dyn_init_value.reset(); if (events.exist("dyn_init_value")) { dyn_init_value = std::unique_ptr<vle::value::Value>( events.get("dyn_init_value")->clone()); } else { dyn_init_value = std::unique_ptr<vle::value::Value>( new value::Double(0.0)); } }
int main(int argc, char** argv) { g_camera.radius = 1000.0f; g_camera.phi = 1.57; g_camera.theta = 1.57; /* float init_diagram_width = 200.0f; float init_diagram_height = 200.0f; SitesPtr sites = generateSites(30, init_diagram_width, init_diagram_height); diagram.reset(new VoronoiDiagram(sites, init_diagram_width, init_diagram_height)); edges = diagram->getEdges();*/ printf("Reading terrain data\n"); //readTerrainData("../terrain_data/clevel.xyz", g_terrain_data, 3000); //readTerrainData("../terrain_data/test.xyz", g_terrain_data); //readTerrainData("../terrain_data/downsampled_clevel.xyz", g_terrain_data); readTerrainData("../meshes/gourd.xyz", g_terrain_data); printf("Number of sites: %d\n", g_terrain_data.sites->size()); printf("X Data Range: [%3.3f, %3.3f]\n", g_terrain_data.min_x, g_terrain_data.max_x); printf("Y Data Range: [%3.3f, %3.3f]\n", g_terrain_data.min_y, g_terrain_data.max_y); printf("Z Data Range: [%3.3f, %3.3f]\n", g_terrain_data.min_z, g_terrain_data.max_z); diagram.reset(new VoronoiDiagram(g_terrain_data.sites, (g_terrain_data.max_x - g_terrain_data.min_x), (g_terrain_data.max_y - g_terrain_data.min_y))); edges = diagram->getEdges(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100, 100); glutInitWindowSize(WindowWidth, WindowHeight); glutCreateWindow("Voronoi and Delaunay"); glutDisplayFunc(DisplayFunc); glutReshapeFunc(ReshapeFunc); glutMouseFunc(MouseFunc); glutMotionFunc(MotionFunc); glutKeyboardFunc(KeyboardFunc); glutMainLoop(); return 0; }
IPCCommandResult STMImmediate::IOCtl(const IOCtlRequest& request) { s32 return_value = IPC_SUCCESS; switch (request.request) { case IOCTL_STM_IDLE: case IOCTL_STM_SHUTDOWN: NOTICE_LOG(IOS_STM, "IOCTL_STM_IDLE or IOCTL_STM_SHUTDOWN received, shutting down"); Core::QueueHostJob(&Core::Stop, false); break; case IOCTL_STM_RELEASE_EH: if (!s_event_hook_request) { return_value = IPC_ENOENT; break; } Memory::Write_U32(0, s_event_hook_request->buffer_out); EnqueueReply(*s_event_hook_request, IPC_SUCCESS); s_event_hook_request.reset(); break; case IOCTL_STM_HOTRESET: INFO_LOG(IOS_STM, "%s - IOCtl:", GetDeviceName().c_str()); INFO_LOG(IOS_STM, " IOCTL_STM_HOTRESET"); break; case IOCTL_STM_VIDIMMING: // (Input: 20 bytes, Output: 20 bytes) INFO_LOG(IOS_STM, "%s - IOCtl:", GetDeviceName().c_str()); INFO_LOG(IOS_STM, " IOCTL_STM_VIDIMMING"); // Memory::Write_U32(1, buffer_out); // return_value = 1; break; case IOCTL_STM_LEDMODE: // (Input: 20 bytes, Output: 20 bytes) INFO_LOG(IOS_STM, "%s - IOCtl:", GetDeviceName().c_str()); INFO_LOG(IOS_STM, " IOCTL_STM_LEDMODE"); break; default: request.DumpUnknown(GetDeviceName(), LogTypes::IOS_STM); } return GetDefaultReply(return_value); }
void Initialize(ASTContext &Ctx) override { if (Context) { assert(Context == &Ctx); return; } Context = &Ctx; if (llvm::TimePassesIsEnabled) LLVMIRGeneration.startTimer(); Gen->Initialize(Ctx); TheModule.reset(Gen->GetModule()); if (llvm::TimePassesIsEnabled) LLVMIRGeneration.stopTimer(); }
void SVGRenderingContext::clipToImageBuffer(GraphicsContext& context, const AffineTransform& absoluteTransform, const FloatRect& targetRect, std::unique_ptr<ImageBuffer>& imageBuffer, bool safeToClear) { if (!imageBuffer) return; FloatRect absoluteTargetRect = calculateImageBufferRect(targetRect, absoluteTransform); // The mask image has been created in the absolute coordinate space, as the image should not be scaled. // So the actual masking process has to be done in the absolute coordinate space as well. context.concatCTM(absoluteTransform.inverse().valueOr(AffineTransform())); context.clipToImageBuffer(*imageBuffer, absoluteTargetRect); context.concatCTM(absoluteTransform); // When nesting resources, with objectBoundingBox as content unit types, there's no use in caching the // resulting image buffer as the parent resource already caches the result. if (safeToClear && !currentContentTransformation().isIdentity()) imageBuffer.reset(); }
void BBox::Shutdown() { Invalidate(); if (s_bbox_buffer) { D3D::command_list_mgr->DestroyResourceAfterCurrentCommandListExecuted(s_bbox_buffer); s_bbox_buffer = nullptr; } if (s_bbox_staging_buffer) { D3D::command_list_mgr->DestroyResourceAfterCurrentCommandListExecuted(s_bbox_staging_buffer); s_bbox_staging_buffer = nullptr; } s_bbox_stream_buffer.reset(); }
void OsmAnd::ICU::release() { // Release resources: delete g_pIcuAccentsAndDiacriticsConverter; g_pIcuAccentsAndDiacriticsConverter = nullptr; delete g_pIcuAnyToLatinTransliterator; g_pIcuAnyToLatinTransliterator = nullptr; delete g_pIcuWordBreakIterator; g_pIcuWordBreakIterator = nullptr; g_IcuData.reset(); // Release ICU u_cleanup(); }
void FinderSyncHost::doShareLink(const QString &path) { QString repo_id; Account account; QString path_in_repo; if (!lookUpFileInformation(path, &repo_id, &account, &path_in_repo)) { qWarning("[FinderSync] invalid path %s", path.toUtf8().data()); return; } get_shared_link_req_.reset(new GetSharedLinkRequest( account, repo_id, QString("/").append(path_in_repo), QFileInfo(path).isFile())); connect(get_shared_link_req_.get(), SIGNAL(success(const QString &)), this, SLOT(onShareLinkGenerated(const QString &))); get_shared_link_req_->send(); }
error_code MachOUniversalBinary::ObjectForArch::getAsObjectFile( std::unique_ptr<ObjectFile> &Result) const { if (Parent) { StringRef ParentData = Parent->getData(); StringRef ObjectData = ParentData.substr(Header.offset, Header.size); std::string ObjectName = Parent->getFileName().str() + ":" + Triple::getArchTypeName(MachOObjectFile::getArch(Header.cputype)); MemoryBuffer *ObjBuffer = MemoryBuffer::getMemBuffer( ObjectData, ObjectName, false); ErrorOr<ObjectFile *> Obj = ObjectFile::createMachOObjectFile(ObjBuffer); if (error_code EC = Obj.getError()) return EC; Result.reset(Obj.get()); return object_error::success; } return object_error::parse_failed; }
void updateCode( std::unique_ptr<llvm::MemoryBuffer> buff ) { BufferID = SM.addNewSourceBuffer(std::move(buff)); Parser.reset( new ParserUnit(SM, BufferID, CompInv.getLangOptions(), CompInv.getModuleName()) ); Parser->getDiagnosticEngine().addConsumer(DiagConsumer); auto &P = Parser->getParser(); bool Done = false; while (!Done) { P.parseTopLevel(); Done = P.Tok.is(tok::eof); } }
/* step 3: declare imgtool_create_cannonical_library() */ imgtoolerr_t imgtool_create_cannonical_library(bool omit_untested, std::unique_ptr<imgtool::library> &library) { size_t i; /* list of modules that we drop */ static const char *const irrelevant_modules[] = { "coco_os9_rsdos" }; library.reset(new imgtool::library()); if (!library) return IMGTOOLERR_OUTOFMEMORY; // create all modules for (i = 0; i < ARRAY_LENGTH(modules); i++) library->add(modules[i]); // remove irrelevant modules for (i = 0; i < ARRAY_LENGTH(irrelevant_modules); i++) { library->unlink(irrelevant_modules[i]); } // if we are omitting untested, go through and block out the functionality in question if (omit_untested) { for (auto &module : library->modules()) { if (module->writing_untested) { module->write_sector = nullptr; } if (module->creation_untested) { module->create = nullptr; module->createimage_optguide = nullptr; module->createimage_optspec = nullptr; } } } return IMGTOOLERR_SUCCESS; }
void initBlur() { if (blur) return; blur.reset(new BlurState); // The blurred version of the view is downsampled. blur->size = (self().root().viewSize() / GuiWidget::toDevicePixels(4)).max(Vector2ui(1, 1)); for (int i = 0; i < 2; ++i) { // Multisampling is disabled in the blurs for now. blur->fb[i].reset(new GLTextureFramebuffer(Image::RGB_888, blur->size, 1)); blur->fb[i]->glInit(); blur->fb[i]->colorTexture().setFilter(gl::Linear, gl::Linear, gl::MipNone); } // Set up the drawble. DefaultVertexBuf *buf = new DefaultVertexBuf; blur->drawable.addBuffer(buf); buf->setVertices(gl::TriangleStrip, DefaultVertexBuf::Builder().makeQuad( Rectanglef(0, 0, 1, 1), Vector4f(1, 1, 1, 1), Rectanglef(0, 0, 1, 1)), gl::Static); blur->uBlurStep = Vector2f(1.f / float(blur->size.x), 1.f / float(blur->size.y)); self().root().shaders().build(blur->drawable.program(), "fx.blur.horizontal") << blur->uMvpMatrix << blur->uTex << blur->uBlurStep << blur->uWindow; blur->drawable.addProgram("vert"); self().root().shaders().build(blur->drawable.program("vert"), "fx.blur.vertical") << blur->uMvpMatrix << blur->uTex << blur->uColor << blur->uBlurStep << blur->uWindow; }
void InitData() { rand_init(); // Load obj file std::string basepath = g_path; basepath += "/"; std::string filename = basepath + g_modelname; g_scene.reset(Scene::LoadFromObj(filename, basepath)); g_scene->camera_.reset(new PerspectiveCamera( g_camera_pos , g_camera_at , CAMERA_UP , CAMERA_ZCAP , CAMERA_FOVY , (float)g_window_width / g_window_height )); g_scene->SetEnvironment("../Resources/Textures/studio015.hdr", "", g_envmapmul); #pragma omp parallel for for (int i = 0; i < g_cfgs.size(); ++i) { g_cfgs[i].renderer->SetNumBounces(g_num_bounces); g_cfgs[i].renderer->Preprocess(*g_scene); g_outputs[i].output = (FrOutput*)g_cfgs[i].renderer->CreateOutput(g_window_width, g_window_height); g_cfgs[i].renderer->SetOutput(g_outputs[i].output); g_outputs[i].fdata.resize(g_window_width * g_window_height); g_outputs[i].udata.resize(g_window_width * g_window_height * 4); if (g_cfgs[i].type == ConfigManager::kPrimary) { g_outputs[i].copybuffer = g_cfgs[i].context.CreateBuffer<float3>(g_window_width * g_window_height, CL_MEM_READ_WRITE); } } g_cfgs[g_primary].renderer->Clear(float3(0, 0, 0), *g_outputs[g_primary].output); }
void InitCl() { ConfigManager::CreateConfigs(g_mode, g_interop, g_cfgs); std::cout << "Running on devices: \n"; for (int i = 0; i < g_cfgs.size(); ++i) { std::cout << i << ": " << g_cfgs[i].context.GetDevice(g_cfgs[i].devidx).GetName() << "\n"; } g_interop = false; g_outputs.resize(g_cfgs.size()); g_ctrl.reset(new ControlData[g_cfgs.size()]); for (int i = 0; i < g_cfgs.size(); ++i) { if (g_cfgs[i].type == ConfigManager::kPrimary) { g_primary = i; if (g_cfgs[i].caninterop) { g_cl_interop_image = g_cfgs[i].context.CreateImage2DFromGLTexture(g_texture); g_interop = true; } } g_ctrl[i].clear.store(1); g_ctrl[i].stop.store(0); g_ctrl[i].newdata.store(0); g_ctrl[i].idx = i; } if (g_interop) { std::cout << "OpenGL interop mode enabled\n"; } else { std::cout << "OpenGL interop mode disabled\n"; } }
//JNIEXPORT void* hgs_init(int w, int h, jobject surface) JNIEXPORT bool hgs_init( jint w, jint h, ANativeWindow* window) { LOGD("window %p", window); tmpargs_.reset( new Main::Args() ); tmpargs_->vWidth = w; tmpargs_->vHeight = h; if (window) { //ANativeWindow* window = ANativeWindow_fromSurface(env, surface); tmpargs_->renderer_ok_ = 1; tmpargs_->vgl.setWindow(window); // pass Ownership // ANativeWindow_release } //jobject o = env_->NewObject(CLS_DecoderWrap, MID_DecoderWrap_ctor, w,h, surface); //oDecoderWrap = env_->NewGlobalRef(o); //env_->DeleteLocalRef(o); //LOGD("%d:%s %dx%d %p: %p", __LINE__,__func__, w,h,surface, oDecoderWrap); //return (void*)oDecoderWrap; return 1; }
bool on_accept() { if (!task) { cout << "In listener::on_accept()" << endl; task.reset(new server_work_thread); task->sock = std::move(connect_sock); task->start(); cout << "server thread started." << endl; // shutdown the listener thead.. our work is done here. return false; } else { connect_sock->close(); cerr << "Multiple attempts to connect to server" << endl; }; };
FontEffector(D3DCore* core, const TCHAR* filename) : Effector{} // ここでは読み込まない , cbColor{ nullptr } { // 共通のリソースとしてピクセルシェーダをロードする if (!psFont) { psFont = Shaders::Load<Shaders::PixelShader>(core, filename); if (!psFont) { // 読み込めなかった LOG_ERR("ファイル %s を読み込めませんでした\n", filename); return; } core->AddResource(PtrToRes(psFont)); } // 親クラスのデストラクタで消されないように、shaderには設定しない //this->shader = psFont; // こいつは自前で削除する cbColor.reset(new D3DConstantBuffer<Color>(core)); }
void DoState(PointerWrap& p) { // By waiting for the DVD thread to be done working, we ensure // that s_request_queue will be empty and that the DVD thread // won't be touching anything while this function runs. WaitUntilIdle(); // Move all results from s_result_queue to s_result_map because // PointerWrap::Do supports std::map but not Common::SPSCQueue. // This won't affect the behavior of FinishRead. ReadResult result; while (s_result_queue.Pop(result)) s_result_map.emplace(result.first.id, std::move(result)); // Both queues are now empty, so we don't need to savestate them. p.Do(s_result_map); p.Do(s_next_id); // s_disc isn't savestated (because it points to files on the // local system). Instead, we check that the status of the disc // is the same as when the savestate was made. This won't catch // cases of having the wrong disc inserted, though. // TODO: Check the game ID, disc number, revision? bool had_disc = HasDisc(); p.Do(had_disc); if (had_disc != HasDisc()) { if (had_disc) PanicAlertT("An inserted disc was expected but not found."); else s_disc.reset(); } // TODO: Savestates can be smaller if the buffers of results aren't saved, // but instead get re-read from the disc when loading the savestate. // TODO: It would be possible to create a savestate faster by stopping // the DVD thread regardless of whether there are pending requests. // After loading a savestate, the debug log in FinishRead will report // screwed up times for requests that were submitted before the savestate // was made. Handling that properly may be more effort than it's worth. }
void AudioSender::process() { auto& mainBuffer = Manager::instance().getRingBufferPool(); auto mainBuffFormat = mainBuffer.getInternalAudioFormat(); // compute nb of byte to get corresponding to 1 audio frame const std::size_t samplesToGet = std::chrono::duration_cast<std::chrono::seconds>(mainBuffFormat.sample_rate * secondsPerPacket_).count(); if (mainBuffer.availableForGet(id_) < samplesToGet) { const auto wait_time = std::chrono::duration_cast<std::chrono::milliseconds>(secondsPerPacket_); if (not mainBuffer.waitForDataAvailable(id_, samplesToGet, wait_time)) return; } // get data micData_.setFormat(mainBuffFormat); micData_.resize(samplesToGet); const auto samples = mainBuffer.getData(micData_, id_); if (samples != samplesToGet) return; // down/upmix as needed auto accountAudioCodec = std::static_pointer_cast<AccountAudioCodecInfo>(args_.codec); micData_.setChannelNum(accountAudioCodec->audioformat.nb_channels, true); if (mainBuffFormat.sample_rate != accountAudioCodec->audioformat.sample_rate) { if (not resampler_) { RING_DBG("Creating audio resampler"); resampler_.reset(new Resampler(accountAudioCodec->audioformat)); } resampledData_.setFormat(accountAudioCodec->audioformat); resampledData_.resize(samplesToGet); resampler_->resample(micData_, resampledData_); Smartools::getInstance().setLocalAudioCodec(audioEncoder_->getEncoderName()); if (audioEncoder_->encode_audio(resampledData_) < 0) RING_ERR("encoding failed"); } else { if (audioEncoder_->encode_audio(micData_) < 0) RING_ERR("encoding failed"); } }
void init_video () // inizializza grafica a 320x200x256 colori. { init(); // Set SDL video mode (using surface rendering) Uint32 rmask, gmask, bmask, amask; /* SDL interprets each pixel as a 32-bit number, so our masks must depend on the endianness (byte order) of the machine */ #if SDL_BYTEORDER == SDL_BIG_ENDIAN rmask = 0xff000000; gmask = 0x00ff0000; bmask = 0x0000ff00; amask = 0x00000000; #else rmask = 0x000000ff; gmask = 0x0000ff00; bmask = 0x00ff0000; amask = 0x00000000; #endif // create software video buffer video_buffer.reset(new unsigned char[WIDTH*HEIGHT]); memset(&video_buffer[0], 0, WIDTH*HEIGHT); p_surface_32 = SDL_CreateRGBSurface(0, WIDTH, HEIGHT, 32, rmask, gmask, bmask, amask); if (p_surface_32 == nullptr) throw sdl_exception(); p_window = SDL_CreateWindow("Crystal Pixels", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WIDTH_SCALED, HEIGHT_SCALED, SDL_WINDOW_RESIZABLE); if (p_window == nullptr) throw sdl_exception(); p_renderer = SDL_CreateRenderer(p_window, -1, SDL_RENDERER_TARGETTEXTURE); p_texture = SDL_CreateTexture(p_renderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, WIDTH,HEIGHT); //p_surface_scaled = SDL_GetWindowSurface(p_window); SDL_SetWindowMinimumSize(p_window, WIDTH, HEIGHT); }
static error_code getMemoryBufferForStream(int FD, StringRef BufferName, std::unique_ptr<MemoryBuffer> &Result) { const ssize_t ChunkSize = 4096*4; SmallString<ChunkSize> Buffer; ssize_t ReadBytes; // Read into Buffer until we hit EOF. do { Buffer.reserve(Buffer.size() + ChunkSize); ReadBytes = read(FD, Buffer.end(), ChunkSize); if (ReadBytes == -1) { if (errno == EINTR) continue; return error_code(errno, posix_category()); } Buffer.set_size(Buffer.size() + ReadBytes); } while (ReadBytes != 0); Result.reset(MemoryBuffer::getMemBufferCopy(Buffer, BufferName)); return error_code::success(); }
bool PassDefinition::Parse( Parser& parser, std::unique_ptr<PassDefinition>& token ) { // The definition starts with an open brace if( !parser.ExpectTerminal( TerminalType::OPEN_BRACE ) ) return false; // Parse some StateAssignmentStatements or CompileStatementss PassStatementVector statements; parser.ExpectSequenceOf<PassStatement>( statements ); // The parser may have advanced the lexer too far CHECK_PARSER; // The definiton ends with a close brace if( !parser.ExpectTerminal( TerminalType::CLOSE_BRACE ) ) return false; token.reset( new PassDefinition( std::move(statements) ) ); return true; }
void AutonomousInit() { CommandBase::pArm->SetEnabled(true); /* std::string autoSelected = SmartDashboard::GetString("Auto Selector", "Default"); if(autoSelected == "My Auto") { autonomousCommand.reset(new MyAutoCommand()); } else { autonomousCommand.reset(new ExampleCommand()); } */ autonomousCommand.reset((Command *)chooser->GetSelected()); if (autonomousCommand) std::cout << "Autonomous valid\n"; else std::cout << "Autonomous invalid\n"; if (autonomousCommand) autonomousCommand->Start(); }
Node::Node(std::unique_ptr<GameBoard> state, Node* const parent, std::unique_ptr<Move> action, uint8_t depth, Heuristic alpha, Heuristic beta, bool maximizer) : state{std::move(state)}, parent{parent}, action{std::move(action)}, depth{depth}, alpha{alpha}, beta{beta}, maximizer{maximizer}, nextNodeMove{0, 0}, bestMove{nullptr} { // If they called it with a null GameBoard, // they probably want a blank game state if (state == nullptr) { state.reset(new GameBoard); } }
void PS::loop(std::unique_ptr<IState> &ptr, ftui::ACanvas &can) { (void)ptr; this->_b->tiles.render(); this->_b->act.render(can); if (this->_launchSolvingState) { ft::f(std::cout, "Algo % Heu % Cost % Grid %:\n%\n" , _main.algorithmId , _main.heuristicId , _main.cost , _b->selectedId , _main.grid ); can.clear(); ptr.reset(new SolvingState(_main, _ocaml)); // throw std::runtime_error("OK"); } return ; }
//-------------------------------------------------------------------------------------- // Clean up the objects we've created //-------------------------------------------------------------------------------------- void CleanupDevice() { if( g_pImmediateContext ) g_pImmediateContext->ClearState(); if ( g_pBatchInputLayout ) g_pBatchInputLayout->Release(); if( g_pTextureRV1 ) g_pTextureRV1->Release(); if( g_pTextureRV2 ) g_pTextureRV2->Release(); if( g_pDepthStencilView ) g_pDepthStencilView->Release(); if( g_pDepthStencil ) g_pDepthStencil->Release(); if( g_pRenderTargetView ) g_pRenderTargetView->Release(); if( g_pSwapChain ) g_pSwapChain->Release(); if( g_pImmediateContext ) g_pImmediateContext->Release(); if( g_pd3dDevice ) g_pd3dDevice->Release(); #ifdef DXTK_AUDIO g_audEngine.reset(); #endif }
void init() { ClientApp::shaders().build(program, "model.skeletal.normal_specular_emission") << uMvpMatrix << uTex << uEyePos << uAmbientLight << uLightDirs << uLightIntensities; atlas.reset(AtlasTexture::newWithKdTreeAllocator( Atlas::DefaultFlags, GLTexture::maximumSize().min(GLTexture::Size(4096, 4096)))); atlas->setBorderSize(1); atlas->setMarginSize(0); // Fallback normal map for models who don't provide one. QImage img(QSize(1, 1), QImage::Format_ARGB32); img.fill(qRgba(127, 127, 255, 255)); // z+ defaultNormals = atlas->alloc(img); // Fallback emission map for models who don't have one. img.fill(qRgba(0, 0, 0, 0)); defaultEmission = atlas->alloc(img); // Fallback specular map (no specular reflections). img.fill(qRgba(0, 0, 0, 0)); defaultSpecular = atlas->alloc(img); uTex = *atlas; /* // All loaded items should use this atlas. bank.iterate([this] (DotPath const &path) { if(bank.isLoaded(path)) { setupModel(bank.model(path)); } });*/ }
void testSubs () { setup ("subs"); { auto& root = makeRoot(); { // Add an array with three entries. auto array = root.setArray ("ar"); array.append (23); array.append (false); array.append (23.5); } { // Add an object with one entry. auto obj = root.setObject ("obj"); obj["hello"] = "world"; } { // Add another object with two entries. Json::Value value; value["h"] = "w"; value["f"] = false; root["obj2"] = value; } } // Json::Value has an unstable order... auto case1 = "{\"ar\":[23,false,23.5]," "\"obj\":{\"hello\":\"world\"}," "\"obj2\":{\"h\":\"w\",\"f\":false}}"; auto case2 = "{\"ar\":[23,false,23.5]," "\"obj\":{\"hello\":\"world\"}," "\"obj2\":{\"f\":false,\"h\":\"w\"}}"; writerObject_.reset(); expect (output_ == case1 || output_ == case2, "Got wrong object:\n " + output_ + "\nShould be either\n " + case1 + "\nor\n " + case2); }
PDB_ErrorCode DIASession::createFromExe(StringRef Path, std::unique_ptr<IPDBSession> &Session) { CComPtr<IDiaDataSource> DiaDataSource; CComPtr<IDiaSession> DiaSession; // We assume that CoInitializeEx has already been called by the executable. if (!LoadDIA(DiaDataSource)) return PDB_ErrorCode::NoPdbImpl; llvm::SmallVector<UTF16, 128> Path16; if (!llvm::convertUTF8ToUTF16String(Path, Path16)) return PDB_ErrorCode::InvalidPath; const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data()); HRESULT Result; if (FAILED(Result = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr))) { if (Result == E_PDB_NOT_FOUND) return PDB_ErrorCode::InvalidPath; else if (Result == E_PDB_FORMAT) return PDB_ErrorCode::InvalidFileFormat; else if (Result == E_PDB_INVALID_SIG || Result == E_PDB_INVALID_AGE) return PDB_ErrorCode::DebugInfoMismatch; else if (Result == E_INVALIDARG) return PDB_ErrorCode::InvalidParameter; else if (Result == E_UNEXPECTED) return PDB_ErrorCode::AlreadyLoaded; else return PDB_ErrorCode::UnknownError; } if (FAILED(Result = DiaDataSource->openSession(&DiaSession))) { if (Result == E_OUTOFMEMORY) return PDB_ErrorCode::NoMemory; else return PDB_ErrorCode::UnknownError; } Session.reset(new DIASession(DiaSession)); return PDB_ErrorCode::Success; }