//创建一个新点，伴随给定点号的所有属性和组；
int addpoint(int geohandle, int point_number)
//创建一个新点，在指定位置；
int addpoint(int geohandle, vector pos)
Args
geohandle，待写入的几何体，仅0、geoself有效；
Return
返回新点的点号，未创建新点返回-1；
可使用返回值，通过setpointattrib函数设置新点属性，有可能不是最终的点号；

int pt = addpoint(0,{1,1,1});
setpointattrib(0,"a",pt,1);

//创建螺旋线
int pts[];
for(int i=0; i<chi('num'); i++){
    float x = cos(i*ch('ang')*$PI)*ch('rad');
    float z = sin(i*ch('ang')*$PI)*ch('rad');
    float y = i*ch('height');
    pts[i] = addpoint(0, set(x,y,z));    
}
addprim(0, 'polyline', pts);

addprim —— 添加面到几何体

//创建polygon或polyline，然后可使用addvertex添加顶点到面
//确保添加至少一个顶点到面，如处理空几何体可能引起奇怪的结果或失败
int addprim(int geohandle, string type)
//使用被点号指定的点，来创建prim
int addprim(int geohandle, string type, int pt0)
int addprim(int geohandle, string type, int pt0, int pt1)
int addprim(int geohandle, string type, int pt0, int pt1, int pt2)
int addprim(int geohandle, string type, int pt0, int pt1, int pt2, int pt3)
int addprim(int geohandle, string type, int pt0, int pt1, int pt2, int pt3, int pt4, int pt5, int pt6, int pt7)
//使用被点号数组指定的点，来创建prim
int addprim(int geohandle, string type, int points[])
//输出新prim对应的顶点号，然后可使用setvertexattrib函数设置顶点属性，可能不是最终的顶点号
void addprim(int &prim_num, int geohandle, string type, int pt0, int &vertices[])
void addprim(int &prim_num, int geohandle, string type, int pt0, int pt1, int &vertices[])
void addprim(int &prim_num, int geohandle, string type, int pt0, int pt1, int pt2, int &vertices[])
void addprim(int &prim_num, int geohandle, string type, int pt0, int pt1, int pt2, int pt3, int &vertices[])
void addprim(int &prim_num, int geohandle, string type, int pt0, int pt1, int pt2, int pt3, int pt4, int pt5, int pt6, int pt7, int &vertices[])
void addprim(int &prim_num, int geohandle, string type, int points[], int &vertices[])
Args
geohandle，待写入的几何体，仅0、geoself有效；
type，新面的类型；
"poly"，封闭的几何体，可使用0或更多的点；
"polyline"，打开的几何体，可使用0或更多的点；
"tet"，四面体Tetrahedron，要求4个点，不能添加顶点到prim；
“hex”，六面体Hexahedron，要求8个点，不能添加顶点到prim；
"sphere", "circle", "tube", "metaball", "metasquad"，创建对应类型的prim，半径和形状由内在变换属性控制，要求1个点，不能添加顶点到prim；
"AlembicRef", "PackedDisk"，创建对应类型的prim，要求1个点，不能添加顶点到prim；
Return
返回新prim的面号，未创建则返回-1；
可使用返回值，通过setprimattrib函数设置新面属性，有可能不是最终的面号；

//使用setprimintrinsic函数设置primitive’s transforms
matrix3 transform_value = {{0, 0, 0}, {0, 0, 0}, {1, 1, 1}};
setprimintrinsic(geoself(), "transform", prim, transform_value);

//也可设置Alembic/packed primitive intrinsics
setprimintrinsic(geoself(), "unexpandedfilename", prim, "test.bgeo");

int p0 = addpoint(0, chv("p0"));
int p1 = addpoint(0, chv("p1"));
int p2 = addpoint(0, chv("p2"));
int p3 = addpoint(0, chv("p3"));
int prim = addprim(0, "poly");
addvertex(0, prim, p0);
addvertex(0, prim, p1);
addvertex(0, prim, p2);
addvertex(0, prim, p3);

//创建圆锥体
int pts[];
int num = chi('num');
for(int i=0; i<num; i++){
    float x = cos(i*2*$PI/num)*ch('rad');
    float z = sin(i*2*$PI/num)*ch('rad');
    float y = i*ch('height');
    pts[i] = addpoint(0, set(x,y,z));    
}
addprim(0, 'poly', reverse(pts));

for(int i=0; i<chi('num'); i++){
    int pt = addpoint(0, set(0,2,0));
    addprim(0, 'poly', pts[i],pts[(i+1)%len(pts)], pt);
}

addvertex —— 添加一顶点到面

int addvertex(int geohandle, int prim_num, int point_num)
Args
geohandle，待写入的几何体，仅0、geoself有效；
Return
返回线性顶点索引，未创建则返回-1；
可使用返回值，通过setvertexattrib函数设置新顶点属性，有可能不是最终的顶点索引；

minpos —— 查找点离几何体表面最近的位置

//返回点离几何体最近点位置
vector minpos(<geometry>geometry, vector point)
//返回点离几何体最近点位置，在指定最大距离内
vector minpos(<geometry>geometry, vector point, float maxdist)
//返回点离几何体最近点位置，在指定面组内
vector minpos(<geometry>geometry, string primgroup, vector point)
//返回点离几何体最近点位置，在指定面组及最大距离内
vector minpos(<geometry>geometry, string primgroup, vector point, float maxdist)
Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
primgroup，面组；可使用类似@Cd.x>0来指定组（可能需要反斜杠转义），空字符串表示所有面；
point，指定的空间点位置；
maxdist，查找最大距离；
Return
最近点位置，未查找到最近点返回point；

注：等价于xyzdist + primuv；

nearpoint —— 查找离几何体最近的点

int nearpoint(<geometry>geometry, vector pt)
int nearpoint(<geometry>geometry, vector pt, float maxdist)
int nearpoint(<geometry>geometry, string ptgroup, vector pt)
int nearpoint(<geometry>geometry, string ptgroup, vector pt, float maxdist)
查找几何体上最近的点号，并不是表面的位置；
使用xyzdist可查找表面或曲线上最近点；

Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
ptgroup，点组，可使用SOP风格的组样式如0-10或@Cd.x>0.5，空字符串表示所有点；
pt，指定的空间点位置；
maxdist，最大查找距离；
Return
最近点号，未查找到返回-1；

nearpoints —— 查找离几何体所有最近的点

int[] nearpoints(<geometry>geometry, vector pt, float maxdist)
int[] nearpoints(<geometry>geometry, vector pt, float maxdist, int maxpts)
int[] nearpoints(<geometry>geometry, string ptgroup, vector pt, float maxdist)
int[] nearpoints(<geometry>geometry, string ptgroup, vector pt, float maxdist, int maxpts)
Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
ptgroup，点组，可使用SOP风格的组样式如0-10或@Cd.x>0.5，空字符串表示所有点；
pt，指定的空间点位置；
maxdist，最大查找距离；
maxpts，最大查找点数；
Return
返回搜索距离内的点号数组；

注，为避免重复连线，可使用条件@ptnum < pt ；搜索0号端口会包含自身点；

//查找端口1附近的点，并连线
vector point = chv("point");
int pts[] = nearpoints(1, point, ch("maxdist"), chi("maxpts"));
vector pos;
int pt0 = addpoint(0, point);
int pt1;
foreach(int pt; pts){
    pos = point(1, "P", pt);
    pt1 = addpoint(0, pos);
    addprim(0, "polyline", pt0, pt1);
}

//point层级，循环或solver；
//扩散，主动查找（只计算红色点@Cd.x>0.5，以红色点搜索周围点）；
//当前红色点搜索周围点，如红色则变为绿色（相当于已经搜索过了），否则设置为红色；
float dist = ch("maxdist")*fit01(rand(@ptnum),0.5,1);
int pts[] = nearpoints(0, @P, dist); //包括自身点

foreach(int pt; pts){
    vector cd = point(0, "Cd", pt);
    if(cd.x == 1) 
        setpointattrib(0, "Cd", @ptnum, {0,1,0}); 
    else if(cd.z == 1) 
        setpointattrib(0, "Cd", pt, {1,0,0});
}

//point层级，循环或solver；
//扩散，被动查找（即非active查找active）；
//每个点查找周围的start或active点并连线，然后自身变为active，查找到的active变start
if(i@group_start==0 && i@group_active==0){
    float dist = ch("maxdist")*fit01(rand(@ptnum),0.5,1);
    int pts[] = nearpoints(0, @P, dist);
    
    foreach(int pt; pts){
        //只要周围有点start内，设置自身为active，并连线
        if(inpointgroup(0, "start", pt)){ 
            setpointgroup(0, "active", @ptnum, 1);
            addprim(0, "polyline", @ptnum, pt);
            setpointattrib(0, 'Cd', @ptnum, set(1,0,0));
            break;
        }  
        //只要周围有点active内，设置自身为active，active点设置为start，并连线
        if(inpointgroup(0, "active", pt)){ 
            setpointgroup(0, "active", @ptnum, 1);
            setpointgroup(0, "active", pt, 0);
            setpointgroup(0, "start", pt, 1);
            addprim(0, "polyline", @ptnum, pt);
            break;
        }
    }
}

neighbour —— 下一个被连接到给定点的点号

int neighbour(<geometry>geometry, int point_num, int neighbour_num)
Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
point_num，指定的点号；
neighbour_num，将查找的邻居，邻居们没有特定的顺序；
neighbourcount，获取所有连接邻居的总数；
Return
超出邻居数，点超出范围或不存在，返回-1；

neighbours —— 所有被连接到给定点的点号

int[] neighbours(<geometry>geometry, int ptnum)
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；

//大致等价
int[] neighbours(int opinput, int ptnum)
{
    int i, n;
    int result[];
    n = neighbourcount(input, ptnum);
    resize(result, n);
    for (i = 0; i < n; i++)
        result[i] = neighbour(input, ptnum, i);
}

//detail层级，查找邻居点并连线
int conns[];
int cur_pt = int(npoints(1)*rand(ch('seed')+5.26));

if(find(conns, cur_pt)<0){
    int polyline = addprim(0, 'polyline');
    
    for(int i=0; i<chi('nums'); i++){    
        append(conns, cur_pt);
        
        vector pos = point(1,'P', cur_pt);
        int newpt = addpoint(0, pos);
        addvertex(0, polyline, newpt);
        
        //插值邻近的下一个点
        int npts[] = neighbours(1, cur_pt);
        int check=0;  
        //排除先前已经查找过的点
        foreach(int pt; npts){          
            if(find(conns, pt)<0 ){
                cur_pt = pt;
                check = 1;
                break;
            }            
        }
        //如周围路径点都查找过，即跳出    
        if(check==0)
            break;
    }
}

neighbourcount —— 被连接到给定点的点总数

int neighbourcount(<geometry>geometry, int point_num)
Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
point_num，指定的点号；
Return
指定点号超出范围或没有输入，返回0；

intersect —— 计算射线的第一个交点

int intersect(<geometry>geometry, vector orig, vector dir, vector &p, float &u, float &v)
int intersect(<geometry>geometry, vector orig, vector dir, vector &p, float &u, float &v, ...)
int intersect(<geometry>geometry, vector orig, vector dir, vector &p, vector &uvw)
int intersect(<geometry>geometry, string group, vector orig, vector dir, vector &p, vector &uvw)
Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
group，面组；
orig，射线起点；
dir，射线方向和最大距离；
&p，交点位置；
&u、&v、&uvw，在面上的参数化交点位置；
Return
交点面号，没有相交或错误返回-1；

注，当与metaball相交时，不能确定面号，将返回面总数；

vector origin = @P;
float max_dist = 1000;
vector dir = max_dist * normalize(@v);

vector isect_pos;
float isect_u, isect_v;
//返回第一个交点
int isect_prim = intersect(@OpInput2, origin, dir, isect_pos, isect_u, isect_v);
//返回最远交点
isect_prim = intersect(@OpInput2, origin, dir, isect_pos, isect_u, isect_v, "farthest", 1);

intersects —— 计算射线的所有交点

int intersect_all(<geometry>geometry, string group, vector orig, vector dir, vector &pos[], int &prim[], vector &uvw[], float tol=0.01, float ttol=0.01)
Args
<geometry>，当运行在一个节点context（如wrangle SOP）时，此参数可以是一个整数（表示输入端）；也可是一字符串（指定一几何体文件，如a.bgeo）；
group，面组；
orig，射线起点；
dir，射线方向和最大距离；
&pos[]，每一个交点位置；
&prim[]，每一个交点面号；
&uvw[]，每一个在面上的参数化交点坐标；
tol，是3D容差；ttol，是射线容差；当相交与边时可避免额外交点，获取所有不合并的交点，设置ttol=-1；
Return
交点总数，没有相交返回0；

注，当与metaball相交时，不能确定面号，将返回面总数；

vector p[], uvw[];
int prim[];
vector origin = chv("origin");
vector dir = normalize(chv("dir"))*ch("length");
int num = intersect_all(@OpInput2, origin, dir, p, prim, uvw);
foreach(vector pos; p){
    addpoint(0, pos);
}

pointprims —— 返回包含指定点的prim列表

int[] pointprims(geometry, int ptnum)
返回面号数组，升序且不重复；

pointvertices —— 返回连接到指定点的顶点列表

int[] pointvertices(<geometry>geometry, int ptnum)
返回被连接到给定点的顶点号数组，不依赖数字顺序；

pointvertex —— 返回与指定点共享的第一个顶点的线性顶点号

int pointvertex(<geometry>geometry, int point_num)
与指定点共享的第一个顶点的线性顶点号，可使用vertexnext去迭代其他顶点；

i[]@linearvertex;
@linearvertex[0] = pointvertex(0, 4);
for(int i=1; i<len(pointvertices(0,4)); i++){
    @linearvertex[i] = vertexnext(0, @linearvertex[i-1]);    
}

primpoints —— 返回指定prim上点的列表

int[] primpoints(geometry, int primnum)
返回点数组，和存储在面上的顺序相同；

//prim层级，对box几何体操作
int pts[] = primpoints(0, @primnum);
int newpts[];

//每个面点像面中心点方向创建新点
foreach(int pt; pts){
    vector pos = point(0, 'P', pt);
    vector newpos = pos + (@P-pos)*ch('size');
    append(newpts, addpoint(0, newpos));
}

for(int i=0; i<len(pts); i++){
    int pt0 = pts[i];
    int pt1 = pts[(i+1)%len(pts)];
    int newpt0 = newpts[(i+1)%len(newpts)];
    int newpt1 = newpts[i];
    addprim(0, 'poly', pt0, pt1, newpt0, newpt1);
}

removeprim(0, @primnum, 1);

int newpts[];
int innerpts[];

foreach(int pt; pts){
    vector pos = point(0, 'P', pt);
    vector newpos = pos + (@P-pos)*ch('size'); //size = 0.2
    vector innerpos = newpos + @N*ch('innersize'); //innersize = -0.05
    append(newpts, addpoint(0, newpos));
    append(innerpts, addpoint(0, innerpos));
}

for(int i=0; i<len(pts); i++){
    int pt0 = pts[i];
    int pt1 = pts[(i+1)%len(pts)];
    int newpt0 = newpts[(i+1)%len(newpts)];
    int newpt1 = newpts[i];
    addprim(0, 'poly', pt0, pt1, newpt0, newpt1);
}

for(int i=0; i<len(newpts); i++){
    int pt0 = newpts[i];
    int pt1 = newpts[(i+1)%len(pts)];
    int newpt0 = innerpts[(i+1)%len(newpts)];
    int newpt1 = innerpts[i];
    addprim(0, 'poly', pt0, pt1, newpt0, newpt1);
}

addprim(0, 'poly', innerpts);
removeprim(0, @primnum, 1);

primvertices —— 返回指定prim上的线性顶点列表

int[] primvertices(<geometry>geometry, int primnum)
返回线性顶点索引，与存储在面的顺序相同；

primpoint —— 将prim上的vertex转化为对应的点号

int primpoint(geometry, int primnum, int vertex)
如：i@a = primpoint("op:../sphere1", 0, 2);
vertex为面的顶点，从0开始；
返回顶点对应的点号，失败返回-1；

i[]@pts;
for(int i=1; i<primvertexcount(0, 0); i++){
    @pts[i] = primpoint(0, 0, i);    
}

primvertex —— 将prim上的顶点转化为对应的线性顶点

int primvertex(<geometry>geometry, int primnum, int vertex)
vertex为面的顶点，从0开始；
返回顶点对应的线性顶点号，失败返回-1；
类似vertexindex；

i[]@linearvertex;
int count = 0;
int nprim = nprimitives(0);
for(int i=0; i<nprim; i++){ 
    int j=0;
    int nvertex = primvertexcount(0, i);
    for(j; j<nvertex; j++){ 
        @linearvertex[count+j] = primvertex(0,i,j);
    }
    count+=j;   
}

primvertexcount —— 返回prim上的顶点总数

int primvertexcount(<geometry>geometry, int prim_num)
返回给定面上的顶点数，如面不存返回-1；

primfind —— 返回可能与boundingbox边界相交的面号列表

int[] primfind(<geometry>geometry, vector min, vector max)
int[] primfind(<geometry>geometry, string group, vector min, vector max)
group，空组表示所有面，支持ad-hoc样式如0-10、@Cd.x>0；
返回面号数组；

//删除所有与指定box相交的面
vector min, max;
getbbox(1, min, max);
int prims[] = primfind(0, min, max);
foreach(int prim; prims){
    removeprim(0, prim, 1);
}

polyneighbours —— 返回共享边的面号数组

int[] polyneighbours(<geometry>geometry, int primnum)
返回面号数组，共享边的面（即邻居面）；
使用Half-Edge数据结构，可与支持Half-Edge的几何体工作（如polygons）；

//等价于
int[] polyneighbours(const string opname; const int primnum)
{
    int result[] = {};
    int start = primhedge(opname, primnum); //获取改面的一个半边

    for (int hedge = start; hedge != -1; )
    {
        for (int nh = hedge_nextequiv(opname, hedge); 
             nh != hedge;
             nh = hedge_nextequiv(opname, nh)) //获取下一个等效半边，并判断是否有等效边
        {
            int prim = hedge_prim(opname, nh); //获取半边的所属的面
            if (prim != -1 && prim != primnum)
            {
                append(result, prim);
            }
        }
        hedge = hedge_next(opname, hedge);
        if (hedge == start)
            break;
    }

    return result;
}

vertexindex —— 将顶点转化为线性顶点

int vertexindex(<geometry>geometry, int primnum, int vertex)
vertex为面的顶点，从0开始；
返回顶点对应的线性顶点号，失败返回-1；
类似primvertex；

i[]@linearvertex;
int count = 0;
int nprim = nprimitives(0);
for(int i=0; i<nprim; i++){ 
    int j=0;
    int nvertex = primvertexcount(0, i);
    for(j; j<nvertex; j++){ 
        @linearvertex[count+j] = vertexindex(0,i,j);
    }
    count+=j;   
}

vertexprev —— 返回与给定顶点共享点的上一个顶点的线性顶点号

int vertexprev(<geometry>geometry, int linearvertex)
linearvertex，线性顶点号，可使用vertexindex将顶点转化为线性顶点；
返回上一个线性顶点号，失败返回-1；

vertexnext —— 返回与给定顶点分享点的下一个顶点的线性顶点号；

int vertexnext(<geometry>geometry, int linearvertex)
linearvertex，线性顶点号，可使用vertexindex将顶点转化为线性顶点；
返回下一个线性顶点号，失败返回-1；

vertexpoint —— 返回线性顶点的点号；

int vertexpoint(<geometry>geometry, int linearvertex)
linearvertex，线性顶点号，可使用vertexindex将顶点转化为线性顶点；
返回顶点对应的点号，无对应的点返回-1；

vertexprim —— 返回包含给定线性顶点的面号；

int vertexprim(<geometry>geometry, int linearvertex)
linearvertex，线性顶点号，可使用vertexindex将顶点转化为线性顶点；
返回顶点对应的面号，无对应的面返回-1；

vertexprimindex —— 将线性顶点转化为顶点号；

int vertexprimindex(<geometry>geometry, int linearindex)

linearvertex，线性顶点号；
返回线性顶点对应的顶点号，无对应的面返回-1；

npoints —— 返回点总数

int npoints(<geometry>geometry)

nprimitives —— 返回面总数

int nprimitives(<geometry>geometry)

nvertices —— 返回顶点总数

int nvertices(<geometry>geometry)

npointsgroup —— 返回组内的点总数

int npointsgroup(<geometry>geometry, string groupname)

nprimitivesgroup —— 返回组内的面总数

int nprimitivesgroup(<geometry>geometry, string groupname)

nverticesgroup —— 返回组内的顶点总数

int nverticesgroup(<geometry>geometry, string groupname)

removeattrib —— 移除指定属性或组

int removeattrib(int geohandle, string attribclass, string name)
attribclass，属性类型如"detail"/"global"、"point"、"prim"、“vertex”；组类型如"primgroup"、"pointgroup"、"vertexgroup"；
name，指定待移除的属性或组；

removeattrib(0, "point", "attribute1");
removeattrib(0, "primgroup", "group1");

removepoint —— 移除指定点

int removepoint(int geohandle, int point_number)
int removepoint(int geohandle, int point_number, int and_prims)
point_number，点号，如是-1没有效果；
and_prims，如是1，删除任何退化的面（如少于3个顶点的封闭polygon，少于2顶点的开放polygon）；如是0，将仅删除无效的面（如少于4个顶点的四面体，0个顶点的volume）；

removeprim —— 移除指定面

int removeprim(int geohandle, int prim_number, int andpoints)
prim_number，面号，如是-1没有效果；
andpoints，如是1，删除任何关联的点（但不与其他面关联）；

removevertex —— 移除指定顶点

int removevertex(int geohandle, int linear_vertex_index)
linear_vertex_index，线性顶点号，如是-1没有效果；可使用vertexindex转化；
移除给定的顶点，注但invoke时不会立即处理；
当前仅polygon支持顶点移除；
但prim没有被删除，会导致退化的polygon（0顶点）；
在高顶点数量的polygon上删除许多顶点，会变的很慢；

setprimvertex —— 将顶点重连接到不同的点

int setprimvertex(int geohandle, int prim, int vtxofprim, int pt)
如点号是-1，没有重连；
如prim是-1，vtxofprim将被作为线性顶点；
与setvertexpoint等效；

setvertexpoint —— 将顶点重连接到不同的点

int setvertexpoint(int geohandle, int prim, int vtxofprim, int pt)
如点号是-1，没有重连；
如prim是-1，vtxofprim将被作为线性顶点；
与setprimvertex等效；

//反转面
int linear_vts[] = primvertices(0, @primnum);
int pts[];

foreach(int vts; linear_vts){
    append(pts, vertexpoint(0, vts));
}

pts = reverse(pts);

for(int i=0; i<len(pts); i++){
    setprimvertex(0, -1, linear_vts[i], pts[i]);
}

setedgegroup —— 设置边组成员

int setedgegroup(int geohandle, string name, int pt0, int pt1, int value)
改变边组成员，如组不存在将创建；
name，组名；
pt0、pt1，边对应的两点；边必须有效；

expandedgegroup —— 返回边点列表

int[] expandedgegroup(<geometry>geometry, string groupname)
int[] expandedgegroup(<geometry>geometry, string groupname, string mode)
可使用ad-hoc，如0或p0-1，空字符串表示所有边；
mode
ordered，默认模式，将按字符串中出现的顺序返回数字，仅限于数字；但使用表达式如@Cd.x>0.5，顺序将不被保持；在返回的数组，相同的数字不会出现两次；
unordered，按排序的点号返回被解析的组；
split，先拆开字符串groupname为@字符串，然后解析每个子字符串；相同的数字可以出现多次；

expandpointgroup
expandprimgroup
expandvertexgroup

inedgegroup —— 是否在指定的边组

int inedgegroup(string filename, string groupname, int pointnum0, int pointnum1)
int inedgegroup(int input, string groupname, int pointnum0, int pointnum1)
在指定的边组，返回1；
不在指定的边组，或组不存在，返回0；

nedgesgroup —— 返回组内的边数

int nedgesgroup(string filename, string groupname)
int nedgesgroup(int input, string groupname)
必须是一个确定的组名，不可是ad-hoc组；

uvintersect —— 计算在UV空间内射线交点

int uvintersect(<geometry>geometry, string uvname, vector orig, vector dir, vector &pos, vector &primuv)
int uvintersect(<geometry>geometry, string primgroup, string uvname, vector orig, vector dir, vector &pos, vector &primuv)

vertexcurveparam —— 沿着面的周长返回顶点参数坐标

float vertexcurveparam(<geometry>geometry, int linearindex)
沿面周长的参数化坐标，面假定是polygon；
对开放的polygon，直接使用primuv；

clip —— 切割p0和p1之间的线段

void clip(int &result, vector &p0, vector &p1, vector4 plane)
void clip(int &result, vector &p0, vector &p1, vector min, vector max)

geounwrap

string geounwrap(<geometry>geometry, string unwrap_attribute)

查看案例：UV Island 각각의 스케일을 줄여주는 방법 (3DS Max의 Uv Relax 대응)

vector t = chv("t");
vector r = chv("r");
vector s = chv("s");
string geo = geounwrap(0, "uv");
int island = prim(0, "island", @primnum);
vector center = getbbox_center(geo, "@island=" + itoa(island));
matrix xform = maketransform(0, 0, t, r, s, center);
v@uv *= xform;

收录于