C++ TypeDesc::elementtype方法代码示例

static void
parse_elements (const std::string &name, TypeDesc type, const std::string &type_code,
     const std::string &elements, int num_elements, ImageIOParameter &param)
{
    void *data = new T[num_elements];
    char *data_ptr = (char *) data;
    size_t element_size = type.elementtype().elementsize ();

    boost::char_separator<char> sep (", ");
    boost::tokenizer<boost::char_separator<char> > tokens (elements, sep);
    BOOST_FOREACH (std::string element, tokens) {
        sscanf (element.c_str (), type_code.c_str (), (T *)data_ptr);
        data_ptr += element_size;
    }

void
OSLCompilerImpl::write_oso_const_value (const ConstantSymbol *sym) const
{
    ASSERT (sym);
    TypeDesc type = sym->typespec().simpletype();
    TypeDesc elemtype = type.elementtype();
    int nelements = std::max (1, type.arraylen);
    if (elemtype == TypeDesc::STRING)
        for (int i = 0;  i < nelements;  ++i)
            oso ("\"%s\"%s", sym->strval(i).c_str(), nelements>1 ? " " : "");
    else if (elemtype == TypeDesc::INT)
        for (int i = 0;  i < nelements;  ++i)
            oso ("%d%s", sym->intval(i), nelements>1 ? " " : "");
    else if (elemtype == TypeDesc::FLOAT)
        for (int i = 0;  i < nelements;  ++i)
            oso ("%.8g%s", sym->floatval(i), nelements>1 ? " " : "");
    else if (equivalent (elemtype, TypeDesc::TypeVector))
        for (int i = 0;  i < nelements;  ++i)
            oso ("%.8g %.8g %.8g%s", sym->vecval(i)[0], sym->vecval(i)[1],
                 sym->vecval(i)[2], nelements>1 ? " " : "");
    else {
        ASSERT (0 && "Don't know how to output this constant type");
    }
}

int
RendererServices::pointcloud_get (ShaderGlobals *sg,
                                  ustring filename, size_t *indices, int count,
                                  ustring attr_name, TypeDesc attr_type,
                                  void *out_data)
{
#if USE_PARTIO
    if (! count)
        return 1;  // always succeed if not asking for any data

    PointCloud *pc = PointCloud::get(filename);
    if (pc == NULL) { // The file failed to load
        sg->context->shadingsys().error ("pointcloud_get: could not open \"%s\"", filename.c_str());
        return 0;
    }
    spin_lock lock (pc->m_mutex);
    Partio::ParticlesDataMutable *cloud = pc->m_partio_cloud;
    if (cloud == NULL) { // The file failed to load
        sg->context->shadingsys().error ("pointcloud_get: could not open \"%s\"", filename.c_str());
        return 0;
    }

    // lookup the ParticleAttribute pointer needed for a query
    Partio::ParticleAttribute *attr = pc->m_attributes[attr_name].get();
    if (! attr) {
        sg->context->shadingsys().error ("Accessing unexisting attribute %s in pointcloud \"%s\"", attr_name.c_str(), filename.c_str());
        return 0;
    }

    // Now make sure that types are compatible
    TypeDesc element_type = attr_type.elementtype ();
    int attr_partio_type = 0;

    // Convert the OSL (OIIO) type to the equivalent Partio type
    if (element_type == TypeDesc::TypeFloat)
        attr_partio_type = Partio::FLOAT;
    else if (element_type == TypeDesc::TypeInt)
        attr_partio_type = Partio::INT;
    else if (element_type == TypeDesc::TypeColor  || element_type == TypeDesc::TypePoint ||
             element_type == TypeDesc::TypeVector || element_type == TypeDesc::TypeNormal)
        attr_partio_type = Partio::VECTOR;
    else {
        // error ("Unsupported attribute type %s for pointcloud query in attribute %s",
        //       element_type.c_str(), attr_name.c_str());
        return 0;
    }

    // Finally check for some equivalent types like float3 and vector
    if (!compatiblePartioType(attr, attr_partio_type)) {
        sg->context->shadingsys().error ("Type of attribute \"%s\" : %s[%d] not compatible with OSL's %s in \"%s\" pointcloud",
                    attr_name.c_str(), partioTypeString(attr), attr->count,
                    element_type.c_str(), filename.c_str());
        return 0;
    }

    ASSERT (sizeof(size_t) == sizeof(Partio::ParticleIndex) &&
            "Only will work if Partio ParticleIndex is the size of a size_t");
    // FIXME -- if anybody cares about an architecture in which that is not
    // the case, we can easily allocate local space to retrieve the indices,
    // then copy them back to the caller's indices.

    // Actual data query
    cloud->data (*attr, count, (Partio::ParticleIndex *)indices,
                 true, out_data);
    return 1;
#else
    return 0;
#endif
}

static bool
grep_file (const std::string &filename, boost::regex &re,
           bool ignore_nonimage_files=false)
{
    if (! Filesystem::exists (filename)) {
        std::cerr << "igrep: " << filename << ": No such file or directory\n";
        return false;
    }

    if (Filesystem::is_directory (filename)) {
        if (! recursive)
            return false;
        if (print_dirs) {
            std::cout << "(" << filename << "/)\n";
            std::cout.flush();
        }
        bool r = false;
        std::vector<std::string> directory_entries;
        Filesystem::get_directory_entries (filename, directory_entries);
        for (size_t i = 0, e = directory_entries.size(); i < e; ++i)
            r |= grep_file (directory_entries[i], re, true);
        return r;
    }

    std::unique_ptr<ImageInput> in (ImageInput::open (filename.c_str()));
    if (! in.get()) {
        if (! ignore_nonimage_files)
            std::cerr << geterror() << "\n";
        return false;
    }
    ImageSpec spec = in->spec();

    if (file_match) {
        bool match = boost::regex_search (filename, re);
        if (match && ! invert_match) {
            std::cout << filename << "\n";
            return true;
        }
    }

    bool found = false;
    int subimage = 0;
    do {
        if (!all_subimages && subimage > 0)
            break;
        for (auto&& p : spec.extra_attribs) {
            TypeDesc t = p.type();
            if (t.elementtype() == TypeDesc::STRING) {
                int n = t.numelements();
                for (int i = 0;  i < n;  ++i) {
                    bool match = boost::regex_search (((const char **)p.data())[i], re);
                    found |= match;
                    if (match && ! invert_match) {
                        if (list_files) {
                            std::cout << filename << "\n";
                            return found;
                        }
                        std::cout << filename << ": " << p.name() << " = " 
                                  << ((const char **)p.data())[i] << "\n";
                    }
                }
            }
        }
    } while (in->seek_subimage (++subimage, 0, spec));

    if (invert_match) {
        found = !found;
        if (found)
            std::cout << filename << "\n";
    }
    return found;
}