bool startObject() { m_items.emplace_back(Item::StartObject); return true; }
void sounds::add_footstep( const tripoint &p, int volume, int, monster * ) { sounds_since_last_turn.emplace_back( std::make_pair( p, sound_event {volume, "", false, true, "", ""} ) ); }
void TextToViewSettings(const string& ColumnTitles,const string& ColumnWidths, std::vector<column>& Columns) { // BUGBUG, add error checking const wchar_t *TextPtr=ColumnTitles.data(); Columns.clear(); for (;;) { string strArgName; if (!(TextPtr=GetCommaWord(TextPtr,strArgName))) break; Columns.emplace_back(VALUE_TYPE(Columns)()); string strArgOrig = strArgName; ToUpper(strArgName); if (strArgName.front() == L'N') { unsigned __int64 &ColumnType = Columns.back().type; ColumnType = NAME_COLUMN; const wchar_t *Ptr = strArgName.data() + 1; while (*Ptr) { switch (*Ptr) { case L'M': ColumnType |= COLUMN_MARK; break; case L'O': ColumnType |= COLUMN_NAMEONLY; break; case L'R': ColumnType |= COLUMN_RIGHTALIGN; break; case L'F': ColumnType |= COLUMN_RIGHTALIGNFORCE; break; case L'N': ColumnType |= COLUMN_NOEXTENSION; break; } Ptr++; } } else if (strArgName.front() == L'S' || strArgName.front() == L'P' || strArgName.front() == L'G') { unsigned __int64 &ColumnType = Columns.back().type; ColumnType = (strArgName.front() == L'S') ? SIZE_COLUMN : (strArgName.front() == L'P') ? PACKED_COLUMN : STREAMSSIZE_COLUMN; const wchar_t *Ptr = strArgName.data() + 1; while (*Ptr) { switch (*Ptr) { case L'C': ColumnType |= COLUMN_COMMAS; break; case L'E': ColumnType |= COLUMN_ECONOMIC; break; case L'F': ColumnType |= COLUMN_FLOATSIZE; break; case L'T': ColumnType |= COLUMN_THOUSAND; break; } Ptr++; } } else if (!StrCmpN(strArgName.data(), L"DM", 2) || !StrCmpN(strArgName.data(), L"DC", 2) || !StrCmpN(strArgName.data(), L"DA", 2) || !StrCmpN(strArgName.data(), L"DE", 2)) { unsigned __int64 &ColumnType = Columns.back().type; switch (strArgName[1]) { case L'M': ColumnType = WDATE_COLUMN; break; case L'C': ColumnType = CDATE_COLUMN; break; case L'A': ColumnType = ADATE_COLUMN; break; case L'E': ColumnType = CHDATE_COLUMN; break; } const wchar_t *Ptr = strArgName.data() + 2; while (*Ptr) { switch (*Ptr) { case L'B': ColumnType |= COLUMN_BRIEF; break; case L'M': ColumnType |= COLUMN_MONTH; break; } Ptr++; } } else if (strArgName.front() == L'O') { unsigned __int64 &ColumnType = Columns.back().type; ColumnType = OWNER_COLUMN; if (strArgName.size() > 1 && strArgName[1] == L'L') ColumnType |= COLUMN_FULLOWNER; } else if (strArgName.front() == L'X') { unsigned __int64 &ColumnType = Columns.back().type; ColumnType = EXTENSION_COLUMN; if (strArgName.size() > 1 && strArgName[1] == L'R') ColumnType |= COLUMN_RIGHTALIGN; } else if (strArgOrig.size() > 2 && strArgOrig.front() == L'<' && strArgOrig.back() == L'>') { Columns.back().title = strArgOrig.substr(1, strArgOrig.size() - 2); Columns.back().type = CUSTOM_COLUMN0; } else { auto ItemIterator = std::find_if(CONST_RANGE(ColumnInfo, i) { return strArgName == i.Symbol; }); if (ItemIterator != std::cend(ColumnInfo)) Columns.back().type = ItemIterator->Type; } }
WorkerThreads(size_t threadCount=1) : shouldStop(false) { threads.reserve(threadCount); for (size_t i=0; i<threadCount; i++) threads.emplace_back(std::thread(&WorkerThreads::runWorker, this)); }
void create_audio_frame() override { frames.emplace_back(new AudioFrame(*this, "Untitled Audio", wxPoint(50, 50), wxSize(450, 340))); frames.back()->Show(true); }
void append(size_t size) { v_.emplace_back(); v_.back().resize(size, false); }
void Assign(std::future<void>&& future) { std::lock_guard<std::mutex> lock(mutex); futures.emplace_back(std::move(future)); EraseReady(); }
bool boolean(const bool val) { m_items.emplace_back(val); return true; }
bool integerNumber(const int64_t val) { m_items.emplace_back(val); return true; }
bool endArray(const std::size_t size) { m_items.emplace_back(Item::EndArray, size); return true; }
bool null() { m_items.emplace_back(Item::Null); return true; }
bool startArray() { m_items.emplace_back(Item::StartArray); return true; }
bool endObject(const std::size_t size) { m_items.emplace_back(Item::EndObject, size); return true; }
bool key(const std::string &str) { m_items.emplace_back(Item::Key, str); return true; }
inline void emplace(TArgs&&... mArgs) { particles.emplace_back(FWD(mArgs)...); }
bool doubleNumber(const double val) { m_items.emplace_back(val); return true; }
void IfcElectricMotor::getAttributes( std::vector<std::pair<std::string, shared_ptr<BuildingObject> > >& vec_attributes ) const { IfcEnergyConversionDevice::getAttributes( vec_attributes ); vec_attributes.emplace_back( std::make_pair( "PredefinedType", m_PredefinedType ) ); }
bool string(const std::string &str) { m_items.emplace_back(Item::String, str); return true; }
void Tracker::Visit(int node) { visited_nodes_.insert(node); walk.emplace_back(node); }
void addLightSource (const sf::Vector2f & position, const oak::Tweener & tweener, const sf::Color & color = sf::Color::White, sf::Uint8 minAlpha = sf::Uint8(0)) { lights.emplace_back(position, tweener, color, minAlpha); }
void Push(const std::string& name, std::string&& arg) { args.emplace_back(arg); names.emplace_back(name); }
void IfcCableSegment::getAttributes( std::vector<std::pair<std::string, shared_ptr<BuildingObject> > >& vec_attributes ) const { IfcFlowSegment::getAttributes( vec_attributes ); vec_attributes.emplace_back( std::make_pair( "PredefinedType", m_PredefinedType ) ); }
void RequestWorkloadStats::enter(State to) { if (m_s.empty()) return; transition(m_s.back(), to); m_s.emplace_back(to); m_transitionCounts[to]++; }
void EidosTypeInterpreter::_ProcessArgumentListTypes(const EidosASTNode *p_node, const EidosCallSignature *p_call_signature, std::vector<EidosASTNode *> &p_arguments) { const std::vector<EidosASTNode *> &node_children = p_node->children_; // Run through the argument nodes, evaluate them, and put the resulting pointers into the arguments buffer, // interleaving default arguments and handling named arguments as we go. auto node_children_end = node_children.end(); int sig_arg_index = 0; int sig_arg_count = (int)p_call_signature->arg_name_IDs_.size(); //bool had_named_argument = false; for (auto child_iter = node_children.begin() + 1; child_iter != node_children_end; ++child_iter) { EidosASTNode *child = *child_iter; if (sig_arg_index < sig_arg_count) { if (child->token_->token_type_ != EidosTokenType::kTokenAssign) { // We have a non-named argument; it will go into the next argument slot from the signature // In EidosInterpreter it is an error if had_named_argument is set here; here, we ignore that // If this argument is the very last thing in the script string, then the user is trying to complete on it; // in that case, we add potential matches to the completion list, providing autocompletion of argument names. // We may be completing off an identifier (with partial typing), or off a bad token (with no typing). // That token should be at or after the script end (if it is a bad token it may be immediately after, since // it may have gotten its position from an EOF at the end of the token stream). // BCH 6 April 2019: We may also be completing off of what appears to be a language keyword, such as "for" // trying to complete to "format=". We want to treat language keywords like identifiers here, if (argument_completions_ && (script_length_ <= (size_t)child->token_->token_end_ + 1)) { if ((child->token_->token_type_ == EidosTokenType::kTokenIdentifier) || (child->token_->token_type_ == EidosTokenType::kTokenBad) || (child->token_->token_type_ >= EidosTokenType::kFirstIdentifierLikeToken)) { // Check each argument in the signature as a possibility for completion for (int sig_arg_match_index = sig_arg_index; sig_arg_match_index < sig_arg_count; ++sig_arg_match_index) { EidosGlobalStringID arg_name_ID = p_call_signature->arg_name_IDs_[sig_arg_match_index]; const std::string &arg_name = Eidos_StringForGlobalStringID(arg_name_ID); // To be a completion match, the name must not be private API ('_' prefix) // Whether it is an acceptable completion in other respects will be checked by the completion engine if (arg_name[0] != '_') argument_completions_->push_back(arg_name); // If the argument we just examined is non-optional, we don't want to offer any further suggestions // since they would not be legal to supply in this position in the function/method call. if (!(p_call_signature->arg_masks_[sig_arg_match_index] & kEidosValueMaskOptional)) break; } } } // Advance to the next argument slot sig_arg_index++; } else { // We have a named argument; get information on it from its children const std::vector<EidosASTNode *> &child_children = child->children_; if (child_children.size() == 2) // other than 2 should never happen; raises in EidosInterpreter { EidosASTNode *named_arg_name_node = child_children[0]; EidosASTNode *named_arg_value_node = child_children[1]; // Get the identifier for the argument name EidosGlobalStringID named_arg_nameID = named_arg_name_node->cached_stringID_; // Now re-point child at the value node child = named_arg_value_node; // While this argument's name doesn't match the expected argument, insert default values for optional arguments do { EidosGlobalStringID arg_name_ID = p_call_signature->arg_name_IDs_[sig_arg_index]; if (named_arg_nameID == arg_name_ID) { sig_arg_index++; break; } // In EidosInterpreter it is an error if a named argument skips over a required argument; here we ignore that // In EidosInterpreter it is an error if an optional argument has no default; here we ignore that // arguments that receive the default value are represented in the argument list here with nullptr, since we have no node for them p_arguments.emplace_back(nullptr); // Move to the next signature argument sig_arg_index++; if (sig_arg_index == sig_arg_count) break; // this is an error in EidosInterpreter; here we just break out to add the named argument after all the signature args } while (true); //had_named_argument = true; } } } else { // We're beyond the end of the signature's arguments; in EidosInterpreter this is complicated because of ellipsis args, here we just let it go } // The child pointer is an argument node, so remember it p_arguments.emplace_back(child); } // Handle any remaining arguments in the signature while (sig_arg_index < sig_arg_count) { // In EidosInterpreter it is an error if a non-optional argument remains unmatched; here we ignore that // In EidosInterpreter it is an error if an optional argument has no default; here we ignore that // arguments that receive the default value are represented in the argument list here with nullptr, since we have no node for them p_arguments.emplace_back(nullptr); sig_arg_index++; } }
int LoadTextures() { int error_count = 0; GLint topology_uniform = gTexCubeShader->GetUniformLocation("topology_sampler"); const char* topology_filename = "gray50.tga"; if(topology_uniform >= 0) { gTextures.emplace_back(new akj::cGLTexture("topology texture")); gTextures.back()->CreateTexture2D(topology_filename, false/*is_srgb*/, -1); gTexCubeShader->Use(); glUniform1i(topology_uniform, gTextures.back()->GetBoundTextureUnit()); error_count += akj::glCheckAllErrors(__FILE__, __LINE__); } GLint diffuse_uniform = gTexCubeShader->GetUniformLocation("diffuse_sampler"); const char* diffuse_filename = "coldcolors.tga"; if(diffuse_uniform >= 0) { gTextures.emplace_back(new akj::cGLTexture("diffuse color texture")); gTextures.back()->CreateTexture2D(diffuse_filename, true/*is_srgb*/, -1); gTexCubeShader->Use(); glUniform1i(diffuse_uniform, gTextures.back()->GetBoundTextureUnit()); error_count += akj::glCheckAllErrors(__FILE__, __LINE__); } GLint light_params_uniform = gTexCubeShader->GetUniformLocation("light_params_sampler"); const char* light_params_filename = "gray50.tga"; if(light_params_uniform >= 0) { gTextures.emplace_back(new akj::cGLTexture("light mapping texture")); gTextures.back()->CreateTexture2D(light_params_filename, false/*is_srgb*/, -1); gTexCubeShader->Use(); glUniform1i(light_params_uniform, gTextures.back()->GetBoundTextureUnit()); error_count += akj::glCheckAllErrors(__FILE__, __LINE__); } GLint texcube_refl_cube_uniform = gTexCubeShader->GetUniformLocation("detailed_cubemap"); GLint background_refl_cube_uniform = gBackgroundShader->GetUniformLocation("my_enviro_map"); const char* detailed_cube_filename = "cube_map.jpg"; if(texcube_refl_cube_uniform >= 0 || background_refl_cube_uniform >= 0) { gTextures.emplace_back(new akj::cGLTexture("detailed cube texture")); gTextures.back()->CreateCubeMap(detailed_cube_filename, true /*is_srgb*/); gTexCubeShader->Use(); glUniform1i(texcube_refl_cube_uniform, gTextures.back()->GetBoundTextureUnit()); gBackgroundShader->Use(); glUniform1i(background_refl_cube_uniform, gTextures.back()->GetBoundTextureUnit()); error_count += akj::glCheckAllErrors(__FILE__, __LINE__); } GLint diffuse_cube_uniform = gTexCubeShader->GetUniformLocation("diffuse_cubemap"); const char* diffuse_cube_filename = "diffuse_map.jpg"; if(diffuse_cube_uniform >= 0) { gTextures.emplace_back(new akj::cGLTexture("diffuse cube texture")); //want the ambient light to be lighter, hence no srgb gTextures.back()->CreateCubeMap(diffuse_cube_filename, false/*is_srgb*/); gTexCubeShader->Use(); glUniform1i(diffuse_cube_uniform, gTextures.back()->GetBoundTextureUnit()); error_count += akj::glCheckAllErrors(__FILE__, __LINE__); } return error_count; }
bool GenTestDocsApp::getOptions() { int c; const char *optArgument = NULL; int longopt_index = 0; static struct option longopts[] = { { "basedir", 1, NULL, 0 }, { "consttextfield", 1, NULL, 0 }, { "prefixtextfield", 1, NULL, 0 }, { "randtextfield", 1, NULL, 0 }, { "modtextfield", 1, NULL, 0 }, { "idtextfield", 1, NULL, 0 }, { "randintfield", 1, NULL, 0 }, { "docidlimit", 1, NULL, 0 }, { "mindocid", 1, NULL, 0 }, { "numwords", 1, NULL, 0 }, { "doctype", 1, NULL, 0 }, { "headers", 0, NULL, 0 }, { "json", 0, NULL, 0 }, { NULL, 0, NULL, 0 } }; enum longopts_enum { LONGOPT_BASEDIR, LONGOPT_CONSTTEXTFIELD, LONGOPT_PREFIXTEXTFIELD, LONGOPT_RANDTEXTFIELD, LONGOPT_MODTEXTFIELD, LONGOPT_IDTEXTFIELD, LONGOPT_RANDINTFIELD, LONGOPT_DOCIDLIMIT, LONGOPT_MINDOCID, LONGOPT_NUMWORDS, LONGOPT_DOCTYPE, LONGOPT_HEADERS, LONGOPT_JSON }; int optIndex = 2; while ((c = _app.GetOptLong("v", optArgument, optIndex, longopts, &longopt_index)) != -1) { FieldGenerator::SP g; switch (c) { case 0: switch (longopt_index) { case LONGOPT_BASEDIR: _baseDir = optArgument; break; case LONGOPT_CONSTTEXTFIELD: _fields.emplace_back(std::make_shared<ConstTextFieldGenerator>(splitArg(optArgument))); break; case LONGOPT_PREFIXTEXTFIELD: _fields.emplace_back(std::make_shared<PrefixTextFieldGenerator>(splitArg(optArgument))); break; case LONGOPT_RANDTEXTFIELD: g.reset(new RandTextFieldGenerator(optArgument, _rnd, _numWords, 20, 50)); _fields.push_back(g); break; case LONGOPT_MODTEXTFIELD: g.reset(new ModTextFieldGenerator(optArgument, _rnd, _mods)); _fields.push_back(g); break; case LONGOPT_IDTEXTFIELD: g.reset(new IdTextFieldGenerator(optArgument)); _fields.push_back(g); break; case LONGOPT_RANDINTFIELD: g.reset(new RandIntFieldGenerator(optArgument, _rnd, 0, 100000)); _fields.push_back(g); break; case LONGOPT_DOCIDLIMIT: _docIdLimit = atoi(optArgument); break; case LONGOPT_MINDOCID: _minDocId = atoi(optArgument); break; case LONGOPT_NUMWORDS: _numWords = atoi(optArgument); break; case LONGOPT_DOCTYPE: _docType = optArgument; break; case LONGOPT_HEADERS: _headers = true; break; case LONGOPT_JSON: _json = true; break; default: if (optArgument != NULL) { LOG(error, "longopt %s with arg %s", longopts[longopt_index].name, optArgument); } else { LOG(error, "longopt %s", longopts[longopt_index].name); } } break; case 'v': _verbose = true; break; default: return false; } } _optIndex = optIndex; if (_optIndex >= _app._argc) { return false; } _outFile = _app._argv[optIndex]; return true; }
/// Recursively traverse the CFG of the function, renaming loads and /// stores to the allocas which we are promoting. /// /// IncomingVals indicates what value each Alloca contains on exit from the /// predecessor block Pred. void PromoteMem2Reg::RenamePass(BasicBlock *BB, BasicBlock *Pred, RenamePassData::ValVector &IncomingVals, RenamePassData::LocationVector &IncomingLocs, std::vector<RenamePassData> &Worklist) { NextIteration: // If we are inserting any phi nodes into this BB, they will already be in the // block. if (PHINode *APN = dyn_cast<PHINode>(BB->begin())) { // If we have PHI nodes to update, compute the number of edges from Pred to // BB. if (PhiToAllocaMap.count(APN)) { // We want to be able to distinguish between PHI nodes being inserted by // this invocation of mem2reg from those phi nodes that already existed in // the IR before mem2reg was run. We determine that APN is being inserted // because it is missing incoming edges. All other PHI nodes being // inserted by this pass of mem2reg will have the same number of incoming // operands so far. Remember this count. unsigned NewPHINumOperands = APN->getNumOperands(); unsigned NumEdges = std::count(succ_begin(Pred), succ_end(Pred), BB); assert(NumEdges && "Must be at least one edge from Pred to BB!"); // Add entries for all the phis. BasicBlock::iterator PNI = BB->begin(); do { unsigned AllocaNo = PhiToAllocaMap[APN]; // Update the location of the phi node. updateForIncomingValueLocation(APN, IncomingLocs[AllocaNo], APN->getNumIncomingValues() > 0); // Add N incoming values to the PHI node. for (unsigned i = 0; i != NumEdges; ++i) APN->addIncoming(IncomingVals[AllocaNo], Pred); // The currently active variable for this block is now the PHI. IncomingVals[AllocaNo] = APN; for (DbgVariableIntrinsic *DII : AllocaDbgDeclares[AllocaNo]) ConvertDebugDeclareToDebugValue(DII, APN, DIB); // Get the next phi node. ++PNI; APN = dyn_cast<PHINode>(PNI); if (!APN) break; // Verify that it is missing entries. If not, it is not being inserted // by this mem2reg invocation so we want to ignore it. } while (APN->getNumOperands() == NewPHINumOperands); } } // Don't revisit blocks. if (!Visited.insert(BB).second) return; for (BasicBlock::iterator II = BB->begin(); !II->isTerminator();) { Instruction *I = &*II++; // get the instruction, increment iterator if (LoadInst *LI = dyn_cast<LoadInst>(I)) { AllocaInst *Src = dyn_cast<AllocaInst>(LI->getPointerOperand()); if (!Src) continue; DenseMap<AllocaInst *, unsigned>::iterator AI = AllocaLookup.find(Src); if (AI == AllocaLookup.end()) continue; Value *V = IncomingVals[AI->second]; // If the load was marked as nonnull we don't want to lose // that information when we erase this Load. So we preserve // it with an assume. if (AC && LI->getMetadata(LLVMContext::MD_nonnull) && !isKnownNonZero(V, SQ.DL, 0, AC, LI, &DT)) addAssumeNonNull(AC, LI); // Anything using the load now uses the current value. LI->replaceAllUsesWith(V); BB->getInstList().erase(LI); } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) { // Delete this instruction and mark the name as the current holder of the // value AllocaInst *Dest = dyn_cast<AllocaInst>(SI->getPointerOperand()); if (!Dest) continue; DenseMap<AllocaInst *, unsigned>::iterator ai = AllocaLookup.find(Dest); if (ai == AllocaLookup.end()) continue; // what value were we writing? unsigned AllocaNo = ai->second; IncomingVals[AllocaNo] = SI->getOperand(0); // Record debuginfo for the store before removing it. IncomingLocs[AllocaNo] = SI->getDebugLoc(); for (DbgVariableIntrinsic *DII : AllocaDbgDeclares[ai->second]) ConvertDebugDeclareToDebugValue(DII, SI, DIB); BB->getInstList().erase(SI); } } // 'Recurse' to our successors. succ_iterator I = succ_begin(BB), E = succ_end(BB); if (I == E) return; // Keep track of the successors so we don't visit the same successor twice SmallPtrSet<BasicBlock *, 8> VisitedSuccs; // Handle the first successor without using the worklist. VisitedSuccs.insert(*I); Pred = BB; BB = *I; ++I; for (; I != E; ++I) if (VisitedSuccs.insert(*I).second) Worklist.emplace_back(*I, Pred, IncomingVals, IncomingLocs); goto NextIteration; }
/** Import one and only one function vector input */ void GeneratePeaks::importPeakFromVector( std::vector<std::pair<double, API::IFunction_sptr>> &functionmap) { API::CompositeFunction_sptr compfunc = boost::make_shared<API::CompositeFunction>(); // Set up and clone peak function if (m_useRawParameter) { // Input vector of values are for raw parameter name size_t numpeakparams = m_peakFunction->nParams(); if (m_vecPeakParamValues.size() == numpeakparams) { for (size_t i = 0; i < numpeakparams; ++i) m_peakFunction->setParameter(i, m_vecPeakParamValues[i]); } else { // Number of input parameter values is not correct. Throw! std::stringstream errss; errss << "Number of input peak parameters' value (" << m_vecPeakParamValues.size() << ") is not correct (should be " << numpeakparams << " for peak of type " << m_peakFunction->name() << "). "; throw std::runtime_error(errss.str()); } } else { // Input vector of values are for effective parameter names if (m_vecPeakParamValues.size() != 3) throw std::runtime_error("Input peak parameters must have 3 numbers for " "effective parameter names."); m_peakFunction->setCentre(m_vecPeakParamValues[0]); m_peakFunction->setHeight(m_vecPeakParamValues[1]); m_peakFunction->setFwhm(m_vecPeakParamValues[2]); } compfunc->addFunction(m_peakFunction->clone()); // Set up and clone background function if (m_genBackground) { size_t numbkgdparams = m_bkgdFunction->nParams(); if (m_useRawParameter) { // Raw background parameters if (m_vecBkgdParamValues.size() != numbkgdparams) throw std::runtime_error( "Number of background parameters' value is not correct. "); else { for (size_t i = 0; i < numbkgdparams; ++i) m_bkgdFunction->setParameter(i, m_vecBkgdParamValues[i]); } } else { // Effective background parameters if (m_vecBkgdParamValues.size() < 3 && m_vecBkgdParamValues.size() < numbkgdparams) { throw std::runtime_error( "There is no enough effective background parameter values."); } // FIXME - Assume that all background functions define parameter i for A_i for (size_t i = 0; i < numbkgdparams; ++i) m_bkgdFunction->setParameter(i, m_vecBkgdParamValues[i]); } compfunc->addFunction(m_bkgdFunction->clone()); } // Set up function map functionmap.emplace_back(m_peakFunction->centre(), compfunc); }
bool OSLInput::open (const std::string &name, ImageSpec &newspec, const ImageSpec &config) { // std::cout << "OSLInput::open \"" << name << "\"\n"; setup_shadingsys (); std::vector<std::pair<string_view,string_view> > args; string_view shadername = deconstruct_uri (name, &args); if (shadername.empty()) return false; if (! Strutil::ends_with (shadername, ".osl") && ! Strutil::ends_with (shadername, ".oso") && ! Strutil::ends_with (shadername, ".oslgroup") && ! Strutil::ends_with (shadername, ".oslbody")) return false; m_filename = name; m_topspec = ImageSpec (1024, 1024, 4, TypeDesc::FLOAT); // std::cout << " name = " << shadername << " args? " << args.size() << "\n"; for (size_t i = 0; i < args.size(); ++i) { // std::cout << " " << args[i].first << " = " << args[i].second << "\n"; if (args[i].first == "RES") { parse_res (args[i].second, m_topspec.width, m_topspec.height, m_topspec.depth); } else if (args[i].first == "TILE" || args[i].first == "TILES") { parse_res (args[i].second, m_topspec.tile_width, m_topspec.tile_height, m_topspec.tile_depth); } else if (args[i].first == "OUTPUT") { m_outputs.emplace_back(args[i].second); } else if (args[i].first == "MIP") { m_mip = Strutil::from_string<int>(args[i].second); } else if (args[i].first.size() && args[i].second.size()) { parse_param (args[i].first, args[i].second, m_topspec); } } if (m_outputs.empty()) { m_outputs.emplace_back("result"); m_outputs.emplace_back("alpha"); } m_topspec.full_x = m_topspec.x; m_topspec.full_y = m_topspec.y; m_topspec.full_z = m_topspec.z; m_topspec.full_width = m_topspec.width; m_topspec.full_height = m_topspec.height; m_topspec.full_depth = m_topspec.depth; bool ok = true; if (Strutil::ends_with (shadername, ".oslgroup")) { // Serialized group // No further processing necessary std::string groupspec; if (! OIIO::Filesystem::read_text_file (shadername, groupspec)) { // If it didn't name a disk file, assume it's the "inline" // serialized group. groupspec = groupspec.substr (0, groupspec.size()-9); } // std::cout << "Processing group specification:\n---\n" // << groupspec << "\n---\n"; OIIO::lock_guard lock (shading_mutex); m_group = shadingsys->ShaderGroupBegin ("", "surface", groupspec); if (! m_group) return false; // Failed shadingsys->ShaderGroupEnd (); } if (Strutil::ends_with (shadername, ".oso")) { // Compiled shader OIIO::lock_guard lock (shading_mutex); shadername.remove_suffix (4); m_group = shadingsys->ShaderGroupBegin (); for (size_t p = 0, np = m_topspec.extra_attribs.size(); p < np; ++p) { const ParamValue &pv (m_topspec.extra_attribs[p]); shadingsys->Parameter (pv.name(), pv.type(), pv.data(), pv.interp() == ParamValue::INTERP_CONSTANT); } if (! shadingsys->Shader ("surface", shadername, "" /*layername*/ )) { error ("y %s", errhandler.haserror() ? errhandler.geterror() : std::string("OSL error")); ok = false; } shadingsys->ShaderGroupEnd (); } if (Strutil::ends_with (shadername, ".osl")) { // shader source } if (Strutil::ends_with (shadername, ".oslbody")) { // shader source OIIO::lock_guard lock (shading_mutex); shadername.remove_suffix (8); static int exprcount = 0; std::string exprname = OIIO::Strutil::format("expr_%d", exprcount++); std::string sourcecode = "shader " + exprname + " (\n" " float s = u [[ int lockgeom=0 ]],\n" " float t = v [[ int lockgeom=0 ]],\n" " output color result = 0,\n" " output float alpha = 1,\n" " )\n" "{\n" " " + std::string(shadername) + "\n" " ;\n" "}\n"; // std::cout << "Expression-based shader text is:\n---\n" // << sourcecode << "---\n"; std::string err; if (! compile_buffer (sourcecode, exprname, err)) { error ("%s", err); return false; } m_group = shadingsys->ShaderGroupBegin (); for (size_t p = 0, np = m_topspec.extra_attribs.size(); p < np; ++p) { const ParamValue &pv (m_topspec.extra_attribs[p]); shadingsys->Parameter (pv.name(), pv.type(), pv.data(), pv.interp() == ParamValue::INTERP_CONSTANT); } shadingsys->Shader ("surface", exprname, "" /*layername*/) ; shadingsys->ShaderGroupEnd (); } if (!ok || m_group.get() == NULL) return false; shadingsys->attribute (m_group.get(), "renderer_outputs", TypeDesc(TypeDesc::STRING,m_outputs.size()), &m_outputs[0]); #if OIIO_PLUGIN_VERSION < 21 return ok && seek_subimage (0, 0, newspec); #else ok &= seek_subimage (0, 0); if (ok) newspec = spec(); else close (); return ok; #endif }
void stitch::Vec3::equidistantVectors_IcosahedronBased(const size_t minimumNumVectors, std::vector<stitch::Vec3> &vectors, std::vector<size_t> &binIndices) { vectors.clear(); binIndices.clear(); stitch::KDTree kdTree;//Keep a tame kd-tree on the side for efficient searching of duplicate vertices to be merged while sub-dividing. //====================================================== //Start with icosahedron. //Note - For refinement of icosahedron: // Faces_0 = 20, Edges_0 = 30, Vertices_0 = 12 // Faces_n = Faces_(n-1) * 4 // Edges_n = Edges_(n-1) * 2 + Faces_(t-1) * 3 // Vertices_n = Vertices_(n-1) + Edges_(n-1) const float phi=atanf(0.5f); #ifdef USE_CXX11 vectors.emplace_back(0.0f, 0.0f, 1.0f); #else vectors.push_back(Vec3(0.0f, 0.0f, 1.0f)); #endif for (size_t i=0; i<5; ++i) { #ifdef USE_CXX11 vectors.emplace_back(cosf((i*72.0f/180.f) * ((float)M_PI))*cosf(phi), sinf((i*72.0f/180.f) * ((float)M_PI))*cosf(phi), ( 1.0f )*sinf(phi)); #else vectors.push_back(Vec3(cosf((i*72.0f/180.f) * ((float)M_PI))*cosf(phi), sinf((i*72.0f/180.f) * ((float)M_PI))*cosf(phi), ( 1.0f )*sinf(phi))); #endif binIndices.push_back(0); binIndices.push_back(((i+0)%5) + 1); binIndices.push_back(((i+1)%5) + 1); } for (size_t i=0; i<5; ++i) { #ifdef USE_CXX11 vectors.emplace_back(cosf(((i+0.5f)*72.0f/180.f) * ((float)M_PI))*cosf(-phi), sinf(((i+0.5f)*72.0f/180.f) * ((float)M_PI))*cosf(-phi), ( 1.0f )*sinf(-phi)); #else vectors.push_back(Vec3(cosf(((i+0.5f)*72.0f/180.f) * ((float)M_PI))*cosf(-phi), sinf(((i+0.5f)*72.0f/180.f) * ((float)M_PI))*cosf(-phi), ( 1.0f )*sinf(-phi))); #endif binIndices.push_back(((i+0)%5) + 1); binIndices.push_back(((i+0)%5) + 6); binIndices.push_back(((i+1)%5) + 1); binIndices.push_back(((i+0)%5) + 6); binIndices.push_back(((i+1)%5) + 6); binIndices.push_back(((i+1)%5) + 1); } #ifdef USE_CXX11 vectors.emplace_back(0.0f, 0.0f, -1.0f); #else vectors.push_back(Vec3(0.0f, 0.0f, -1.0f)); #endif for (size_t i=0; i<5; ++i) { binIndices.push_back(((i+1)%5) + 6); binIndices.push_back(((i+0)%5) + 6); binIndices.push_back(11); } //====================================================== //Subdivide the icosahedron until number of vertices>=minimumNumVertices. while (vectors.size()<minimumNumVectors) { size_t numBinIndices=binIndices.size(); for (size_t indexNum=0; indexNum<numBinIndices; indexNum+=3) { size_t i0=binIndices[indexNum+0]; size_t i1=binIndices[indexNum+1]; size_t i2=binIndices[indexNum+2]; const stitch::Vec3 v0=vectors[i0]; const stitch::Vec3 v1=vectors[i1]; const stitch::Vec3 v2=vectors[i2]; stitch::Vec3 v01=(v0+v1); v01.normalise(); stitch::Vec3 v12=(v1+v2); v12.normalise(); stitch::Vec3 v20=(v2+v0); v20.normalise(); int32_t i01=-1; int32_t i12=-1; int32_t i20=-1; //=== Check if any of the new vertices already exist === {//Need to have distance epsilon? const float similarity_epsilon=0.00001f; float radius01=1.0f; stitch::BoundingVolume *bv01=kdTree.getNearest(v01, radius01); float radius12=1.0f; stitch::BoundingVolume *bv12=kdTree.getNearest(v12, radius12); float radius20=1.0f; stitch::BoundingVolume *bv20=kdTree.getNearest(v20, radius20); if (bv01) { const uint32_t vertexNum01=bv01->userIndex_; if ( Vec3::calcDistToPointSq(vectors[vertexNum01], v01) < similarity_epsilon ) { i01=vertexNum01; } } if (bv12) { const uint32_t vertexNum12=bv12->userIndex_; if ( Vec3::calcDistToPointSq(vectors[vertexNum12], v12) < similarity_epsilon ) { i12=vertexNum12; } } if (bv20) { const uint32_t vertexNum20=bv20->userIndex_; if ( Vec3::calcDistToPointSq(vectors[vertexNum20], v20) < similarity_epsilon ) { i20=vertexNum20; } } } //=== ===// if (i01<0) {//This is a new vertex, so add it. vectors.push_back(v01); i01=vectors.size()-1; kdTree.addItem(new stitch::BoundingVolume(vectors[vectors.size()-1], 0.0f, vectors.size()-1)); } if (i12<0) {//This is a new vertex, so add it. vectors.push_back(v12); i12=vectors.size()-1; kdTree.addItem(new stitch::BoundingVolume(vectors[vectors.size()-1], 0.0f, vectors.size()-1)); } if (i20<0) {//This is a new vertex, so add it. vectors.push_back(v20); i20=vectors.size()-1; kdTree.addItem(new stitch::BoundingVolume(vectors[vectors.size()-1], 0.0f, vectors.size()-1)); } std::vector<stitch::Vec3> splitAxisVec; splitAxisVec.push_back(Vec3(1.0f, 0.0f, 0.0f)); splitAxisVec.push_back(Vec3(0.0f, 1.0f, 0.0f)); splitAxisVec.push_back(Vec3(0.0f, 0.0f, 1.0f)); kdTree.build(KDTREE_DEFAULT_CHUNK_SIZE, 0, 1000, splitAxisVec); { binIndices[indexNum+0]=i0; binIndices[indexNum+1]=i01; binIndices[indexNum+2]=i20; } { binIndices.push_back(i01); binIndices.push_back(i12); binIndices.push_back(i20); } { binIndices.push_back(i20); binIndices.push_back(i12); binIndices.push_back(i2); } { binIndices.push_back(i01); binIndices.push_back(i1); binIndices.push_back(i12); } } } }