void Awake () { anim = GetComponent<Animator>(); SFX = GetComponent<AudioSource>(); health = startingHealth; meshCollider = GetComponent<MeshCollider>(); meshCollider.enabled = false; }
/// <summary> /// This handles when draging and dropping a zosim project file /// </summary> // private void OnPreprocessAsset() { // ZOImportZeroSim.ZeroSimProjectFile = this.assetPath; // ZOImportZeroSim.ImportFusion360Project(); // } // See: https://gist.github.com/ACap99/61e309688a53377b0dceaa7efce1a8e3 & https://stackoverflow.com/questions/53931129/cant-create-collision-mesh-for-a-child-gameobject void OnPostprocessModel(GameObject go) { // Add convex mesh collider and disable rendering for collision meshes if (IsProcessingZOSimColliders) { Debug.Log("INFO: ZOImportZeroSimProcessor::OnPostprocessModel: " + go.name); // BUGBUG: always assuming the 0 child game object GameObject meshGameObject = go.transform.GetChild(0).gameObject; // create the meshcollider UnityEngine.MeshCollider meshCollider = meshGameObject.AddComponent <UnityEngine.MeshCollider>(); meshCollider.convex = true; // disable meshrenderer for collider meshGameObject.GetComponent <MeshRenderer>().enabled = false; // save back prefab string assetPath = AssetDatabase.GetAssetPath(go); if (assetPath.Length > 0) { PrefabUtility.SaveAsPrefabAsset(go, assetPath); } else { Debug.LogWarning("WARNING: invalid asset path for: " + go.name); } } }
private void BuildMesh (MeshFilter mf, MeshRenderer mr, MeshCollider mc, int i, int j) { Mesh mesh = new Mesh(); mesh.Clear(); // the vertices of our new mesh, separated into two groups Vector3[] inner = new Vector3[grid.smoothness + 1]; // the inner vertices (closer to the centre) Vector3[] outer = new Vector3[grid.smoothness + 1]; // the outer vertices // vertices must be given in local space Transform trnsfrm = mf.gameObject.transform; // the amount of vertices depends on how much the grid is smoothed for (int k = 0; k < grid.smoothness + 1; k++) { // rad is the current distance from the centre, sctr is the current sector and i * (1.0f / grid.smoothness) is the fraction inside the current sector inner[k] = trnsfrm.InverseTransformPoint(grid.GridToWorld(new Vector3(i, j + k * (1.0f / grid.smoothness), 0))); outer[k] = trnsfrm.InverseTransformPoint(grid.GridToWorld(new Vector3(i + 1, j + k * (1.0f / grid.smoothness), 0))); } //this is wher the actual vertices go Vector3[] vertices = new Vector3[2 * (grid.smoothness + 1)]; // copy the sorted vertices into the new array inner.CopyTo(vertices, 0); // for each inner vertex its outer counterpart has the same index plus grid.smoothness + 1, this will be relevant later outer.CopyTo(vertices, grid.smoothness + 1); // assign them as the vertices of the mesh mesh.vertices = vertices; // now we have to assign the triangles int[] triangles = new int[6 * grid.smoothness]; // for each smoothing step we need two triangles and each triangle is three indices int counter = 0; // keeps track of the current index for (int k = 0; k < grid.smoothness; k++) { // triangles are assigned in a clockwise fashion triangles[counter] = k; triangles[counter+1] = k + (grid.smoothness + 1) + 1; triangles[counter+2] = k + (grid.smoothness + 1); triangles[counter+3] = k + 1; triangles[counter+4] = k + (grid.smoothness + 1) + 1; triangles[counter+5] = k; counter += 6; // increment the counter for the nex six indices } mesh.triangles = triangles; // add some dummy UVs to keep the shader happy or else it complains, but they are not used in this example Vector2[] uvs = new Vector2[vertices.Length]; for (int k = 0; k < uvs.Length; k++) { uvs[k] = new Vector2(vertices[k].x, vertices[k].y); } mesh.uv = uvs; // the usual cleanup mesh.RecalculateNormals(); mesh.RecalculateBounds(); mesh.Optimize(); // assign the mesh to the mesh filter and mesh collider mf.mesh = mesh; mc.sharedMesh = mesh; }
// Use this for initialization void Start () { mesh = GetComponent<MeshFilter> ().mesh; meshC = GetComponent<MeshCollider> (); vertices = mesh.vertices; fireballs = GameObject.FindGameObjectsWithTag("Fireball"); Debug.Log (vertices.Length); }
// Use this for initialization void Start() { // check this node for mReferenceCollider if (mReferenceCollider == null) { mReferenceCollider = this.GetComponent<BoxCollider>(); } if (mReferenceCollider == null) { mReferenceCollider = this.GetComponent<SphereCollider>(); } if (mReferenceCollider == null) { mReferenceCollider = this.GetComponent<CapsuleCollider>(); // unlikely. } // check the parent node for mReferenceCollider if (mReferenceCollider == null) { mReferenceCollider = this.transform.parent.GetComponent<BoxCollider>(); } if (mReferenceCollider == null) { mReferenceCollider = this.transform.parent.GetComponent<SphereCollider>(); } if (mReferenceCollider == null) { mReferenceCollider = this.transform.parent.GetComponent<CapsuleCollider>(); // unlikely. } if (mMeshCollider == null) { mMeshCollider = this.GetComponent<MeshCollider>(); } }
void Awake() { GetComponent <MeshFilter>().mesh = hexMesh = new UnityEngine.Mesh(); meshCollider = gameObject.AddComponent <UnityEngine.MeshCollider>(); hexMesh.name = "Hex Mesh"; EntityManager entityManager = World.DefaultGameObjectInjectionWorld.EntityManager; EntityArchetype hexMeshArchetype = entityManager.CreateArchetype( typeof(LocalToWorld), typeof(RenderMesh), typeof(RenderBounds), typeof(HexMeshTag), typeof(PhysicsCollider), typeof(Translation), typeof(Rotation) ); entity = entityManager.CreateEntity(hexMeshArchetype); entityManager.SetSharedComponentData(entity, new RenderMesh { mesh = hexMesh, material = hexMaterial }); }
public void DestroyColliderData(tk2dTileMap tileMap) { if (this.colliderMesh != null) { tileMap.DestroyMesh(this.colliderMesh); } if (((this.meshCollider != null) && (this.meshCollider.sharedMesh != null)) && (this.meshCollider.sharedMesh != this.colliderMesh)) { tileMap.DestroyMesh(this.meshCollider.sharedMesh); } if (this.meshCollider != null) { tk2dUtil.DestroyImmediate(this.meshCollider); } this.meshCollider = null; this.colliderMesh = null; if (this.edgeColliders.Count > 0) { for (int i = 0; i < this.edgeColliders.Count; i++) { tk2dUtil.DestroyImmediate(this.edgeColliders[i]); } this.edgeColliders.Clear(); } }
// Use this for initialization void Awake() { rMesh = gameObject.GetComponent<MeshRenderer>(); fMesh = gameObject.GetComponent<MeshFilter>(); cMesh = gameObject.GetComponent<MeshCollider>(); mesh = new Mesh(); }
public void DuplicateOldChunk(string ChunkData) { meshCollider = GetComponent<MeshCollider>(); map = new byte[width, width, width]; int iter = 0; for (int x = 0; x < width; x++) { for (int z = 0; z < width; z++) { //make the bottom layer of the chunk all solid blocks if(ChunkData[iter] == '0') map[x,0,z]=0; else map[x,0,z]=1; iter++; //make the second layer of the chunk random if(ChunkData[iter] == '0') map[x,1,z]=0; else map[x,1,z]=1; iter++; } } mesh = new Mesh(); GetComponent<MeshFilter>().mesh = mesh; Regenerate(); }
private void pStart() { _collider = (MeshCollider)gameObject.collider; //this sets the collider mesh to equal the objects mesh filter. //May not be required if you aren't using 2D Toolkit _collider.sharedMesh = gameObject.GetComponent<MeshFilter>().sharedMesh; }
void Start() { collider=GetComponent<MeshCollider>(); startRot=transform.rotation; rbody=GetComponent<Rigidbody>(); startPos=transform.position; }
// Use this for initialization void Start() { hmul = 1F / hardness; mf = GetComponent<MeshFilter> (); mc = GetComponent<MeshCollider> (); verts = mf.mesh.vertices; tris = mf.mesh.triangles; //mf.mesh.SetIndices (tris, MeshTopology.LineStrip, 0); connections = new VertexConnection[verts.Length]; for (int i = 0; i < verts.Length; i++) { Vector3 P1 = verts [i]; VertexConnection VC1 = connections [i]; for (int n = i+1; n < verts.Length; n++) { if (P1 == verts [n]) { var VC2 = connections [n]; if (VC2 == null) VC2 = connections [n] = new VertexConnection (); if (VC1 == null) VC1 = connections [i] = new VertexConnection (); VC1.connections.Add (n); VC2.connections.Add (i); } } } }
public void GenerateMesh(int[,] map, float squareSize) { if(wallCollider == null) { wallCollider = walls.gameObject.AddComponent<MeshCollider> (); } outlines.Clear(); checkedVertices.Clear (); triangleDictionary.Clear(); squareGrid = new SquareGrid(map, squareSize); vertices = new List<Vector3>(); triangles = new List<int>(); for (int x = 0; x < squareGrid.squares.GetLength(0); x++) { for(int y =0; y < squareGrid.squares.GetLength(1); y++) { TriangulateSquare(squareGrid.squares[x,y]); } } Mesh mesh = new Mesh(); cave.mesh = mesh; mesh.vertices = vertices.ToArray(); mesh.triangles = triangles.ToArray(); mesh.RecalculateNormals(); if(!is2D) { CreateWallMesh(); } }
// Use this for initialization protected void Awake() { Filter = gameObject.GetComponent<MeshFilter>(); Coll = gameObject.GetComponent<MeshCollider>(); //past here is just to set up an example chunk //Blocks = new VoxBlock[ChunkSize, ChunkSize, ChunkSize]; for (var x = 0; x < World.ChunkSize; x++) { for (var y = 0; y < World.ChunkSize; y++) { for (var z = 0; z < World.ChunkSize; z++) { Blocks[x, y, z] = new Block(Color.white) { BlockType = VoxBlockType.Empty }; } } } //Blocks[1, 14, 1] = new VoxBlock(); //Blocks[3, 5, 2] = new VoxBlock(); //Blocks[4, 5, 2] = new VoxBlock(); //UpdateChunk(); }
/// <summary> /// Initialized the components /// </summary> void Awake() { this.isoObj = GetComponent<IsoObject>(); this.collider = GetComponent<MeshCollider>(); collider.sharedMesh = createMesh(); deltaSize = isoObj.Size; }
void Start() { filter = gameObject.GetComponent<MeshFilter>(); coll = gameObject.GetComponent<MeshCollider>(); //past here is just to set up an example chunk blocks = new Block[chunkSize, chunkSize, chunkSize]; for (int x = 0; x < chunkSize; x++) { for (int y = 0; y < chunkSize; y++) { for (int z = 0; z < chunkSize; z++) { blocks[x, y, z] = new BlockAir(); } } } blocks[1, 1, 1] = new Block(); blocks[1, 2, 1] = new Block(); blocks[1, 2, 2] = new Block(); blocks[2, 2, 2] = new Block(); UpdateChunk(); }
static public int constructor(IntPtr l) { UnityEngine.MeshCollider o; o = new UnityEngine.MeshCollider(); pushObject(l, o); return(1); }
void Start() { if (DataManager == null) DataManager = GetManager.GetDataManager (); // need a better way to do this, keep references in a static object..! HasInitialLoad = false; filter = gameObject.GetComponent<MeshFilter>(); coll = gameObject.GetComponent<MeshCollider>(); }
// Use this for initialization void Start() { world = GameObject.FindWithTag("world").GetComponent("World") as World; displayBlock = new BlockSelect(); filter = gameObject.GetComponent<MeshFilter>(); coll = gameObject.GetComponent<MeshCollider>(); }
static public int set_sharedMesh(IntPtr l) { UnityEngine.MeshCollider o = (UnityEngine.MeshCollider)checkSelf(l); UnityEngine.Mesh v; checkType(l, 2, out v); o.sharedMesh = v; return(0); }
void Start(){ mesh = GetComponent<MeshFilter>().mesh; meshCollider = GetComponent<MeshCollider>(); GenerateTerrain(); BuildMesh(); UpdateMesh(); }
public void Initialize (World world, Chunk chunk, MeshFilter meshFilter, MeshCollider meshCollider) { this.meshFilter = meshFilter; this.meshCollider = meshCollider; this.chunk = chunk; this.world = world; this.lastLevelY = world.LevelY; }
/// <summary> /// Initialized the components /// </summary> void Awake() { this.isoObj = GetComponent<IsoObject>(); this.collider = GetComponent<MeshCollider>(); collider.sharedMesh = createMesh(); deltaSize = isoObj.Size; Isometric.projectGravityVector(); }
public void AddCollider() { if(hasCollider == false){ hasCollider = true; gameObject.AddComponent<MeshCollider>(); meshCollider = this.GetComponent<MeshCollider>(); UpdateCollider(); } }
public void GenerateMesh(Voxel[] voxels, float voxelSize,float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode mode, MeshingMode colliderMode, bool immediate) #endif { if (mf == null) mf = GetComponent<MeshFilter>(); if (mc == null) mc = GetComponent<MeshCollider>(); if (immediate) { #if UNITY_EDITOR Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2, selfShadeIntensity, mode, paintMode); #else Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2, selfShadeIntensity, mode); #endif SetMesh(); if (colliderMode != mode &&transform.parent.parent.parent.GetComponent<Volume>().CollisionMode != CollisionMode.None) { #if UNITY_EDITOR Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2, selfShadeIntensity, mode, paintMode); #else Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2, selfShadeIntensity, mode); #endif } if (transform.parent.parent.parent.GetComponent<Volume>().CollisionMode != CollisionMode.None) SetColliderMesh(); } else { if (status != ChunkStatus.NoChange) return; #if UNITY_WINRT && !UNITY_EDITOR System.Threading.Tasks.Task.Run(() => { GenerateThreaded(ref voxels, voxelSize, xOffset, yOffset, zOffset, xSize, ySize, zSize,ub0, ub1, ub2, selfShadeIntensity, mode); }); #else #if UNITY_EDITOR ThreadPool.QueueUserWorkItem(delegate { GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2, selfShadeIntensity, mode, paintMode); }); #else ThreadPool.QueueUserWorkItem(delegate { GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize,ub0, ub1, ub2, selfShadeIntensity, mode); }); #endif #endif } }
/// <summary> /// <para>Constructor for conveniently filling out a SurfaceData struct.</para> /// </summary> /// <param name="_id">ID for the surface in question.</param> /// <param name="_outputMesh">MeshFilter to write Mesh data to.</param> /// <param name="_outputAnchor">WorldAnchor receiving the anchor point for the surface.</param> /// <param name="_outputCollider">MeshCollider to write baked physics data to (optional).</param> /// <param name="_trianglesPerCubicMeter">Requested resolution for the computed Mesh. Actual resolution may be less than this value.</param> /// <param name="_bakeCollider">Set to true if collider baking is/has been requested.</param> public SurfaceData(SurfaceId _id, MeshFilter _outputMesh, WorldAnchor _outputAnchor, MeshCollider _outputCollider, float _trianglesPerCubicMeter, bool _bakeCollider) { this.id = _id; this.outputMesh = _outputMesh; this.outputAnchor = _outputAnchor; this.outputCollider = _outputCollider; this.trianglesPerCubicMeter = _trianglesPerCubicMeter; this.bakeCollider = _bakeCollider; }
private CWeightList[] nodeWeights; // array of node weights (one per node) #endregion Fields #region Methods // Function: Start // This basically translates the information about the skinned mesh into // data that we can internally use to quickly update the collision mesh. void Start() { SkinnedMeshRenderer rend = GetComponent(typeof(SkinnedMeshRenderer)) as SkinnedMeshRenderer; collide = GetComponent(typeof(MeshCollider)) as MeshCollider; if (collide!=null && rend!=null) { Mesh baseMesh = rend.sharedMesh; mesh = new Mesh(); mesh.vertices = baseMesh.vertices; mesh.uv = baseMesh.uv; mesh.triangles = baseMesh.triangles; newVert = new Vector3[baseMesh.vertices.Length]; short i; // Make a CWeightList for each bone in the skinned mesh nodeWeights = new CWeightList[rend.bones.Length]; for ( i=0 ; i<rend.bones.Length ; i++ ) { nodeWeights[i] = new CWeightList(); nodeWeights[i].transform = rend.bones[i]; } // Create a bone weight list for each bone, ready for quick calculation during an update... Vector3 localPt; for ( i=0 ; i<baseMesh.vertices.Length ; i++ ) { BoneWeight bw = baseMesh.boneWeights[i]; if (bw.weight0!=0.0f) { localPt = baseMesh.bindposes[bw.boneIndex0].MultiplyPoint3x4( baseMesh.vertices[i] ); nodeWeights[bw.boneIndex0].weights.Add( new CVertexWeight( i, localPt, bw.weight0 ) ); } if (bw.weight1!=0.0f) { localPt = baseMesh.bindposes[bw.boneIndex1].MultiplyPoint3x4( baseMesh.vertices[i] ); nodeWeights[bw.boneIndex1].weights.Add( new CVertexWeight( i, localPt, bw.weight1 ) ); } if (bw.weight2!=0.0f) { localPt = baseMesh.bindposes[bw.boneIndex2].MultiplyPoint3x4( baseMesh.vertices[i] ); nodeWeights[bw.boneIndex2].weights.Add( new CVertexWeight( i, localPt, bw.weight2 ) ); } if (bw.weight3!=0.0f) { localPt = baseMesh.bindposes[bw.boneIndex3].MultiplyPoint3x4( baseMesh.vertices[i] ); nodeWeights[bw.boneIndex3].weights.Add( new CVertexWeight( i, localPt, bw.weight3 ) ); } } UpdateCollisionMesh(); } else { Debug.LogError(gameObject.name + ": SkinnedCollisionHelper: this object either has no SkinnedMeshRenderer or has no MeshCollider!"); } }
// Use this for initialization void Start () { //world = worldGO.GetComponent ( "World" ) as World; mesh = GetComponent<MeshFilter> ().mesh; col = GetComponent<MeshCollider> (); //PreBuildChunk2 (); }
void Start() { Count++; meshFilter = GetComponent<MeshFilter> (); meshCollider = GetComponent<MeshCollider> (); transform.localScale = Vector3.one * size; GenerateMesh(); }
public void Initialize(Block[, ,] data, int size, Material material, Terrain world) { _meshFilter = GetComponent<MeshFilter>(); _meshCollider = GetComponent<MeshCollider>(); GetComponent<MeshRenderer>().material = material; this._data = data; _size = size; _parentWorld = world; }
public void Initialize(ChunkSaveData saveData, int size, Material material, Terrain world) { _meshFilter = GetComponent<MeshFilter>(); _meshCollider = GetComponent<MeshCollider>(); this._data = Helper.SingleToMulti(size,size,size,saveData.Data); GetComponent<MeshRenderer>().material = material; _size = size; _parentWorld = world; }
static public int set_convex(IntPtr l) { UnityEngine.MeshCollider o = (UnityEngine.MeshCollider)checkSelf(l); bool v; checkType(l, 2, out v); o.convex = v; return(0); }
void Start() { mCol = GetComponent<MeshCollider>(); actionHandler = GetComponent<ActionHandler>(); if(actionHandler) { actionHandler.TakeAction += EnableG; } }
void Start() { audio = GetComponent<AudioSource>(); boxCollider = GetComponent<BoxCollider>(); meshCollider = GetComponentInChildren<MeshCollider>(); fallingTime = 0; falling = false; fallen = false; }
static public int set_smoothSphereCollisions(IntPtr l) { UnityEngine.MeshCollider o = (UnityEngine.MeshCollider)checkSelf(l); bool v; checkType(l, 2, out v); o.smoothSphereCollisions = v; return(0); }
public void deactivateMarkers() { for (int i=1; i<locationPoints.Length; i++) { GameObject marker = locationPoints [i].gameObject; fade = marker.GetComponent<FadeObjectInOut> (); fade.FadeOut (); coll = marker.GetComponent<MeshCollider> (); coll.enabled = false; } }
static public int get_cookingOptions(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); pushEnum(l, (int)self.cookingOptions); return(1); } catch (Exception e) { return(error(l, e)); } }
static public int get_convex(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); pushValue(l, self.convex); return(1); } catch (Exception e) { return(error(l, e)); } }
static public int get_smoothSphereCollisions(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); pushValue(l, self.smoothSphereCollisions); return(1); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
static public int constructor(IntPtr l) { try { UnityEngine.MeshCollider o; o = new UnityEngine.MeshCollider(); pushValue(l, o); return(1); } catch (Exception e) { return(error(l, e)); } }
static public int get_sharedMesh(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); pushValue(l, true); pushValue(l, self.sharedMesh); return(2); } catch (Exception e) { return(error(l, e)); } }
static public int constructor(IntPtr l) { try { UnityEngine.MeshCollider o; o = new UnityEngine.MeshCollider(); pushValue(l, o); return(1); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
static public int set_cookingOptions(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); UnityEngine.MeshColliderCookingOptions v; checkEnum(l, 2, out v); self.cookingOptions = v; return(0); } catch (Exception e) { return(error(l, e)); } }
static public int set_convex(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); bool v; checkType(l, 2, out v); self.convex = v; return(0); } catch (Exception e) { return(error(l, e)); } }
static public int set_sharedMesh(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); UnityEngine.Mesh v; checkType(l, 2, out v); self.sharedMesh = v; return(0); } catch (Exception e) { return(error(l, e)); } }
static public int constructor(IntPtr l) { LuaDLL.lua_remove(l, 1); UnityEngine.MeshCollider o; if (matchType(l, 1)) { o = new UnityEngine.MeshCollider(); pushObject(l, o); return(1); } LuaDLL.luaL_error(l, "New object failed."); return(0); }
static public int set_inflateMesh(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); bool v; checkType(l, 2, out v); self.inflateMesh = v; pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
static public int set_smoothSphereCollisions(IntPtr l) { try { UnityEngine.MeshCollider self = (UnityEngine.MeshCollider)checkSelf(l); bool v; checkType(l, 2, out v); self.smoothSphereCollisions = v; return(0); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
static void MeshCollider_smoothSphereCollisions(JSVCall vc) { if (vc.bGet) { UnityEngine.MeshCollider _this = (UnityEngine.MeshCollider)vc.csObj; var result = _this.smoothSphereCollisions; JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(result)); } else { System.Boolean arg0 = (System.Boolean)JSApi.getBooleanS((int)JSApi.GetType.Arg); UnityEngine.MeshCollider _this = (UnityEngine.MeshCollider)vc.csObj; _this.smoothSphereCollisions = arg0; } }
// fields // properties static void MeshCollider_sharedMesh(JSVCall vc) { if (vc.bGet) { UnityEngine.MeshCollider _this = (UnityEngine.MeshCollider)vc.csObj; var result = _this.sharedMesh; JSMgr.datax.setObject((int)JSApi.SetType.Rval, result); } else { UnityEngine.Mesh arg0 = (UnityEngine.Mesh)JSMgr.datax.getObject((int)JSApi.GetType.Arg); UnityEngine.MeshCollider _this = (UnityEngine.MeshCollider)vc.csObj; _this.sharedMesh = arg0; } }
/// <summary> /// Write the specified value using the writer. /// </summary> /// <param name="value">Value.</param> /// <param name="writer">Writer.</param> public override void Write(object value, ISaveGameWriter writer) { UnityEngine.MeshCollider meshCollider = (UnityEngine.MeshCollider)value; writer.WriteProperty("sharedMesh", meshCollider.sharedMesh); writer.WriteProperty("convex", meshCollider.convex); writer.WriteProperty("inflateMesh", meshCollider.inflateMesh); writer.WriteProperty("skinWidth", meshCollider.skinWidth); writer.WriteProperty("enabled", meshCollider.enabled); writer.WriteProperty("isTrigger", meshCollider.isTrigger); writer.WriteProperty("contactOffset", meshCollider.contactOffset); writer.WriteProperty("material", meshCollider.material); writer.WriteProperty("sharedMaterial", meshCollider.sharedMaterial); writer.WriteProperty("tag", meshCollider.tag); writer.WriteProperty("name", meshCollider.name); writer.WriteProperty("hideFlags", meshCollider.hideFlags); }
static int get_sharedMesh(IntPtr L) { UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)ToLua.ToObject(L, 1); UnityEngine.Mesh ret = null; try { ret = obj.sharedMesh; } catch (Exception e) { return(LuaDLL.luaL_error(L, obj == null ? "attempt to index sharedMesh on a nil value" : e.Message)); } ToLua.Push(L, ret); return(1); }
static int get_convex(IntPtr L) { UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)ToLua.ToObject(L, 1); bool ret; try { ret = obj.convex; } catch (Exception e) { return(LuaDLL.luaL_error(L, obj == null ? "attempt to index convex on a nil value" : e.Message)); } LuaDLL.lua_pushboolean(L, ret); return(1); }
static int get_skinWidth(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; float ret = obj.skinWidth; LuaDLL.lua_pushnumber(L, ret); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o, "attempt to index skinWidth on a nil value")); } }
static int get_inflateMesh(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; bool ret = obj.inflateMesh; LuaDLL.lua_pushboolean(L, ret); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o, "attempt to index inflateMesh on a nil value")); } }
static int set_sharedMesh(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; UnityEngine.Mesh arg0 = (UnityEngine.Mesh)ToLua.CheckUnityObject(L, 2, typeof(UnityEngine.Mesh)); obj.sharedMesh = arg0; return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index sharedMesh on a nil value" : e.Message)); } }
static int set_inflateMesh(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; bool arg0 = LuaDLL.luaL_checkboolean(L, 2); obj.inflateMesh = arg0; return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index inflateMesh on a nil value" : e.Message)); } }
static int get_convex(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; bool ret = obj.convex; LuaDLL.lua_pushboolean(L, ret); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index convex on a nil value" : e.Message)); } }
static int set_skinWidth(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; float arg0 = (float)LuaDLL.luaL_checknumber(L, 2); obj.skinWidth = arg0; return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index skinWidth on a nil value" : e.Message)); } }
static int get_sharedMesh(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); UnityEngine.MeshCollider obj = (UnityEngine.MeshCollider)o; UnityEngine.Mesh ret = obj.sharedMesh; ToLua.Push(L, ret); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index sharedMesh on a nil value" : e.Message)); } }