[Closed] The Quick 'n' Dirty Way to extend MXS with the SDK

Thank you.

Klvnk, thank you! I will try this! Shouldn’t you use smth like loadscript, filin or smth like this?

the best extending functions by a country mile are

def_struct_primitive(polyop_getMapVertsUsingVert, polyop, "getMapVertsUsingVert");

// <bitarray> polyop.getMapVertsUsingVert <Poly poly> <int mapChannel> <vertlist>
  
  Value* polyop_getMapVertsUsingVert_cf(Value** arg_list, int arg_count)
  {
  // the usual arg check
  
  	check_arg_count(getMapVertsUsingVert, 3, arg_count);
  
  // get the poly mesh
  
  	MNMesh* pmesh = get_polyForValue(arg_list[0], MESH_READ_ACCESS, NULL, getMapVertsUsingVert);
  
  	int channel = arg_list[1]->to_int();
  	checkMapChannel(pmesh,channel);
  
  // ok to access the map
  
  	MNMap* map = pmesh->M(channel);
  	int nVerts  = pmesh->numv;
  	int nMapVerts = map->numv;
  	int nMapFaces = map->numf;
  
  // create a new bitarray from input which could be a bitarray, int or array of ints
  
  	BitArray verts(nVerts);
  	ValueToBitArray(arg_list[2], verts, nVerts, GetString(IDS_VERTEX_INDEX_OUT_OF_RANGE));
  
  // create the return bitarray variable on the stack
  
  	one_typed_value_local(BitArrayValue* mapVerts);
  	vl.mapVerts = new BitArrayValue(nMapVerts);
  
  	for(int f=0; f < nMapFaces; f++)
  	{
  		MNFace*	face = pmesh->F(f);
  
  // skip over dead faces
  
  		if(face->GetFlag(MN_DEAD)) 
  			continue;
  
  		MNMapFace* mapface = map->F(f);
  
  		for(int j=0; j < face->deg; j++) 
  		{
  			if(verts[face->vtx[j]])
  			{
  				vl.mapVerts->bits.Set(mapface->tv[j]);
  				break; // should only be one per face
  			}
  		}
  	}
  	return_value(vl.mapVerts);
  }

and the mesh varient

//********************************************************************************************
  // meshop.getMapVertsUsingVert
  //<bitarray mapverts> meshop.getMapVertsUsingVert  <Mesh mesh\> <int mapChannel> <int vert>
 
  def_struct_primitive(meshop_getMapVertsUsingVert, meshop, "getMapVertsUsingVert");
  
  Value* meshop_getMapVertsUsingVert_cf(Value **arg_list, int count)
  {
  	check_arg_count(getMapVertsUsingVert, 3, count);
  
  // mesh
  
  	Mesh* mesh = get_meshForValue(arg_list[0], MESH_READ_ACCESS, NULL, getMapVertsUsingVert);
  
  // channel
  
  	int mapChannel = arg_list[1]->to_int();
  	range_check(mapChannel, -NUM_HIDDENMAPS, MAX_MESHMAPS-1, GetString(IDS_MESH_MAP_CHANNEL_OUT_OF_RANGE));
  	if(!mesh->mapSupport(mapChannel))
  		throw RuntimeError (GetString(IDS_MAP_SUPPORT_NOT_ENABLED_FOR_CHANNEL), Integer::intern(mapChannel));
  
  // vert
  
  	int	vert = arg_list[2]->to_int() - 1; // mxs to sdk
  	range_check(vert,0,(mesh->numVerts - 1), GetString(IDS_VERTEX_INDEX_OUT_OF_RANGE));
  
  // create the return bitarray variable on the stack
  
  	one_typed_value_local(BitArrayValue* mapVerts);
  	vl.mapVerts = new BitArrayValue(mesh->getNumMapVerts(mapChannel));
  	
  // get the pointer to the map faces
  
  	TVFace*	mapfaces = mesh->mapFaces(mapChannel);
  
  // for all the faces, find our vert, and tag the same "corner" in the map face
  
  	int nfaces = mesh->numFaces;
  	for(int i = 0; i < nfaces; ++i)
  	{
  		Face& geoface = mesh->faces[i]; // 
  		for(int j=0; j < 3; ++j) 
  		{
  			if(geoface.v[j] == vert)
  			{
  				vl.mapVerts->bits.Set(mapfaces[i].t[j]);
  				break; // should only be one per face
  			}
  		}
  	}
  	return_value(vl.mapVerts);
  }

Klunk, Thanks for this, very helpful.

Is there a way to return the collection of BitArrayValues? Say if I’d like to get all the mesh elements as an array of bitarrays. Is it even possible?
Thanks

upd Found the answer in this incredible thread. Thank you guys!