opensubdiv-petite-sys 0.3.1

Low-level wrapper around parts of Pixar’s OpenSubdiv
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//
//   Copyright 2013 Pixar
//
//   Licensed under the terms set forth in the LICENSE.txt file available at
//   https://opensubdiv.org/license.
//

#ifndef SHAPE_UTILS_H
#define SHAPE_UTILS_H

#include <string>
#include <vector>
#include <map>

//------------------------------------------------------------------------------

enum Scheme {
  kBilinear=0,
  kCatmark,
  kLoop
};

struct ShapeDesc 
{
    ShapeDesc(char const * iname, std::string const & idata, Scheme ischeme,
        bool iIsLeftHanded = false) :
        name(iname), data(idata), scheme(ischeme), isLeftHanded(iIsLeftHanded) 
	{ }

    std::string name;
    std::string data;
    Scheme      scheme;
    bool        isLeftHanded;
};

//------------------------------------------------------------------------------

struct Shape {
    // full(er) spec here: http://paulbourke.net/dataformats/mtl/
    struct material {

        material();

        std::string name;

        float ka[3],         // ambient
              kd[3],         // diffuse
              ks[3],         // specular
              ns,            // specular exponent
              ni,            // optical density (1.0=no refraction, glass=1.5)
              sharpness,     // reflection sharpness
              tf[3],         // transmission filter
              d;             // dissolve factor (1.0 = opaque)

        int illum;
    };

    struct tag {

        static tag * parseTag(char const * stream);

        std::string genTag() const;

        std::string              name;
        std::vector<int>         intargs;
        std::vector<float>       floatargs;
        std::vector<std::string> stringargs;
    };

    static Shape * parseObj(ShapeDesc const & shapeDesc, bool parsemtl=false);
    static Shape * parseObj(char const * shapeString, Scheme shapeScheme,
                            bool isLeftHanded=false, bool parsemtl=false);

    void parseMtllib(char const * stream);

    std::string genShape(char const * name) const;

    std::string genObj() const;

    std::string genRIB() const;

    Shape() : scheme(kCatmark), isLeftHanded(false) { }

    ~Shape();

    int GetNumVertices() const { return (int)verts.size()/3; }

    int GetNumFaces() const { return (int)nvertsPerFace.size(); }

    bool HasUV() const { return ! (uvs.empty() || faceuvs.empty()); }

    int GetFVarWidth() const { return HasUV() ? 2 : 0; }

    std::vector<float>      verts;
    std::vector<float>      uvs;
    std::vector<float>      normals;
    std::vector<int>        nvertsPerFace;
    std::vector<int>        faceverts;
    std::vector<int>        faceuvs;
    std::vector<int>        facenormals;
    std::vector<tag *>      tags;
    Scheme                  scheme;
    bool                    isLeftHanded;

    char FindMaterial(char const * name) {
        for (int i=0; i<(int)mtls.size(); ++i) {
            if (mtls[i]->name==name) {
                return (char) i;
            }
        }
        return -1;
    }

    std::string                 mtllib;
    std::vector<unsigned short> mtlbind;
    std::vector<material *>     mtls;
};

//------------------------------------------------------------------------------

#endif /* SHAPE_UTILS_H */