C++ Box3::Max方法代码示例

BOOL plDistributor::IConformCheck(Matrix3& l2w, int iRepNode, plMeshCacheTab& cache, int& iCache) const
{
    Matrix3 OTM = IOTM(iRepNode);
    Mesh* mesh = cache[iRepNode].fMesh;

    Point3 dir = l2w.VectorTransform(Point3(0.f, 0.f, 1.f));
    dir = FNormalize(dir);

    const float kOneOverSqrt2 = 0.707107f;
    Point3 scalePt(kOneOverSqrt2, kOneOverSqrt2, 0.f);
    scalePt = l2w.VectorTransform(scalePt);
    float maxScaledDist = fMaxConform * scalePt.Length();

    Box3 bnd = mesh->getBoundingBox() * OTM;
    bnd = Box3(Point3(bnd.Min().x, bnd.Min().y, -bnd.Max().z), bnd.Max());
    bnd = bnd * l2w;
    Tab<int32_t> faces;
    IFindFaceSet(bnd, faces);

    int i;
    for( i = 0; i < mesh->getNumVerts(); i++ )
    {
        Point3 pt = mesh->getVert(i) * OTM;
        pt.z = 0;

        pt = pt * l2w;

        Point3 projPt;
        if( !IProjectVertex(pt, dir, maxScaledDist, faces, projPt) )
            return false;
    }
    return true;
}

void bhkProxyObject::BuildColBox()
{
	Box3 box; box.Init();
	for (int i = 0;i < pblock2->Count(PB_MESHLIST); i++) {
		INode *tnode = NULL;
		pblock2->GetValue(PB_MESHLIST,0,tnode,FOREVER,i);	
		if (tnode)
		{
			ObjectState os = tnode->EvalWorldState(0);
			Matrix3 wm = tnode->GetNodeTM(0);
			TriObject *tri = (TriObject *)os.obj->ConvertToType(0, Class_ID(TRIOBJ_CLASS_ID, 0));
			if (tri)
			{
				Box3 box2; box2.Init();
				Mesh& mesh = tri->GetMesh();
				CalcAxisAlignedBox(mesh, box2, &wm);
				box += box2;
			}
		}
	}
	BuildBox(proxyMesh, box.Max().y-box.Min().y, box.Max().x-box.Min().x, box.Max().z-box.Min().z);

	MNMesh mn(proxyMesh);
	Matrix3 tm(true);
	tm.SetTranslate(box.Center());
	mn.Transform(tm);
	mn.OutToTri(proxyMesh);

	//proxyPos = box.Center();
	proxyPos = Point3::Origin;
	forceRedraw = true;
}

BOOL plDistributor::IConformAll(Matrix3& l2w, int iRepNode, plMeshCacheTab& cache, int& iCache) const
{
    Matrix3 OTM = IOTM(iRepNode);
    Mesh* mesh = cache[iRepNode].fMesh;

    Point3 dir = l2w.VectorTransform(Point3(0.f, 0.f, 1.f));
    dir = FNormalize(dir);

    const float kOneOverSqrt2 = 0.707107f;
    Point3 scalePt(kOneOverSqrt2, kOneOverSqrt2, 0.f);
    scalePt = l2w.VectorTransform(scalePt);
    float maxScaledDist = fMaxConform * scalePt.Length();

    Box3 bnd = mesh->getBoundingBox() * OTM;
    bnd = Box3(Point3(bnd.Min().x, bnd.Min().y, -bnd.Max().z), bnd.Max());
    bnd = bnd * l2w;
    Tab<int32_t> faces;
    IFindFaceSet(bnd, faces);

    // l2w, iRepNode, cache, &iCache, maxScaledDist, dir
    iCache = cache.Count();
    cache.SetCount(iCache + 1);
    cache[iCache] = cache[iRepNode];
    cache[iCache].fMesh = new Mesh(*mesh);

    mesh = cache[iCache].fMesh;

    Matrix3 v2w = OTM * l2w;
    Matrix3 w2v = Inverse(v2w);

    BOOL retVal = true;
    int i;
    for( i = 0; i < mesh->getNumVerts(); i++ )
    {
        Point3 pt = mesh->getVert(i) * OTM;
        pt.z = 0;

        pt = pt * l2w;

        Point3 projPt;
        if( !IProjectVertex(pt, dir, maxScaledDist, faces, projPt) )
        {
            retVal = false;
            break;
        }

        Point3 del = w2v.VectorTransform(projPt - pt);
        mesh->getVert(i) += del;
    }
    if( !retVal )
    {
//      delete cache[iCache].fMesh;
        delete mesh;
        cache.SetCount(iCache);
        iCache = iRepNode;
    }
    return retVal;
}

/// positive in, negative out
static inline bool isPointInBoxBias(const Box3& box, const double3& point)
{
    if (point.x > box.Max().x) return false;
    if (point.y > box.Max().y) return false;
    if (point.z > box.Max().z) return false;

    if (point.x <= box.Min().x) return false;
    if (point.y <= box.Min().y) return false;
    if (point.z <= box.Min().z) return false;

    return true;
}

void bhkRigidBodyModifier::BuildColBox(Mesh& mesh)
{
	Box3 box; box.Init();
	CalcAxisAlignedBox(mesh, box, NULL);
	BuildBox(mesh, box.Max().y-box.Min().y, box.Max().x-box.Min().x, box.Max().z-box.Min().z);

	MNMesh mn(mesh);
	Matrix3 tm(true);
	tm.Translate(box.Center());
	mn.Transform(tm);
	mn.OutToTri(mesh);
}

static void MakeDummyMesh(plMaxNode* node, plMaxMeshExtractor::NeutralMesh& mesh)
{
    hsPoint3 minV, maxV;

    Object* thisObj = node->GetObjectRef();
    DummyObject* thisDummy = (DummyObject*)thisObj;
    Box3 thisBoundSurface = thisDummy->GetBox();
    minV.fX = thisBoundSurface.Min().x;
    minV.fY = thisBoundSurface.Min().y;
    minV.fZ = thisBoundSurface.Min().z;
    maxV.fX = thisBoundSurface.Max().x;
    maxV.fY = thisBoundSurface.Max().y;
    maxV.fZ = thisBoundSurface.Max().z;

    MakeBoxMesh(node, mesh, minV, maxV);
}

plLayerInterface* plLayerConverter::IConvertAngleAttenLayer(plPlasmaMAXLayer *layer, 
                                                                plMaxNode *maxNode, uint32_t blendFlags, 
                                                                bool preserveUVOffset, bool upperLayer)
{
    hsGuardBegin( "plPlasmaMAXLayer::IConvertAngleAttenLayer" );
    if( !upperLayer )
    {
        fErrorMsg->Set(true, maxNode->GetName(), "Angle Attenuation layers can only be used as a top layer").Show();
        fErrorMsg->Set();
        return nil;
    }
    plAngleAttenLayer* aaLay = (plAngleAttenLayer*)layer;
    Box3 fade = aaLay->GetFade();
    float tr0 = cosf(DegToRad(180.f - fade.Min().x));
    float op0 = cosf(DegToRad(180.f - fade.Min().y));
    float tr1 = cosf(DegToRad(180.f - fade.Max().x));
    float op1 = cosf(DegToRad(180.f - fade.Max().y));

    int loClamp = aaLay->GetLoClamp();
    int hiClamp = aaLay->GetHiClamp();

    int uvwSrc = aaLay->Reflect() ? plLayerInterface::kUVWReflect : plLayerInterface::kUVWNormal;

    plLayer* lut = ICreateAttenuationLayer(plString::FromUtf8(layer->GetName()), maxNode, uvwSrc, tr0, op0, tr1, op1, loClamp, hiClamp);

    return lut;

    hsGuardEnd;
}

static inline void normalizeBox3(const Box3& target, const Box3& env, Box3& output)
{
    auto scale = env.Diagonal();
    auto center = env.Center();
    
    output.Set((target.Min()-center)/scale*2.0, 
        (target.Max()-center)/scale*2.0);
}

static inline void staticFilter(Box3& box, double factor)
{
    double3 minimum(box.Min());
    double3 maximum(box.Max());

    minimum.x = staticFilter(minimum.x, factor);
    minimum.y = staticFilter(minimum.y, factor);
    minimum.z = staticFilter(minimum.z, factor);

    maximum.x = staticFilter(maximum.x, factor);
    maximum.y = staticFilter(maximum.y, factor);
    maximum.z = staticFilter(maximum.z, factor);
}

BOOL plDistributor::ISetupSkinWeights(plMaxNode* node, Mesh* mesh, const Point3& flex) const
{
    const char* dbgNodeName = node->GetName();

    Matrix3 otm = node->GetOTM();

    Box3 bnd = mesh->getBoundingBox() * otm;

    float meshHeight = bnd.Max().z;
    float maxHeight = kMaxHeight;
    if( meshHeight > maxHeight )
        maxHeight = meshHeight;
    float maxNorm = meshHeight / maxHeight;

    float flexibility = flex[0];

    UVVert *wgtMap = mesh->mapVerts(kWgtMapChan);   
    int numWgtVerts = mesh->getNumMapVerts(kWgtMapChan);
    if( !mesh->mapSupport(kWgtMapChan) || !mesh->mapVerts(kWgtMapChan) || !mesh->mapFaces(kWgtMapChan) )
    {
        mesh->setMapSupport(kWgtMapChan);

        mesh->setNumMapVerts(kWgtMapChan, mesh->getNumVerts());
        mesh->setNumMapFaces(kWgtMapChan, mesh->getNumFaces());
    }

    int i;
    for( i = 0; i < mesh->getNumVerts(); i++ )
    {
        Point3 pos = mesh->getVert(i) * otm;
        float wgt = pos.z / meshHeight;
        wgt *= wgt > 0 ? wgt : 0;
        wgt *= maxNorm;
        wgt *= flexibility;

        pos.x = wgt;
        pos.y = wgt;
        pos.z = wgt;

        mesh->setMapVert(kWgtMapChan, i, pos);
    }

    TVFace* mapFaces = mesh->mapFaces(kWgtMapChan);
    Face* faces = mesh->faces;
    for( i = 0; i < mesh->getNumFaces(); i++ )
    {
        mapFaces[i].setTVerts(faces[i].getVert(0), faces[i].getVert(1), faces[i].getVert(2));
    }

    return true;
}

void Exporter::CalcBoundingBox(INode *node, Box3& box, int all)
{
	if (nullptr == node)
		return;

	Matrix3 tm = node->GetObjTMAfterWSM(0);
	if (node->IsBoneShowing()) {
		box.IncludePoints(const_cast<Point3*>(&tm.GetTrans()), 1, nullptr);
	}
	else {
		if (Object *o = node->GetObjectRef()) {
			if (o->SuperClassID() == GEOMOBJECT_CLASS_ID) {
				if (o->ClassID() == BONE_OBJ_CLASSID
					|| o->ClassID() == Class_ID(BONE_CLASS_ID, 0)
					|| o->ClassID() == Class_ID(0x00009125, 0) /* Biped Twist Helpers */
					)
				{
					box.IncludePoints(const_cast<Point3*>(&tm.GetTrans()), 1, nullptr);
				}
				else
				{
					Box3 local;
#if VERSION_3DSMAX < (15000<<16) // Version 15 (2013)
					o->GetLocalBoundBox(0, node, mI->GetActiveViewport(), local);
#else
					o->GetLocalBoundBox(0, node, &mI->GetActiveViewExp(), local);
#endif
					box.IncludePoints(&local.Min(), 1, nullptr);
					box.IncludePoints(&local.Max(), 1, nullptr);
				}
			}
			else if (mExportCameras && o->SuperClassID() == CAMERA_CLASS_ID)
			{
				box.IncludePoints(const_cast<Point3*>(&tm.GetTrans()), 1, nullptr);
			}
		}
	}
	if (all < 0)
		return;

	all = (all>0 ? all : -1);
	for (int i = 0; i < node->NumberOfChildren(); i++) {
		CalcBoundingBox(node->GetChildNode(i), box, all);
	}
}

void BSPOctree::SplitSpaceByXYZ(const Box3& bbox,  Box3 childBoxes[])
{
    vec3<float> minOffset, maxOffset;
    const double factor = pow(2.0, 11);
    double3 step = double3(
        staticFilter(bbox.Diagonal().x* 0.5, factor)
        , staticFilter(bbox.Diagonal().y*0.5, factor)
        ,  staticFilter(bbox.Diagonal().z*0.5, factor));

    for (int i = 0; i < 8 ; i++)
    {
        maxOffset.z = i & 1 ?  0 : -step.z; 
        maxOffset.y = i & 2 ?  0 : -step.y;
        maxOffset.x = i & 4 ?  0 : -step.x;
        minOffset.z = i & 1 ?  step.z : 0; 
        minOffset.y = i & 2 ?  step.y : 0;
        minOffset.x = i & 4 ?  step.x : 0;
        childBoxes[i].Set(bbox.Min() + minOffset, bbox.Max()+ maxOffset);
    }
}

BOOL plDistribComponent_old::IValidateFade(Box3& fade)
{
    BOOL retVal = true;
    fade = GetFade();

    if( fCompPB->GetInt(kFadeInActive) )
    {
        if( fade.Max()[0] < fade.Max()[1] )
        {
            if( fade.Min()[0] > fade.Max()[0] )
            {
                fade.pmin[0] = fade.Max()[0];
                retVal = false;
            }

            if( fade.Min()[1] > fade.Min()[0] )
            {
                fade.pmin[1] = fade.Min()[0];
                retVal = false;
            }
        }
        else if( fade.Max()[0] > fade.Max()[1] )
        {
            if( fade.Min()[1] > fade.Max()[1] )
            {
                fade.pmin[1] = fade.Max()[1];
                retVal = false;
            }

            if( fade.Min()[0] > fade.Min()[1] )
            {
                fade.pmin[0] = fade.Min()[1];
                retVal = false;
            }
        }
    }
    return retVal;
}

int Blockporter::DoExport(const TCHAR* name, ExpInterface* ei, Interface* i, BOOL supressPrompts, DWORD options)
{
	INode* root;
	//caption and message for MessagesBoxes
	TCHAR msg[MB_BUFFER_LENGTH];
	TCHAR cap[MB_BUFFER_LENGTH];

	//Get the root node
	root = i->GetRootNode();

	//the node of our object should be a groupnode, which contains every object
	//we want to export
	i->PushPrompt(_T("Searching for Group..."));
	bool found = false;
	for(int idx = 0; idx < root->NumberOfChildren(); idx++)
	{
		if(root->GetChildNode(idx)->IsGroupHead())
		{
			//we found our group
			//next step is to make the group node our new root, because every object
			//we want is part of this group

			found = true;
			root = root->GetChildNode(idx);
			break;
		}
	}

	if(!found)
	{
		MessageBox(nullptr, GetString(IDS_ERROR_NO_GROUP, msg), GetString(IDS_GENERAL_ERROR, cap), MB_OK | MB_ICONERROR);
		return 0;
	}

	//Now that we have the groupnode let's compare the fileversions
	if(!IsNewModelVersion(name, root->GetName()))
	{
		if(MessageBox(nullptr, GetString(IDS_VER_TO_LOW_MSG, msg), GetString(IDS_VER_TO_LOW_CAP, cap), MB_YESNO | MB_ICONEXCLAMATION) == IDNO)
			return 1;
	}

	i->PushPrompt(_T("Opening File"));
	Interface14* iface = GetCOREInterface14();
	UINT code = iface->DefaultTextSaveCodePage(true);
	MaxSDK::Util::Path storageNamePath(name);
	storageNamePath.SaveBaseFile();
	switch (code & MaxSDK::Util::MaxStringDataEncoding::MSDE_CP_MASK)
	{
	case CP_UTF8:
		mStream = _tfopen(name, _T("wt, ccs=UFT-8"));
		break;
	case MaxSDK::Util::MaxStringDataEncoding::MSDE_CP_UTF16:
		mStream = _tfopen(name, _T("wt, ccs=UTF-16BE"));
		break;
	default:
		mStream = _tfopen(name, _T("wt"));
	}
	if(!mStream)
		return 0;

	//now we have our file stream, so let's write the header
	i->PushPrompt(_T("Writing Header"));
	WriteHeader(root->GetName(), root->NumberOfChildren());

	//now that we have the header written, let's iterate through the objects in the
	//group and export the meshes and lights

	INode* child;
    Point3 pMin(0,0,0), pMax(0,0,0);

	for(int idx = 0; idx < root->NumberOfChildren(); idx++)
	{
		child = root->GetChildNode(idx);
		i->PushPrompt(_T("Processing Object %s", child->GetName()));
		if(child->IsGroupHead())
		{
			MessageBox(nullptr, GetString(IDS_ERROR_TO_MANY_GROUPS, msg), GetString(IDS_GENERAL_ERROR, cap), MB_OK | MB_ICONERROR);
			continue;
		}

		ObjectState os = child->EvalWorldState(0);

		//let's take a look at the SuperClassID of the object
		//so we find out if it's a mesh or a light
		if(!os.obj)
			continue; //somehow this node doesn't have an object

        Box3 boundBox;

		switch(os.obj->SuperClassID())
		{
		case GEOMOBJECT_CLASS_ID:
			_ftprintf(mStream, _T("<ObjectID=%i>\n"), idx);
			i->PushPrompt(_T("Writing MeshData for Object %s", child->GetName()));
			boundBox = WriteMeshData(child, idx);
            pMin.x = (boundBox.Min().x < pMin.x) ? boundBox.Min().x : pMin.x;
            pMin.y = (boundBox.Min().y < pMin.y) ? boundBox.Min().y : pMin.y;
            pMax.x = (boundBox.Max().x > pMax.x) ? boundBox.Max().x : pMax.x;
            pMax.y = (boundBox.Max().y > pMax.y) ? boundBox.Max().y : pMax.y;
			i->PushPrompt(_T("Writing MaterialData for Object %s", child->GetName()));
//.........这里部分代码省略.........

void LuminaireObject::BuildMesh()
{
	mesh.setNumVerts(120);
	mesh.setNumFaces(106);

	// aszabo|Feb.10.03|Compute scale of mesh. DummyObject::box has been scaled,
	// while our mDefBoxSize wasn't, but it was used to initialize the box.
	float s = box.Max().x/mDefBoxSize.Max().x;

	mesh.setVert(0, s*Point3(2.812824,-4.221277,0.000000));
	mesh.setVert(1, s*Point3(-2.731174,-4.221277,0.000000));
	mesh.setVert(2, s*Point3(-2.731174,-4.972452,0.000000));
	mesh.setVert(3, s*Point3(2.812824,-4.972452,0.000000));
	mesh.setVert(4, s*Point3(0.430951,-0.504076,0.000000));
	mesh.setVert(5, s*Point3(0.373688,-0.540217,0.000000));
	mesh.setVert(6, s*Point3(0.312884,-0.570737,0.000000));
	mesh.setVert(7, s*Point3(0.248868,-0.595212,0.000000));
	mesh.setVert(8, s*Point3(0.181967,-0.613220,0.000000));
	mesh.setVert(9, s*Point3(0.112510,-0.624335,0.000000));
	mesh.setVert(10, s*Point3(0.040825,-0.628134,0.000000));
	mesh.setVert(11, s*Point3(-0.030860,-0.624335,0.000000));
	mesh.setVert(12, s*Point3(-0.100318,-0.613220,0.000000));
	mesh.setVert(13, s*Point3(-0.167219,-0.595213,0.000000));
	mesh.setVert(14, s*Point3(-0.231235,-0.570737,0.000000));
	mesh.setVert(15, s*Point3(-0.292039,-0.540217,0.000000));
	mesh.setVert(16, s*Point3(-0.349302,-0.504076,0.000000));
	mesh.setVert(17, s*Point3(-0.402695,-0.462737,0.000000));
	mesh.setVert(18, s*Point3(-0.402695,-4.025318,0.000000));
	mesh.setVert(19, s*Point3(0.484345,-4.025318,0.000000));
	mesh.setVert(20, s*Point3(0.484345,-0.462738,0.000000));
	mesh.setVert(21, s*Point3(0.373465,-4.025318,0.000000));
	mesh.setVert(22, s*Point3(-0.291815,-4.025318,0.000000));
	mesh.setVert(23, s*Point3(-0.291815,-4.221277,0.000000));
	mesh.setVert(24, s*Point3(0.373465,-4.221277,0.000000));
	mesh.setVert(25, s*Point3(4.419012,5.754055,0.000000));
	mesh.setVert(26, s*Point3(2.964259,4.637785,0.000000));
	mesh.setVert(27, s*Point3(3.340581,4.051188,0.000000));
	mesh.setVert(28, s*Point3(3.598334,3.467271,0.000000));
	mesh.setVert(29, s*Point3(3.784944,2.884963,0.000000));
	mesh.setVert(30, s*Point3(3.947842,2.303191,0.000000));
	mesh.setVert(31, s*Point3(4.134453,1.720884,0.000000));
	mesh.setVert(32, s*Point3(4.392206,1.136967,0.000000));
	mesh.setVert(33, s*Point3(4.768528,0.550370,0.000000));
	mesh.setVert(34, s*Point3(7.900172,2.953366,0.000000));
	mesh.setVert(35, s*Point3(7.430962,3.468688,0.000000));
	mesh.setVert(36, s*Point3(6.933653,3.868786,0.000000));
	mesh.setVert(37, s*Point3(6.419484,4.199750,0.000000));
	mesh.setVert(38, s*Point3(5.899698,4.507671,0.000000));
	mesh.setVert(39, s*Point3(5.385530,4.838635,0.000000));
	mesh.setVert(40, s*Point3(4.888222,5.238734,0.000000));
	mesh.setVert(41, s*Point3(2.805657,2.557596,0.000000));
	mesh.setVert(42, s*Point3(2.664196,2.574949,0.000000));
	mesh.setVert(43, s*Point3(2.533501,2.619650,0.000000));
	mesh.setVert(44, s*Point3(2.416477,2.688673,0.000000));
	mesh.setVert(45, s*Point3(2.316031,2.778996,0.000000));
	mesh.setVert(46, s*Point3(2.235066,2.887594,0.000000));
	mesh.setVert(47, s*Point3(2.176486,3.011443,0.000000));
	mesh.setVert(48, s*Point3(2.143197,3.147520,0.000000));
	mesh.setVert(49, s*Point3(-0.028124,0.736024,0.000000));
	mesh.setVert(50, s*Point3(-0.018348,0.737188,0.000000));
	mesh.setVert(51, s*Point3(-0.008572,0.738606,0.000000));
	mesh.setVert(52, s*Point3(0.001220,0.740119,0.000000));
	mesh.setVert(53, s*Point3(0.011041,0.741571,0.000000));
	mesh.setVert(54, s*Point3(0.020906,0.742804,0.000000));
	mesh.setVert(55, s*Point3(0.030829,0.743659,0.000000));
	mesh.setVert(56, s*Point3(0.040825,0.743979,0.000000));
	mesh.setVert(57, s*Point3(0.174745,0.730856,0.000000));
	mesh.setVert(58, s*Point3(0.299803,0.693174,0.000000));
	mesh.setVert(59, s*Point3(0.413514,0.633459,0.000000));
	mesh.setVert(60, s*Point3(0.513398,0.554243,0.000000));
	mesh.setVert(61, s*Point3(0.596971,0.458053,0.000000));
	mesh.setVert(62, s*Point3(0.661752,0.347418,0.000000));
	mesh.setVert(63, s*Point3(0.705257,0.224866,0.000000));
	mesh.setVert(64, s*Point3(0.726882,0.057922,0.000000));
	mesh.setVert(65, s*Point3(0.708744,0.215121,0.000000));
	mesh.setVert(66, s*Point3(0.657090,0.359483,0.000000));
	mesh.setVert(67, s*Point3(0.576055,0.486872,0.000000));
	mesh.setVert(68, s*Point3(0.469775,0.593152,0.000000));
	mesh.setVert(69, s*Point3(0.342386,0.674188,0.000000));
	mesh.setVert(70, s*Point3(0.198024,0.725842,0.000000));
	mesh.setVert(71, s*Point3(0.040825,0.743979,0.000000));
	mesh.setVert(72, s*Point3(-0.116374,0.725842,0.000000));
	mesh.setVert(73, s*Point3(-0.260736,0.674188,0.000000));
	mesh.setVert(74, s*Point3(-0.388125,0.593152,0.000000));
	mesh.setVert(75, s*Point3(-0.494405,0.486872,0.000000));
	mesh.setVert(76, s*Point3(-0.575440,0.359483,0.000000));
	mesh.setVert(77, s*Point3(-0.627095,0.215121,0.000000));
	mesh.setVert(78, s*Point3(-0.645232,0.057922,0.000000));
	mesh.setVert(79, s*Point3(-0.627095,-0.099276,0.000000));
	mesh.setVert(80, s*Point3(-0.575440,-0.243638,0.000000));
	mesh.setVert(81, s*Point3(-0.494405,-0.371027,0.000000));
	mesh.setVert(82, s*Point3(-0.388125,-0.477308,0.000000));
	mesh.setVert(83, s*Point3(-0.260736,-0.558343,0.000000));
	mesh.setVert(84, s*Point3(-0.116374,-0.609997,0.000000));
	mesh.setVert(85, s*Point3(0.040825,-0.628134,0.000000));
	mesh.setVert(86, s*Point3(0.198024,-0.609997,0.000000));
	mesh.setVert(87, s*Point3(0.342386,-0.558343,0.000000));
	mesh.setVert(88, s*Point3(0.469775,-0.477308,0.000000));
	mesh.setVert(89, s*Point3(0.576055,-0.371027,0.000000));
	mesh.setVert(90, s*Point3(0.657090,-0.243638,0.000000));
//.........这里部分代码省略.........