void loadAssets() { // Models models.skybox.loadFromFile(vulkanDevice, getAssetPath() + "models/cube.obj", vertexLayout, 0.05f, queue); std::vector<std::string> filenames = {"sphere.obj", "teapot.dae", "torusknot.obj"}; for (auto file : filenames) { vks::Model model; model.loadFromFile(vulkanDevice, getAssetPath() + "models/" + file, vertexLayout, 0.05f, queue); models.objects.push_back(model); } // Load HDR texture (equirectangular projected) // VK_FORMAT_BC6H_UFLOAT_BLOCK is a compressed 16 bit unsigned floating point format for storing HDR content textures.envmap.loadFromFile(getAssetPath() + "textures/hdr_uffizi_bc6uf.DDS", VK_FORMAT_BC6H_UFLOAT_BLOCK, vulkanDevice, queue); // Custom sampler with clamping adress mode vkDestroySampler(device, textures.envmap.sampler, nullptr); VkSamplerCreateInfo sampler{}; sampler.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; sampler.magFilter = VK_FILTER_LINEAR; sampler.minFilter = VK_FILTER_LINEAR; sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; sampler.addressModeV = sampler.addressModeU; sampler.addressModeW = sampler.addressModeU; sampler.maxLod = (float)textures.envmap.mipLevels; sampler.maxLod = 1.0f; sampler.anisotropyEnable = VK_TRUE; sampler.maxAnisotropy = vulkanDevice->properties.limits.maxSamplerAnisotropy; sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; VK_CHECK_RESULT(vkCreateSampler(vulkanDevice->logicalDevice, &sampler, nullptr, &textures.envmap.sampler)); textures.envmap.descriptor.sampler = textures.envmap.sampler; }
void Utils::writeCrashLog(std::string path) { string line; ifstream myfile; vector<string> cam; myfile.open( getAssetPath(path).c_str(), ifstream::in); int value = 0; if (myfile.is_open()) { while ( myfile.good() ) { getline (myfile,line); cam.push_back(line); } myfile.close(); value = ::atoi(cam[0].c_str()); } value++; ofstream myfile1 (getAssetPath(path).c_str()); if (myfile1.is_open()) { myfile1 << value; myfile.close(); } }
void preparePipelines() { if (pipeline != VK_NULL_HANDLE) { vkDestroyPipeline(device, pipeline, nullptr); } const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE); VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE); VkPipelineColorBlendStateCreateInfo colorBlendStateCI = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState); VkPipelineDepthStencilStateCreateInfo depthStencilStateCI = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_FALSE, VK_COMPARE_OP_LESS_OR_EQUAL); VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0); VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0); VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()), 0); VkPipelineRasterizationStateCreateInfo rasterizationStateCI{}; rasterizationStateCI.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; rasterizationStateCI.polygonMode = VK_POLYGON_MODE_FILL; rasterizationStateCI.lineWidth = 1.0f; rasterizationStateCI.cullMode = VK_CULL_MODE_NONE + cullMode; rasterizationStateCI.frontFace = windingOrder == 0 ? VK_FRONT_FACE_CLOCKWISE : VK_FRONT_FACE_COUNTER_CLOCKWISE; // Vertex bindings and attributes std::vector<VkVertexInputBindingDescription> vertexInputBindings = { vks::initializers::vertexInputBindingDescription(0, sizeof(float) * 5, VK_VERTEX_INPUT_RATE_VERTEX), }; std::vector<VkVertexInputAttributeDescription> vertexInputAttributes = { vks::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0), // Position vks::initializers::vertexInputAttributeDescription(0, 1, VK_FORMAT_R32G32_SFLOAT, sizeof(float) * 3), // uv }; VkPipelineVertexInputStateCreateInfo vertexInputState = vks::initializers::pipelineVertexInputStateCreateInfo(); vertexInputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertexInputBindings.size()); vertexInputState.pVertexBindingDescriptions = vertexInputBindings.data(); vertexInputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexInputAttributes.size()); vertexInputState.pVertexAttributeDescriptions = vertexInputAttributes.data(); VkGraphicsPipelineCreateInfo pipelineCreateInfoCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0); //pipelineCreateInfoCI.pVertexInputState = &emptyInputState; pipelineCreateInfoCI.pVertexInputState = &vertexInputState; pipelineCreateInfoCI.pInputAssemblyState = &inputAssemblyStateCI; pipelineCreateInfoCI.pRasterizationState = &rasterizationStateCI; pipelineCreateInfoCI.pColorBlendState = &colorBlendStateCI; pipelineCreateInfoCI.pMultisampleState = &multisampleStateCI; pipelineCreateInfoCI.pViewportState = &viewportStateCI; pipelineCreateInfoCI.pDepthStencilState = &depthStencilStateCI; pipelineCreateInfoCI.pDynamicState = &dynamicStateCI; const std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages = { loadShader(getAssetPath() + "shaders/negativeviewportheight/quad.vert.spv", VK_SHADER_STAGE_VERTEX_BIT), loadShader(getAssetPath() + "shaders/negativeviewportheight/quad.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT) }; pipelineCreateInfoCI.stageCount = static_cast<uint32_t>(shaderStages.size()); pipelineCreateInfoCI.pStages = shaderStages.data(); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfoCI, nullptr, &pipeline)); }
void loadTextures() { textureLoader->loadTexture( getAssetPath() + "textures/stonewall_colormap_bc3.dds", VK_FORMAT_BC3_UNORM_BLOCK, &textures.colorMap); textureLoader->loadTexture( getAssetPath() + "textures/stonewall_heightmap_rgba.dds", VK_FORMAT_R8G8B8A8_UNORM, &textures.heightMap); }
void loadMeshes() { // Skybox models.skybox.loadFromFile(getAssetPath() + "models/cube.obj", vertexLayout, 0.05f, vulkanDevice, queue); // Objects std::vector<std::string> filenames = { "sphere.obj", "teapot.dae", "torusknot.obj" }; for (auto file : filenames) { vks::Model model; model.loadFromFile(getAssetPath() + "models/" + file, vertexLayout, 0.05f, vulkanDevice, queue); models.objects.push_back(model); } }
void loadAssets() { // Skybox models.skybox.loadFromFile(getAssetPath() + "models/cube.obj", vertexLayout, 0.05f, vulkanDevice, queue); // Objects std::vector<std::string> filenames = { "sphere.obj", "teapot.dae", "torusknot.obj", "venus.fbx" }; objectNames = { "Sphere", "Teapot", "Torusknot", "Venus" }; for (auto file : filenames) { vks::Model model; model.loadFromFile(getAssetPath() + "models/" + file, vertexLayout, 0.05f * (file == "venus.fbx" ? 3.0f : 1.0f), vulkanDevice, queue); models.objects.push_back(model); } }
void preparePipelines() { const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE); VkPipelineRasterizationStateCreateInfo rasterizationStateCI = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0); VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE); VkPipelineColorBlendStateCreateInfo colorBlendStateCI = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState); VkPipelineDepthStencilStateCreateInfo depthStencilStateCI = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL); VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0); VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0); VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()), 0); // Vertex bindings and attributes const std::vector<VkVertexInputBindingDescription> vertexInputBindings = { vks::initializers::vertexInputBindingDescription(0, sizeof(vkglTF::Model::Vertex), VK_VERTEX_INPUT_RATE_VERTEX), }; const std::vector<VkVertexInputAttributeDescription> vertexInputAttributes = { vks::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0), // Location 0: Position vks::initializers::vertexInputAttributeDescription(0, 1, VK_FORMAT_R32G32B32_SFLOAT, sizeof(float) * 3), // Location 1: Normal vks::initializers::vertexInputAttributeDescription(0, 2, VK_FORMAT_R32G32_SFLOAT, sizeof(float) * 6), // Location 2: UV }; VkPipelineVertexInputStateCreateInfo vertexInputState = vks::initializers::pipelineVertexInputStateCreateInfo(); vertexInputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertexInputBindings.size()); vertexInputState.pVertexBindingDescriptions = vertexInputBindings.data(); vertexInputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexInputAttributes.size()); vertexInputState.pVertexAttributeDescriptions = vertexInputAttributes.data(); VkGraphicsPipelineCreateInfo pipelineCreateInfoCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0); pipelineCreateInfoCI.pVertexInputState = &vertexInputState; pipelineCreateInfoCI.pInputAssemblyState = &inputAssemblyStateCI; pipelineCreateInfoCI.pRasterizationState = &rasterizationStateCI; pipelineCreateInfoCI.pColorBlendState = &colorBlendStateCI; pipelineCreateInfoCI.pMultisampleState = &multisampleStateCI; pipelineCreateInfoCI.pViewportState = &viewportStateCI; pipelineCreateInfoCI.pDepthStencilState = &depthStencilStateCI; pipelineCreateInfoCI.pDynamicState = &dynamicStateCI; const std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages = { loadShader(getAssetPath() + "shaders/conditionalrender/model.vert.spv", VK_SHADER_STAGE_VERTEX_BIT), loadShader(getAssetPath() + "shaders/conditionalrender/model.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT) }; pipelineCreateInfoCI.stageCount = static_cast<uint32_t>(shaderStages.size()); pipelineCreateInfoCI.pStages = shaderStages.data(); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfoCI, nullptr, &pipeline)); }
void QRcode::setup() { qrCodeFon = *AssetManager::getInstance()->getTexture("images/qrCodeHolder.png"); qrCodeFont = Font( loadFile(getAssetPath("fonts/Helvetica Neue Bold.ttf")), 36 ); errorTexture = AssetManager::getInstance()->getTexture("05_serveraerror.png"); preloader.setup(); }
void loadTextures() { textureLoader->loadTexture( getAssetPath() + "textures/deer.ktx", VK_FORMAT_BC3_UNORM_BLOCK, &textures.colorMap); }
void SplatTestApp::setup() { resetCamera(); { connexion::Device::initialize(getRenderer()->getHwnd()); const auto &ids = connexion::Device::getAllDeviceIds(); if (!ids.empty()) { spaceNav = connexion::Device::create(ids.front()); spaceNav->getMotionSignal().connect([this](const connexion::MotionEvent &event) { cameraTranslation = event.translation; cameraRotation = event.rotation; }); spaceNav->getButtonDownSignal().connect( [this](const connexion::ButtonDownEvent &event) { resetCamera(); }); } } particleSys = std::make_unique<ParticleSys>(); particleUpdateMainFilepath = getAssetPath("update_cs.glsl"); wd::watch(particleUpdateMainFilepath, [this](const fs::path &filepath) { updateShaderError.clear(); try { particleSys->loadUpdateShaderMain(filepath); } catch (const gl::GlslProgCompileExc &exc) { updateShaderError = exc.what(); } }); ui::initialize(ui::Options().autoRender(false)); }
void loadAssets() { models.example.loadFromFile(getAssetPath() + "models/voyager/voyager.dae", vertexLayout, 1.0f, vulkanDevice, queue); if (deviceFeatures.textureCompressionBC) { textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_bc3_unorm.ktx", VK_FORMAT_BC3_UNORM_BLOCK, vulkanDevice, queue); } else if (deviceFeatures.textureCompressionASTC_LDR) { textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_astc_8x8_unorm.ktx", VK_FORMAT_ASTC_8x8_UNORM_BLOCK, vulkanDevice, queue); } else if (deviceFeatures.textureCompressionETC2) { textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue); } else { vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); } }
bool SensorFile::init( const string &fileName ) { if( mInited ) return false; fs::path fullPath( getAssetPath( string( "capture/" ) + fileName )); if( ! fs::exists( fullPath )) { console() << "Unable to load captured file: " << fileName << endl; return false; } mDoc = XmlTree( loadFile( fullPath )); if( mDoc.hasChild( "PulseSensor" )) { XmlTree &xmlPulseSensor = mDoc.getChild( "PulseSensor" ); mName = xmlPulseSensor.getAttributeValue<string>( "Name" , "" ); if( xmlPulseSensor.hasChild( "Data" )) { mListXmlData = &xmlPulseSensor.getChildren(); mXmlDataActIt = mListXmlData->end(); mInited = true; mTime = getElapsedSeconds(); return true; } } console() << "Invalid captured file: " << fileName << endl; return false; }
void loadTextures() { textureLoader->loadCubemap( getAssetPath() + "textures/cubemap_vulkan.ktx", VK_FORMAT_R8G8B8A8_UNORM, &textures.skybox); }
void loadTextures() { textureLoader->loadTexture( getAssetPath() + "textures/particle01_rgba.ktx", VK_FORMAT_R8G8B8A8_UNORM, &textureColorMap, false); }
NativeString* AssetManagerGlue::getCookieName(int cookie) { String8 name(getAssetPath((void*)cookie)); if (name.length() == 0) { return NULL; } return new NativeString(name); }
void loadAssets() { std::vector<std::string> filenames = { "geosphere.obj", "teapot.dae", "torusknot.obj", "venus.fbx" }; for (auto file : filenames) { vks::Model model; model.loadFromFile(getAssetPath() + "models/" + file, vertexLayout, OBJ_DIM * (file == "venus.fbx" ? 3.0f : 1.0f), vulkanDevice, queue); models.objects.push_back(model); } }
void loadAssets() { model.loadFromFile(getAssetPath() + "models/geosphere.obj", vertexLayout, OBJ_DIM, vulkanDevice, queue); // Setup random materials for every object in the scene for (uint32_t i = 0; i < objects.size(); i++) { objects[i].setRandomMaterial(); } }
void loadAssets() { models.quad.loadFromFile(getAssetPath() + "models/plane_z.obj", vertexLayout, 0.1f, vulkanDevice, queue); // Textures textures.normalHeightMap.loadFromFile(getAssetPath() + "textures/rocks_normal_height_rgba.dds", VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue); if (vulkanDevice->features.textureCompressionBC) { textures.colorMap.loadFromFile(getAssetPath() + "textures/rocks_color_bc3_unorm.dds", VK_FORMAT_BC3_UNORM_BLOCK, vulkanDevice, queue); } else if (vulkanDevice->features.textureCompressionASTC_LDR) { textures.colorMap.loadFromFile(getAssetPath() + "textures/rocks_color_astc_8x8_unorm.ktx", VK_FORMAT_ASTC_8x8_UNORM_BLOCK, vulkanDevice, queue); } else if (vulkanDevice->features.textureCompressionETC2) { textures.colorMap.loadFromFile(getAssetPath() + "textures/rocks_color_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue); } else { vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT); } }
void DataManager::loadDataSet( GenomeDataStructure ds ){ Buffer b = Buffer( loadFile( getAssetPath(ds.pathBases) ) ); size_t size = b.getDataSize(); mDataBuffer = b; mCurrentDataSet.basePairsCount = size; mCurrentDataSet.chromosomeDescription = ds.name; mCurrentDataSet.chromosomeID = ds.id; Buffer bmap = Buffer( loadFile( getAssetPath(ds.pathMap) ) ); generateChromosomeMap( &bmap ); vector<GenomeData::ROIDataSet>::const_iterator it; for(it=mRoiMap.begin();it!=mRoiMap.end();++it){ int roiID = (*it).roiId; mRoiMapVisited[roiID] = roiID; // XXX } sOnDataStructureChange(); }
void loadAssets() { textures.CW.loadFromFile(getAssetPath() + "textures/texture_orientation_cw_rgba.ktx", VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue); textures.CCW.loadFromFile(getAssetPath() + "textures/texture_orientation_ccw_rgba.ktx", VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue); // [POI] Create two quads with different Y orientations struct Vertex { float pos[3]; float uv[2]; }; const float ar = (float)height / (float)width; // OpenGL style (y points upwards) std::vector<Vertex> verticesYPos = { { -1.0f * ar, 1.0f, 1.0f, 0.0f, 1.0f }, { -1.0f * ar, -1.0f, 1.0f, 0.0f, 0.0f }, { 1.0f * ar, -1.0f, 1.0f, 1.0f, 0.0f }, { 1.0f * ar, 1.0f, 1.0f, 1.0f, 1.0f }, }; // Vulkan style (y points downwards) std::vector<Vertex> verticesYNeg = { { -1.0f * ar, -1.0f, 1.0f, 0.0f, 1.0f }, { -1.0f * ar, 1.0f, 1.0f, 0.0f, 0.0f }, { 1.0f * ar, 1.0f, 1.0f, 1.0f, 0.0f }, { 1.0f * ar, -1.0f, 1.0f, 1.0f, 1.0f }, }; const VkMemoryPropertyFlags memoryPropertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, memoryPropertyFlags, &quad.verticesYUp, sizeof(Vertex) * 4, verticesYPos.data())); VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, memoryPropertyFlags, &quad.verticesYDown, sizeof(Vertex) * 4, verticesYNeg.data())); // [POI] Create two set of indices, one for counter clock wise, and one for clock wise rendering std::vector<uint32_t> indices = { 2,1,0, 0,3,2 }; VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_INDEX_BUFFER_BIT, memoryPropertyFlags, &quad.indicesCCW, indices.size() * sizeof(uint32_t), indices.data())); indices = { 0,1,2, 2,3,0 }; VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_INDEX_BUFFER_BIT, memoryPropertyFlags, &quad.indicesCW, indices.size() * sizeof(uint32_t), indices.data())); }
void fsExperiments::setupEyes() { GlobalData& data = GlobalData::get(); data.mAiEyes = assimp::AssimpLoader( getAssetPath( "models/eyes.dae" ) ); data.mAiEyes.disableSkinning(); //data.mAiEyes.disableMaterials(); data.mAiEyes.enableMaterials(); // FIXME: load positions from export/eye data.mLeftEyeRef = data.mAiEyes.getAssimpNode( "left" ); assert( data.mLeftEyeRef ); data.mLeftEyeRef->setPosition( Vec3f( 31.3636, -24.4065, -24.7222 ) ); data.mRightEyeRef = data.mAiEyes.getAssimpNode( "right" ); assert( data.mRightEyeRef ); data.mRightEyeRef->setPosition( Vec3f( -31.1631, -26.0238, -24.7322 ) ); }
void ResourceManager::initResources() { // mFont = Font(loadAsset("Blender-BOOK.ttf"), 14); // mFont = Font(loadAsset("Blender-BOLD.ttf"), 14); mFont = Font(loadAsset("Overlock-Bold.ttf"), 12); gl::TextureFont::Format format; // format.premultiply(); mTextureFont = gl::TextureFont::create(mFont, format); mPlusTexture = loadImage(getAssetPath("plus.png")); colors.push_back(Color::hex(0xdc534e)); colors.push_back(Color::hex(0x5f78b4)); colors.push_back(Color::hex(0x5b3a6f)); colors.push_back(Color::hex(0xbaa326)); colors.push_back(Color::hex(0xF26835)); ResourceManager::mainIsolate = v8::Isolate::New(); ResourceManager::mainIsolate->Enter(); }
void DataManager::generateXmlFile(){ XmlTree dataTree; dataTree.setTag("QLT_Genome_Data"); dataTree.push_back(XmlTree("datapath","./data/exons/")); XmlTree datas("datasets",""); for(int i=0;i<23;i++){ XmlTree dataset("dataset",""); dataset.setAttribute("id", i); dataset.push_back( XmlTree("title","Chromosome "+toString(i+1)) ); dataset.push_back( XmlTree("map","exons."+toString(i+1)+".locations") ); dataset.push_back( XmlTree("bases","exons."+toString(i+1)+".bases") ); datas.push_back( dataset ); } dataTree.push_back( datas ); DataTargetPathRef f = writeFile( getAssetPath( "QLT_Genome_Data.xml" ), true ); dataTree.write( f ); }
bool Utils::readFlag(std::string path) { string line; ifstream myfile; vector<string> cam; myfile.open( getAssetPath(path).c_str(), ifstream::in); if (myfile.is_open()) { while ( myfile.good() ) { getline (myfile,line); cam.push_back(line); } myfile.close(); return ::atoi(cam[0].c_str()) == 1; } return false; }
void tracking::setup(){ mWindow = getWindow(); mCbMouseDown = mWindow->getSignalMouseDown().connect( std::bind( &tracking::mouseDown, this, std::placeholders::_1 ) ); mCbMouseDrag = mWindow->getSignalMouseDrag().connect( std::bind( &tracking::mouseDrag, this, std::placeholders::_1 ) ); mCbMouseMove = mWindow->getSignalMouseMove().connect( std::bind( &tracking::mouseMove, this, std::placeholders::_1 ) ); mCbMouseUp = mWindow->getSignalMouseUp().connect( std::bind( &tracking::mouseUp, this, std::placeholders::_1 ) ); mCbKeyDown = mWindow->getSignalKeyDown().connect( std::bind( &tracking::keyDown, this, std::placeholders::_1 ) ); mCbKeyUp = mWindow->getSignalKeyUp().connect( std::bind( &tracking::keyUp, this, std::placeholders::_1 ) ); mCbResize = mWindow->getSignalResize().connect(std::bind(&tracking::resize,this)); mUseBeginEnd = false; // initialize warps mSettings = getAssetPath( "" ) / "warps.xml"; if( fs::exists( mSettings ) ) { mWarps = Warp::readSettings( loadFile( mSettings ) ); } else { mWarps.push_back( WarpPerspective::create() ); } mTexturePlaceholder = gl::Texture::create(500,500); // load test image try { mImage = gl::Texture::create( loadImage( loadAsset( "help.png" ) ), gl::Texture2d::Format().loadTopDown().mipmap( true ).minFilter( GL_LINEAR_MIPMAP_LINEAR ) ); mSrcArea = mImage->getBounds(); // adjust the content size of the warps Warp::setSize( mWarps, mImage->getSize() ); } catch( const std::exception &e ) { console() << e.what() << std::endl; } }
void fsExperiments::setupParams() { fs::path paramsXml( getAssetPath( "params.xml" )); if ( paramsXml.empty() ) { #if defined( CINDER_MAC ) fs::path assetPath( getResourcePath() / "assets" ); #else fs::path assetPath( getAppPath() / "assets" ); #endif createDirectories( assetPath ); paramsXml = assetPath / "params.xml" ; } params::PInterfaceGl::load( paramsXml ); GlobalData& data = GlobalData::get(); data.mParams = params::PInterfaceGl( "Parameters", Vec2i( 200, 300 ) ); data.mParams.addPersistentSizeAndPosition(); data.mParams.addParam( "Fps", &mFps, "", false ); data.mParams.addPersistentParam( "Background", &mBackground, Color::gray( .1 ) ); // effect params setup mCurrentEffect = 0; vector< string > effectNames; for ( vector< fsExpRef >::iterator it = mEffects.begin(); it != mEffects.end(); ++it ) { effectNames.push_back( (*it)->getName() ); } data.mParams.addParam( "Effect", effectNames, &mCurrentEffect ); for ( vector< fsExpRef >::iterator it = mEffects.begin(); it != mEffects.end(); ++it ) { (*it)->setupParams(); } }
void loadTextures() { // Vulkan core supports three different compressed texture formats // As the support differs between implemementations we need to check device features and select a proper format and file std::string filename; VkFormat format; if (deviceFeatures.textureCompressionBC) { filename = "cubemap_yokohama_bc3_unorm.ktx"; format = VK_FORMAT_BC2_UNORM_BLOCK; } else if (deviceFeatures.textureCompressionASTC_LDR) { filename = "cubemap_yokohama_astc_8x8_unorm.ktx"; format = VK_FORMAT_ASTC_8x8_UNORM_BLOCK; } else if (deviceFeatures.textureCompressionETC2) { filename = "cubemap_yokohama_etc2_unorm.ktx"; format = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; } else { vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); } loadCubemap(getAssetPath() + "textures/" + filename, format, false); }
void preparePipelines() { VkResult err; VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vkTools::initializers::pipelineInputAssemblyStateCreateInfo( VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 0, VK_FALSE); VkPipelineRasterizationStateCreateInfo rasterizationState = vkTools::initializers::pipelineRasterizationStateCreateInfo( VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0); VkPipelineColorBlendAttachmentState blendAttachmentState = vkTools::initializers::pipelineColorBlendAttachmentState( 0xf, VK_FALSE); VkPipelineColorBlendStateCreateInfo colorBlendState = vkTools::initializers::pipelineColorBlendStateCreateInfo( 1, &blendAttachmentState); VkPipelineDepthStencilStateCreateInfo depthStencilState = vkTools::initializers::pipelineDepthStencilStateCreateInfo( VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL); VkPipelineViewportStateCreateInfo viewportState = vkTools::initializers::pipelineViewportStateCreateInfo(1, 1, 0); VkPipelineMultisampleStateCreateInfo multisampleState = vkTools::initializers::pipelineMultisampleStateCreateInfo( VK_SAMPLE_COUNT_1_BIT, 0); std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH }; VkPipelineDynamicStateCreateInfo dynamicState = vkTools::initializers::pipelineDynamicStateCreateInfo( dynamicStateEnables.data(), dynamicStateEnables.size(), 0); VkPipelineTessellationStateCreateInfo tessellationState = vkTools::initializers::pipelineTessellationStateCreateInfo(3); // Tessellation pipeline // Load shaders std::array<VkPipelineShaderStageCreateInfo, 4> shaderStages; shaderStages[0] = loadShader(getAssetPath() + "shaders/displacement/base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/displacement/base.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); shaderStages[2] = loadShader(getAssetPath() + "shaders/displacement/displacement.tesc.spv", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT); shaderStages[3] = loadShader(getAssetPath() + "shaders/displacement/displacement.tese.spv", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT); VkGraphicsPipelineCreateInfo pipelineCreateInfo = vkTools::initializers::pipelineCreateInfo( pipelineLayout, renderPass, 0); pipelineCreateInfo.pVertexInputState = &vertices.inputState; pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState; pipelineCreateInfo.pRasterizationState = &rasterizationState; pipelineCreateInfo.pColorBlendState = &colorBlendState; pipelineCreateInfo.pMultisampleState = &multisampleState; pipelineCreateInfo.pViewportState = &viewportState; pipelineCreateInfo.pDepthStencilState = &depthStencilState; pipelineCreateInfo.pDynamicState = &dynamicState; pipelineCreateInfo.pTessellationState = &tessellationState; pipelineCreateInfo.stageCount = shaderStages.size(); pipelineCreateInfo.pStages = shaderStages.data(); pipelineCreateInfo.renderPass = renderPass; // Solid pipeline err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solid); assert(!err); // Wireframe pipeline rasterizationState.polygonMode = VK_POLYGON_MODE_LINE; err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.wire); assert(!err); // Pass through pipelines // Load pass through tessellation shaders (Vert and frag are reused) shaderStages[2] = loadShader(getAssetPath() + "shaders/displacement/passthrough.tesc.spv", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT); shaderStages[3] = loadShader(getAssetPath() + "shaders/displacement/passthrough.tese.spv", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT); // Solid rasterizationState.polygonMode = VK_POLYGON_MODE_FILL; err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solidPassThrough); assert(!err); // Wireframe rasterizationState.polygonMode = VK_POLYGON_MODE_LINE; err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.wirePassThrough); assert(!err); }
void loadMeshes() { loadMesh(getAssetPath() + "models/torus.obj", &meshes.object, vertexLayout, 0.25f); }
void preparePipelines() { VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo( VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE); VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo( VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0); VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState( 0xf, VK_FALSE); VkPipelineColorBlendStateCreateInfo colorBlendState = vks::initializers::pipelineColorBlendStateCreateInfo( 1, &blendAttachmentState); VkPipelineDepthStencilStateCreateInfo depthStencilState = vks::initializers::pipelineDepthStencilStateCreateInfo( VK_FALSE, VK_FALSE, VK_COMPARE_OP_LESS_OR_EQUAL); VkPipelineViewportStateCreateInfo viewportState = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0); VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo( VK_SAMPLE_COUNT_1_BIT, 0); std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; VkPipelineDynamicStateCreateInfo dynamicState = vks::initializers::pipelineDynamicStateCreateInfo( dynamicStateEnables.data(), dynamicStateEnables.size(), 0); // Skybox pipeline (background cube) std::array<VkPipelineShaderStageCreateInfo,2> shaderStages; shaderStages[0] = loadShader(getAssetPath() + "shaders/cubemap/skybox.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/cubemap/skybox.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); VkGraphicsPipelineCreateInfo pipelineCreateInfo = vks::initializers::pipelineCreateInfo( pipelineLayout, renderPass, 0); pipelineCreateInfo.pVertexInputState = &vertices.inputState; pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState; pipelineCreateInfo.pRasterizationState = &rasterizationState; pipelineCreateInfo.pColorBlendState = &colorBlendState; pipelineCreateInfo.pMultisampleState = &multisampleState; pipelineCreateInfo.pViewportState = &viewportState; pipelineCreateInfo.pDepthStencilState = &depthStencilState; pipelineCreateInfo.pDynamicState = &dynamicState; pipelineCreateInfo.stageCount = shaderStages.size(); pipelineCreateInfo.pStages = shaderStages.data(); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skybox)); // Cube map reflect pipeline shaderStages[0] = loadShader(getAssetPath() + "shaders/cubemap/reflect.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/cubemap/reflect.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); // Enable depth test and write depthStencilState.depthWriteEnable = VK_TRUE; depthStencilState.depthTestEnable = VK_TRUE; // Flip cull mode rasterizationState.cullMode = VK_CULL_MODE_FRONT_BIT; VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.reflect)); }