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));
}
}
