public ActionResult Create(capsule capsule)
{
if (ModelState.IsValid)
{
string imagename = Path.GetFileNameWithoutExtension(capsule.Imageupload.FileName);
string extension = Path.GetExtension(capsule.Imageupload.FileName);
HttpPostedFileBase serverimage = capsule.Imageupload;
int size = serverimage.ContentLength;
if (extension.ToLower() == ".jpg" || extension.ToLower() == ".jpeg" || extension.ToLower() == ".png")
{
if (size <= 2000000)
{
imagename = imagename + extension;
capsule.pic = "~/capsulefile/" + imagename;
imagename = Path.Combine(Server.MapPath("~/capsulefile/"), imagename);
capsule.Imageupload.SaveAs(imagename);
db.capsule.Add(capsule);
db.SaveChanges();
ModelState.Clear();
}
else
{
ViewBag.msg = "<script>alert('invalid error')</script>";
}
}
else
{
ViewBag.msg = "<script>alert('Wrong Extension')</script>";
}
}
return(View());
}
public ActionResult DeleteConfirmed(int id)
{
capsule capsule = db.capsule.Find(id);
db.capsule.Remove(capsule);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,Name,company_name,output,size,dimension,shipping_weight,Power,Price_")] capsule capsule)
{
if (ModelState.IsValid)
{
db.Entry(capsule).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(capsule));
}
public static bool OverlapCapsuleAABB(capsule capsule, box AABB)
{
var closestOnCapsule = ClosestPointOnLineSegment(capsule.p1, capsule.p2, AABB.center);
float sqDist;
float3 closestInBox;
CalculateClosestPointInBox(closestOnCapsule, AABB, out closestInBox, out sqDist);
return(math.sqrt(sqDist) < capsule.radius);
}
// GET: capsules/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
capsule capsule = db.capsule.Find(id);
if (capsule == null)
{
return(HttpNotFound());
}
return(View(capsule));
}
public static bool OverlapCapsuleBox(capsule capsule, box box)
{
// Transform capsule into box space
var rayCapsule = capsule;
var invBoxRot = math.inverse(box.rotation);
var invBoxPos = -math.mul(invBoxRot, box.center);
rayCapsule = primlib.transform(rayCapsule, invBoxPos, invBoxRot);
var primLocalSpace = box;
primLocalSpace.center = float3.zero;
primLocalSpace.rotation = Quaternion.identity;
var hit = coll.OverlapCapsuleAABB(rayCapsule, primLocalSpace);
return(hit);
}
public static void Prim(capsule capsule, Color color, float duration = 0)
{
var v = capsule.p2 - capsule.p1;
Capsule(capsule.p1 + v * 0.5f, math.normalize(v), capsule.radius, math.length(v) + 2 * capsule.radius, color, duration);
}
public static void Setup(EntityManager entityManager, Entity entity, List <Transform> parents,
float boundsRadius, float boundsHeightOffset, List <CapsuleCollider> capsuleColliders,
List <Transform> capsuleColliderParents, List <SphereCollider> sphereColliders,
List <Transform> sphereColliderParents, List <BoxCollider> boxColliders, List <Transform> boxColliderParents)
{
var coll = new HitCollisionData();
if (entityManager.HasComponent <HitCollisionData>(entity))
{
coll = entityManager.GetComponentData <HitCollisionData>(entity);
}
coll.lastTick = -1;
coll.lastIndex = -1;
coll.boundsRadius = boundsRadius;
coll.boundsHeightOffset = boundsHeightOffset;
if (entityManager.HasComponent <HitCollisionData>(entity))
{
entityManager.SetComponentData(entity, coll);
}
else
{
entityManager.AddComponentData(entity, coll);
}
// Setup history
entityManager.AddBuffer <TransformHistory>(entity);
var historyBuffer = entityManager.GetBuffer <TransformHistory>(entity);
for (int i = 0; i < k_historyCount * k_maxColliderCount; i++)
{
historyBuffer.Add(new TransformHistory());
}
entityManager.AddBuffer <BoundsHistory>(entity);
var boundsBuffer = entityManager.GetBuffer <BoundsHistory>(entity);
for (int i = 0; i < k_historyCount; i++)
{
boundsBuffer.Add(new BoundsHistory());
}
// Primitives
entityManager.AddBuffer <Capsule>(entity);
var capsuleBuffer = entityManager.GetBuffer <Capsule>(entity);
for (var i = 0; i < capsuleColliders.Count; i++)
{
var collider = capsuleColliders[i];
var localPos = collider.center;
var axis = collider.direction == 0 ? Vector3.right :
collider.direction == 1 ? Vector3.up : Vector3.forward;
var offset = 0.5f * axis * (collider.height - 2 * collider.radius);
var prim = new capsule()
{
p1 = localPos - offset,
p2 = localPos + offset,
radius = collider.radius,
};
var capsule = new Capsule();
capsule.prim = primlib.transform(prim, collider.transform.localPosition,
collider.transform.localRotation);
var parent = capsuleColliderParents[i];
capsule.transformIndex = parents.IndexOf(parent);
capsule.info = new HitCollInfo
{
type = HitCollType.Body
};
capsuleBuffer.Add(capsule);
}
entityManager.AddBuffer <Box>(entity);
var boxBuffer = entityManager.GetBuffer <Box>(entity);
for (var i = 0; i < boxColliders.Count; i++)
{
var collider = boxColliders[i];
var prim = new box
{
center = collider.center,
size = collider.size,
rotation = Quaternion.identity
};
var box = new Box();
box.prim = primlib.transform(prim, collider.transform.localPosition,
collider.transform.localRotation);
var parent = boxColliderParents[i];
box.transformIndex = parents.IndexOf(parent);
box.info = new HitCollInfo
{
type = HitCollType.Body
};
boxBuffer.Add(box);
}
entityManager.AddBuffer <Sphere>(entity);
var sphereBuffer = entityManager.GetBuffer <Sphere>(entity);
for (var i = 0; i < sphereColliders.Count; i++)
{
var collider = sphereColliders[i];
var prim = new sphere
{
center = collider.center,
radius = collider.radius,
};
var sphere = new Sphere();
sphere.prim = primlib.transform(prim, collider.transform.localPosition,
collider.transform.localRotation);
var parent = sphereColliderParents[i];
sphere.transformIndex = parents.IndexOf(parent);
sphere.info = new HitCollInfo
{
type = HitCollType.Body
};
sphereBuffer.Add(sphere);
}
}
public void Execute()
{
// TODO (mogensh) : find all hits and return closest
var rayEnd = ray.origin + ray.direction * rayDist;
for (var i = 0; i < sphereArray.Length; i++)
{
var prim = sphereArray[i].prim;
var sourceIndex = sphereArray[i].transformIndex;
prim = primlib.transform(prim, transformBuffer[sourceIndex].pos,
transformBuffer[sourceIndex].rot);
var hit = coll.RayCast(prim, ray, rayDist, rayRadius);
if (hit)
{
result[0] = new HitCollisionData.CollisionResult()
{
info = sphereArray[i].info,
primCenter = prim.center,
hit = 1,
sphere = prim,
};
return;
}
}
for (var i = 0; i < capsuleArray.Length; i++)
{
var prim = capsuleArray[i].prim;
var sourceIndex = capsuleArray[i].transformIndex;
prim = primlib.transform(prim, transformBuffer[sourceIndex].pos, transformBuffer[sourceIndex].rot);
var rayCapsule = new capsule(ray.origin, rayEnd, rayRadius);
var hit = InstersectionHelper.IntersectCapsuleCapsule(ref prim, ref rayCapsule);
if (hit)
{
result[0] = new HitCollisionData.CollisionResult()
{
info = capsuleArray[i].info,
primCenter = prim.p1 + (prim.p2 - prim.p1) * 0.5f,
hit = 1,
capsule = prim,
};
return;
}
}
for (var i = 0; i < boxArray.Length; i++)
{
var prim = boxArray[i].prim;
var sourceIndex = boxArray[i].transformIndex;
var primWorldSpace = primlib.transform(prim, transformBuffer[sourceIndex].pos, transformBuffer[sourceIndex].rot);
var rayCapsule = new capsule(ray.origin, rayEnd, rayRadius);
var hit = coll.OverlapCapsuleBox(rayCapsule, primWorldSpace);
if (hit)
{
result[0] = new HitCollisionData.CollisionResult()
{
info = boxArray[i].info,
primCenter = primWorldSpace.center,
hit = 1,
box = primWorldSpace,
};
return;
}
}
}
public static bool IntersectCapsuleCapsule(ref capsule c0, ref capsule c1)
{
float3 D1 = c0.p2 - c0.p1;
float3 D2 = c1.p2 - c1.p1;
float3 diff = c0.p1 - c1.p1;
float s, t;
float a = math.dot(D1, D1);
float b = math.dot(D1, D2);
float c = math.dot(D2, D2);
float d = math.dot(D1, diff);
float e = math.dot(D2, diff);
float det = a * c - b * b;
if (det > float.Epsilon)
{
s = b * e - c * d;
t = a * e - b * d;
if (s <= 0)
{
// The projection of A1 onto L2 is t = e / c. Figure out what region that lies in (negative, positive, or inside the interval).
if (e <= 0)
{
t = 0;
s = SafeClampRatio(-d, a);
}
else if (e < c) // t in (0,1)
{
s = 0;
t = e / c;
}
else // t >= 1
{
t = 1;
s = SafeClampRatio(b - d, a);
}
}
else
{
if (s >= det) // s >= 1
{
// The projection of A1+D1 onto L2 is t = (b + e) / c.
if (b + e <= 0) // t <= 0
{
t = 0;
s = SafeClampRatio(-d, a);
}
else if (b + e < c) // t in (0,1)
{
s = 1;
t = (b + e) / c;
}
else
{
t = 1;
s = SafeClampRatio(b - d, a);
}
}
else // s in (0,1)
{
if (t <= 0)
{
t = 0;
s = SafeClampRatio(-d, a);
}
else
{
if (t >= det) // t >= 1
{
t = 1;
s = SafeClampRatio(b - d, a);
}
else
{
// the minimum is inside the unit square, just compute the unconstrained version
s /= det;
t /= det;
}
}
}
}
}
else
{
// Parallel axes, pick the endpoints
if (e <= 0) // Proj(A1,L2) = e / c
{
t = 0;
s = SafeClampRatio(-d, a);
}
else if (e < c) // t in (0,1)
{
s = 0;
t = e / c;
}
else
{
t = 1;
s = SafeClampRatio(b - d, a);
}
}
// Finally, get the distance between points and compare to the sum of radiuses
float3 comp = math.lerp(c0.p1, c0.p2, s) - math.lerp(c1.p1, c1.p2, t);
float radSum = c0.radius + c1.radius;
return(math.lengthsq(comp) <= radSum * radSum);
}
