int main(void) { //1.打开共享库文件 void* handler = dlopen("./max/libmax.so",RTLD_NOW); //2.判断是否打开错误 char* error = dlerror(); if(error) { printf("打开共享文件失败\n"); return -1; } //3.获取函数的地址并且调用 int (*pMax)(int,int); pMax = dlsym(handler,"max"); error = dlerror(); if(error) { printf("获取函数的地址失败\n"); return -1; } printf("最大值是:%d\n",pMax(10,20)); //4.关闭共享库文件 dlclose(handler); return 0; }
void clip_cs_menu() { cleardevice(); outtext((char*)"Click and drag mouse to define rectangular clipping region"); mouseInput(x1, y1, x2, y2); Point2D pMin(std::min(x1,x2), std::min(y1,y2)), pMax(std::max(x1,x2), std::max(y1,y2)); std::vector<Point2D> rect; rect.push_back(pMin); rect.push_back(Point2D(pMin.x, pMax.y)); rect.push_back(pMax); rect.push_back(Point2D(pMax.x, pMin.y)); cleardevice(); mypoly(rect); outtext((char*)"Click and drag mouse to make lines to be clipped, right click to EXIT"); clearmouseclick(WM_RBUTTONDOWN); while(!ismouseclick(WM_RBUTTONDOWN)) { Point2D p1, p2; mouseLine(p1, p2); setcolor(RED); myline(p1, p2); setcolor(WHITE); clip_line_cs(pMin, pMax, p1, p2); } }
void PEffectGlow::setBlurKernelSize(pint32 size) { // We choose its nearest odd number to the "size" m_blurKernelSize = pMax(size / 2 * 2 + 1, pint32(3)); m_xMaterial->parameter("size") = m_blurKernelSize; m_yMaterial->parameter("size") = m_blurKernelSize; }
//--------------------------------------------------------------------------- void Sky::makeBoundingBox() { // This bounding box is less than the root container's bounding box, but // greater than any "real" bounding box, ie the terrain. // Point3F pMin(-1e10f, -1e10f, -1e10f); Point3F pMax( 1e10f, 1e10f, 1e10f); setBoundingBox(Box3F(pMin, pMax)); }
void ShapeBezierSurface::computeBBox(SoAction*, SbBox3f& box, SbVec3f& /*center*/ ) { box.makeEmpty(); for (int i = 0; i < m_surfacesVector.size(); i++) { BBox pBox = m_surfacesVector[i]->GetComputeBBox(); SbVec3f pMin( pBox.pMin[0], pBox.pMin[1], pBox.pMin[2] ); box.extendBy( pMin ); SbVec3f pMax( pBox.pMax[0], pBox.pMax[1], pBox.pMax[2] ); box.extendBy( pMax ); } }
void Colony::distributeAntsByBlock() { int nHorizontalBlocks = _environment->getWidth() / BLOCK_SIZE; int nVerticalBlocks = _environment->getHeight() / BLOCK_SIZE; for (int hb = 0; hb < nHorizontalBlocks; ++hb) { for (int vb = 0; vb < nVerticalBlocks; ++vb) { Point pMin( hb * BLOCK_SIZE, vb * BLOCK_SIZE ); Point pMax( pMin.x + BLOCK_SIZE - 1, pMin.y + BLOCK_SIZE - 1 ); addAntInBlock( pMin, pMax ); } } }
void CPlanarGraph::GetGraphBoundingBox(v2f& posMin, v2f& posMax) { v2f pMin(1e10); v2f pMax(-1e10); for ( int i=0; i<GetNumOfNodes(); i++ ) { v2f pi = GetNode(i).GetPos(); for ( int j=0; j<2; j++ ) { pMin[j] = min(pMin[j], pi[j]); pMax[j] = max(pMax[j], pi[j]); } } posMin = pMin; posMax = pMax; }
//----------------------------------------------------------------------------- ImplicitMesh::ImplicitMesh(SimpleMesh * mesh) : mSourceMesh(mesh), mData(NULL) { // Loop through all vertices in the mesh to determine the smallest // bounding box needed Vector3<float> pMin((std::numeric_limits<float>::max)(), (std::numeric_limits<float>::max)(), (std::numeric_limits<float>::max)()); Vector3<float> pMax(-(std::numeric_limits<float>::max)(), -(std::numeric_limits<float>::max)(), -(std::numeric_limits<float>::max)()); const std::vector<SimpleMesh::Vertex>& verts = mSourceMesh->GetVerts(); for(unsigned int i=0; i < verts.size(); i++){ const SimpleMesh::Vertex &v = verts.at(i); for (int j = 0; j < 3; j++) { if (pMin[j] > v.pos[j]) pMin[j] = v.pos[j]; if (pMax[j] < v.pos[j]) pMax[j] = v.pos[j]; } } // Pad with 0.1 to get around border issues Vector3<float> pad(0.1, 0.1, 0.1); pMin -= pad; pMax += pad; mBox = Bbox(pMin, pMax); std::cout << "Bounding box of implicit mesh: " << mBox << std::endl; }
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())); WriteMaterialData(child); _ftprintf(mStream, _T("</Object>\n")); break; //case LIGHT_CLASS_ID: // WriteLightData(child, idx); // break; } } //Write the Bounding Box _ftprintf(mStream, _T("<BoundingBox>\n")); _ftprintf(mStream, _T("\t<Min=%f,%f>\n"), pMin.x, pMin.y); _ftprintf(mStream, _T("\t<Max=%f,%f>\n"), pMax.x, pMax.y); _ftprintf(mStream, _T("</BoundingBox>\n")); //we are done exporting, so close the stream i->PushPrompt(_T("Closing file...")); fclose(mStream); MessageBox(nullptr, GetString(IDS_FINISH_MSG, msg), GetString(IDS_FINISH_CAP, cap), MB_OK | MB_ICONINFORMATION); return 1; }
dgMeshEffect * dgMeshEffect::CreateVoronoiConvexDecomposition (dgMemoryAllocator * const allocator, dgInt32 pointCount, dgInt32 pointStrideInBytes, const dgFloat32 * const pointCloud, dgInt32 materialId, const dgMatrix & textureProjectionMatrix) { dgFloat32 normalAngleInRadians = 30.0f * 3.1416f / 180.0f; dgStack<dgBigVector> buffer (pointCount + 16); dgBigVector * const pool = &buffer[0]; dgInt32 count = 0; dgFloat64 quantizeFactor = dgFloat64 (16.0f); dgFloat64 invQuantizeFactor = dgFloat64 (1.0f) / quantizeFactor; dgInt32 stride = pointStrideInBytes / sizeof (dgFloat32); dgBigVector pMin (dgFloat32 (1.0e10f), dgFloat32 (1.0e10f), dgFloat32 (1.0e10f), dgFloat32 (0.0f)); dgBigVector pMax (dgFloat32 (-1.0e10f), dgFloat32 (-1.0e10f), dgFloat32 (-1.0e10f), dgFloat32 (0.0f)); for (dgInt32 i = 0; i < pointCount; i ++) { dgFloat64 x = pointCloud[i * stride + 0]; dgFloat64 y = pointCloud[i * stride + 1]; dgFloat64 z = pointCloud[i * stride + 2]; x = floor (x * quantizeFactor) * invQuantizeFactor; y = floor (y * quantizeFactor) * invQuantizeFactor; z = floor (z * quantizeFactor) * invQuantizeFactor; dgBigVector p (x, y, z, dgFloat64 (0.0f)); pMin = dgBigVector (dgMin (x, pMin.m_x), dgMin (y, pMin.m_y), dgMin (z, pMin.m_z), dgFloat64 (0.0f)); pMax = dgBigVector (dgMax (x, pMax.m_x), dgMax (y, pMax.m_y), dgMax (z, pMax.m_z), dgFloat64 (0.0f)); pool[count] = p; count ++; } // add the bbox as a barrier pool[count + 0] = dgBigVector ( pMin.m_x, pMin.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 1] = dgBigVector ( pMax.m_x, pMin.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 2] = dgBigVector ( pMin.m_x, pMax.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 3] = dgBigVector ( pMax.m_x, pMax.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 4] = dgBigVector ( pMin.m_x, pMin.m_y, pMax.m_z, dgFloat64 (0.0f)); pool[count + 5] = dgBigVector ( pMax.m_x, pMin.m_y, pMax.m_z, dgFloat64 (0.0f)); pool[count + 6] = dgBigVector ( pMin.m_x, pMax.m_y, pMax.m_z, dgFloat64 (0.0f)); pool[count + 7] = dgBigVector ( pMax.m_x, pMax.m_y, pMax.m_z, dgFloat64 (0.0f)); count += 8; dgStack<dgInt32> indexList (count); count = dgVertexListToIndexList (&pool[0].m_x, sizeof (dgBigVector), 3, count, &indexList[0], dgFloat64 (5.0e-2f)); dgAssert (count >= 8); dgFloat64 maxSize = dgMax (pMax.m_x - pMin.m_x, pMax.m_y - pMin.m_y, pMax.m_z - pMin.m_z); pMin -= dgBigVector (maxSize, maxSize, maxSize, dgFloat64 (0.0f)); pMax += dgBigVector (maxSize, maxSize, maxSize, dgFloat64 (0.0f)); // add the a guard zone, so that we do no have to clip dgInt32 guadVertexKey = count; pool[count + 0] = dgBigVector ( pMin.m_x, pMin.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 1] = dgBigVector ( pMax.m_x, pMin.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 2] = dgBigVector ( pMin.m_x, pMax.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 3] = dgBigVector ( pMax.m_x, pMax.m_y, pMin.m_z, dgFloat64 (0.0f)); pool[count + 4] = dgBigVector ( pMin.m_x, pMin.m_y, pMax.m_z, dgFloat64 (0.0f)); pool[count + 5] = dgBigVector ( pMax.m_x, pMin.m_y, pMax.m_z, dgFloat64 (0.0f)); pool[count + 6] = dgBigVector ( pMin.m_x, pMax.m_y, pMax.m_z, dgFloat64 (0.0f)); pool[count + 7] = dgBigVector ( pMax.m_x, pMax.m_y, pMax.m_z, dgFloat64 (0.0f)); count += 8; dgDelaunayTetrahedralization delaunayTetrahedras (allocator, &pool[0].m_x, count, sizeof (dgBigVector), dgFloat32 (0.0f)); delaunayTetrahedras.RemoveUpperHull (); // delaunayTetrahedras.Save("xxx0.txt"); dgInt32 tetraCount = delaunayTetrahedras.GetCount(); dgStack<dgBigVector> voronoiPoints (tetraCount + 32); dgStack<dgDelaunayTetrahedralization::dgListNode *> tetradrumNode (tetraCount); dgTree<dgList<dgInt32>, dgInt32> delanayNodes (allocator); dgInt32 index = 0; const dgHullVector * const delanayPoints = delaunayTetrahedras.GetHullVertexArray(); for (dgDelaunayTetrahedralization::dgListNode * node = delaunayTetrahedras.GetFirst(); node; node = node->GetNext()) { dgConvexHull4dTetraherum & tetra = node->GetInfo(); voronoiPoints[index] = tetra.CircumSphereCenter (delanayPoints); tetradrumNode[index] = node; for (dgInt32 i = 0; i < 4; i ++) { dgTree<dgList<dgInt32>, dgInt32>::dgTreeNode * header = delanayNodes.Find (tetra.m_faces[0].m_index[i]); if (!header) { dgList<dgInt32> list (allocator); header = delanayNodes.Insert (list, tetra.m_faces[0].m_index[i]); } header->GetInfo().Append (index); } index ++; } dgMeshEffect * const voronoiPartition = new (allocator) dgMeshEffect (allocator); voronoiPartition->BeginPolygon(); dgFloat64 layer = dgFloat64 (0.0f); dgTree<dgList<dgInt32>, dgInt32>::Iterator iter (delanayNodes); for (iter.Begin(); iter; iter ++) { dgTree<dgList<dgInt32>, dgInt32>::dgTreeNode * const nodeNode = iter.GetNode(); const dgList<dgInt32> & list = nodeNode->GetInfo(); dgInt32 key = nodeNode->GetKey(); if (key < guadVertexKey) { dgBigVector pointArray[512]; dgInt32 indexArray[512]; dgInt32 count = 0; for (dgList<dgInt32>::dgListNode * ptr = list.GetFirst(); ptr; ptr = ptr->GetNext()) { dgInt32 i = ptr->GetInfo(); pointArray[count] = voronoiPoints[i]; count ++; dgAssert (count < dgInt32 (sizeof (pointArray) / sizeof (pointArray[0]))); } count = dgVertexListToIndexList (&pointArray[0].m_x, sizeof (dgBigVector), 3, count, &indexArray[0], dgFloat64 (1.0e-3f)); if (count >= 4) { dgMeshEffect convexMesh (allocator, &pointArray[0].m_x, count, sizeof (dgBigVector), dgFloat64 (0.0f)); if (convexMesh.GetCount()) { convexMesh.CalculateNormals (normalAngleInRadians); convexMesh.UniformBoxMapping (materialId, textureProjectionMatrix); for (dgInt32 i = 0; i < convexMesh.m_pointCount; i ++) convexMesh.m_points[i].m_w = layer; for (dgInt32 i = 0; i < convexMesh.m_atribCount; i ++) convexMesh.m_attrib[i].m_vertex.m_w = layer; voronoiPartition->MergeFaces (&convexMesh); layer += dgFloat64 (1.0f); } } } } voronoiPartition->EndPolygon (dgFloat64 (1.0e-8f), false); // voronoiPartition->SaveOFF("xxx0.off"); //voronoiPartition->ConvertToPolygons(); return voronoiPartition; }
void PEffectGlow::setBlurIterations(pint32 number) { m_blurIterations = pMax(number, pint32(1)); }
void PPropertyInt::operator=(pint32 value) { m_value = pMin(m_range[1], pMax(value, m_range[0])); }
/* * Break up commands into data that can be passed into the function * Parameters: * char* linePointer - Chooses which command function to call and passes tokens based on this string * struct annual_stats* dataStruct - Data from stdin */ void processCommands(char* linePointer, struct annual_stats* dataStruct) { readLine(linePointer); int numOfCommands = atoi(linePointer); char delim[2] = " "; for (int i = 0; i < numOfCommands; i++) { readLine(linePointer); char* command = strtok(linePointer, delim); if(strcmp(command, "bsort") == 0) { char* temp = strtok(NULL, delim); //Either 2 for year '20xx' or r for 'range' if(temp[0] == '2') { int year = atoi(temp); char* field = strtok(NULL,delim); char* order = strtok(NULL,delim); struct package* package = orderPackage(year, year, field, dataStruct); bSortY(package, field, order); } else if(temp[0] == 'r') { int start = atoi(strtok(NULL,delim)); int end = atoi(strtok(NULL,delim)); char* field = strtok(NULL,delim); char* order = strtok(NULL,delim); struct package* package = orderPackage(start, end, field, dataStruct); bSortR(package, field, order, (end - start)); } else printf("Error in calling sort function.\n"); } else if (strcmp(command, "bfind") == 0) { int year = atoi(strtok(NULL,delim));; char* field = strtok(NULL,delim); char* item = strtok(NULL,delim); struct package* package = orderPackage(year, year, field, dataStruct); bFind(package, field, item); } else if(strcmp(command, "qsort") == 0) { char* temp = strtok(NULL, delim); //Either 2 for year '20xx' or r for 'range' if(temp[0] == '2') { int year = atoi(temp); char* field = strtok(NULL,delim); char* order = strtok(NULL,delim); struct package* package = orderPackage(year, year, field, dataStruct); qSortY(package, field, order); } else if(temp[0] == 'r') { int start = atoi(strtok(NULL,delim)); int end = atoi(strtok(NULL,delim)); char* field = strtok(NULL,delim); char* order = strtok(NULL,delim); struct package* package = orderPackage(start, end, field, dataStruct); qSortR(package, field, order, (end - start)); } else printf("Error in calling sort function.\n"); } else if (strcmp(command, "qfind") == 0) { int year = atoi(strtok(NULL,delim));; char* field = strtok(NULL,delim); char* item = strtok(NULL,delim); struct package* package = orderPackage(year, year, field, dataStruct); qFind(package, field, item); } else if (strcmp(command, "pmax") == 0) { int year = atoi(strtok(NULL,delim));; char* field = strtok(NULL,delim); struct package* package = orderPackage(year, year, field, dataStruct); pMax(package, field); } else if (strcmp(command, "pmin") == 0) { int year = atoi(strtok(NULL,delim));; char* field = strtok(NULL,delim); struct package* package = orderPackage(year, year, field, dataStruct); pMin(package, field); } } }