Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-06 10:32:49 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

[WL21389] wip and modifications based on comments

Browse source 
https://github.com/highfidelity/hifi/pull/11024#pullrequestreview-51611518

Cleans up tabs, moves new functionality out of ShapeFactory directly to
RenderableShapeEntityItem's computeShapeInfo override, begins to break down
where we will need pointlists.

Still need to determine how rotation is handled for pointlists, and check
for axis alignment on cylinders before deciding on a shape.

Changes to be committed:
	modified:   libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
	modified:   libraries/entities-renderer/src/RenderableShapeEntityItem.h
	modified:   libraries/entities/CMakeLists.txt
	modified:   libraries/entities/src/ShapeEntityItem.cpp
	modified:   libraries/entities/src/ShapeEntityItem.h
	modified:   libraries/physics/src/ShapeFactory.cpp
	modified:   libraries/physics/src/ShapeFactory.h
	modified:   libraries/shared/src/ShapeInfo.cpp
	modified:   scripts/developer/tests/basicEntityTest/entitySpawner.js
This commit is contained in:
Leander Hasty 2017-07-24 17:02:40 -04:00 committed by LaShonda Hopper
parent 75403124b6
commit d155c02640
9 changed files with 122 additions and 227 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
View file

@ -49,23 +49,18 @@ RenderableShapeEntityItem::Pointer RenderableShapeEntityItem::baseFactory(const
}
EntityItemPointer RenderableShapeEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
auto result = baseFactory(entityID, properties);
//TODO_CUSACK: Remove this before final PN
qCDebug(entities) << "Creating RenderableShapeEntityItem( " << result->_name << " ): " << result.get() << " ID: " << result->_id;
return result;
return baseFactory(entityID, properties);
}
EntityItemPointer RenderableShapeEntityItem::boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
auto result = baseFactory(entityID, properties);
result->setShape(entity::Shape::Cube);
result->setShape(entity::Cube);
return result;
}
EntityItemPointer RenderableShapeEntityItem::sphereFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
auto result = baseFactory(entityID, properties);
result->setShape(entity::Shape::Sphere);
result->setShape(entity::Sphere);
return result;
}
@ -90,19 +85,84 @@ bool RenderableShapeEntityItem::isTransparent() {
void RenderableShapeEntityItem::computeShapeInfo(ShapeInfo& info) {
if (_collisionShapeType == ShapeType::SHAPE_TYPE_NONE) {
if (_shape == entity::Shape::NUM_SHAPES)
{
EntityItem::computeShapeInfo(info);
// This will be called whenever DIRTY_SHAPE flag (set by dimension change, etc)
// is set.
//--EARLY EXIT--( allow default handling to process )
return;
const glm::vec3 entityDimensions = getDimensions();
switch (_shape){
case entity::Shape::Quad:
case entity::Shape::Cube: {
_collisionShapeType = SHAPE_TYPE_BOX;
}
break;
case entity::Shape::Sphere: {
float diameter = entityDimensions.x;
const float MIN_DIAMETER = 0.001f;
const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
if (diameter > MIN_DIAMETER
&& fabsf(diameter - entityDimensions.y) / diameter < MIN_RELATIVE_SPHERICAL_ERROR
&& fabsf(diameter - entityDimensions.z) / diameter < MIN_RELATIVE_SPHERICAL_ERROR) {
_collisionShapeType = SHAPE_TYPE_SPHERE;
}
else {
_collisionShapeType = SHAPE_TYPE_ELLIPSOID;
}
}
break;
case entity::Shape::Cylinder: {
_collisionShapeType = SHAPE_TYPE_CYLINDER_Y;
// TODO_CUSACK: determine if rotation is axis-aligned
//const Transform::Quat & rot = _transform.getRotation();
_collisionShapeType = ShapeFactory::computeShapeType(getShape(), getDimensions());
#if 0
// TODO: some way to tell apart SHAPE_TYPE_CYLINDER_Y
// TODO_CUSACK: Should allow for minor variance along axes?
if ((entityDimensions.y >= entityDimensions.x) && (entityDimensions.y >= entityDimensions.z)) {
}
else if (entityDimensions.x >= entityDimensions.z) {
_collisionShapeType = SHAPE_TYPE_CYLINDER_X;
}
else if (entityDimensions.z >= entityDimensions.x) {
_collisionShapeType = SHAPE_TYPE_CYLINDER_Z;
}
else //...there was no major axis, treat as a hull
{
_collisionShapeType = SHAPE_TYPE_SIMPLE_HULL;
//TODO_CUSACK: pointCollection
}
#endif
}
break;
case entity::Shape::Triangle:
case entity::Shape::Hexagon:
case entity::Shape::Octagon:
case entity::Shape::Circle:
case entity::Shape::Tetrahedron:
case entity::Shape::Octahedron:
case entity::Shape::Dodecahedron:
case entity::Shape::Icosahedron:
case entity::Shape::Cone: {
_collisionShapeType = SHAPE_TYPE_SIMPLE_HULL;
//TODO_CUSACK: pointCollection
}
break;
case entity::Shape::Torus:
{
// Not in GeometryCache::buildShapes, unsupported.
_collisionShapeType = SHAPE_TYPE_NONE;
//TODO_CUSACK: SHAPE_TYPE_SIMPLE_HULL and pointCollection (later)
}
break;
default:{
//_collisionShapeType = SHAPE_TYPE_NONE; // Remains SHAPE_TYPE_NONE.
}
break;
}
return EntityItem::computeShapeInfo(info);
EntityItem::computeShapeInfo(info);
}
void RenderableShapeEntityItem::render(RenderArgs* args) {

2
libraries/entities-renderer/src/RenderableShapeEntityItem.h
View file

@ -28,7 +28,7 @@ public:
bool isTransparent() override;
void computeShapeInfo(ShapeInfo& info);
virtual void computeShapeInfo(ShapeInfo& info);
private:
std::unique_ptr<Procedural> _procedural { nullptr };

1
libraries/entities/CMakeLists.txt
View file

@ -1,4 +1,3 @@
set(TARGET_NAME entities)
setup_hifi_library(Network Script)
link_hifi_libraries(shared networking octree avatars)

37
libraries/entities/src/ShapeEntityItem.cpp
View file

@ -58,12 +58,7 @@ ShapeEntityItem::Pointer ShapeEntityItem::baseFactory(const EntityItemID& entity
}
EntityItemPointer ShapeEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
auto result = baseFactory(entityID, properties);
//TODO_CUSACK: Remove this before final PN
qCDebug(entities) << "Creating ShapeEntityItem( " << result->_name << " ): " << result.get() << " ID: " << result->_id;
return result;
return baseFactory(entityID, properties);
}
EntityItemPointer ShapeEntityItem::boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
@ -93,14 +88,14 @@ EntityItemProperties ShapeEntityItem::getProperties(EntityPropertyFlags desiredP
void ShapeEntityItem::setShape(const entity::Shape& shape) {
_shape = shape;
switch (_shape) {
switch (_shape) { // TODO_CUSACK fill out?
case entity::Shape::Cube:
_type = EntityTypes::Box;
_collisionShapeType = ShapeType::SHAPE_TYPE_BOX;
break;
case entity::Shape::Sphere:
_type = EntityTypes::Sphere;
_collisionShapeType = ShapeType::SHAPE_TYPE_ELLIPSOID;
_collisionShapeType = ShapeType::SHAPE_TYPE_ELLIPSOID; // TODO_CUSACK defer? Check to see if sphere is more appropriate?
break;
default:
_type = EntityTypes::Shape;
@ -108,11 +103,6 @@ void ShapeEntityItem::setShape(const entity::Shape& shape) {
}
}
//TODO_CUSACK: Move back to header prior to PN
void ShapeEntityItem::setShape( const QString &shape ) {
setShape(entity::shapeFromString(shape));
}
bool ShapeEntityItem::setProperties(const EntityItemProperties& properties) {
bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
@ -175,25 +165,6 @@ void ShapeEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
// This value specifes how the shape should be treated by physics calculations.
// For now, all polys will act as spheres
ShapeType ShapeEntityItem::getShapeType() const {
//TODO_CUSACK: This needs to be retrieved from properties if possible
// or stored within a new member and set during parsing of
// the properties like setShape via set/get/readEntityProperties.
// Perhaps if the _actual_ collisionShapeType is needed (the version that's in use
// based on analysis of the shape's halfExtents when BulletLibrary collision shape was
// created as opposed to the desired ShapeType is it possible to retrieve that information)?
//if (_shape == entity::Shape::Cylinder) {
// return SHAPE_TYPE_CYLINDER_Y;
//}
//// Original functionality: Everything not a cube, is treated like an ellipsoid/sphere
//return (_shape == entity::Shape::Cube) ? SHAPE_TYPE_BOX : SHAPE_TYPE_ELLIPSOID;
//if (_collisionShapeType == ShapeType::SHAPE_TYPE_NONE)
//{
// //--EARLY EXIT--( Maintain previous behavior of treating invalid as Ellipsoid/Sphere )
// return SHAPE_TYPE_ELLIPSOID;
//}
return _collisionShapeType;
}
@ -254,7 +225,7 @@ bool ShapeEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const
void ShapeEntityItem::debugDump() const {
quint64 now = usecTimestampNow();
qCDebug(entities) << "SHAPE EntityItem id:" << getEntityItemID() << "---------------------------------------------";
qCDebug(entities) << " name:" << _name;
qCDebug(entities) << " name:" << _name;
qCDebug(entities) << " shape:" << stringFromShape(_shape) << " (EnumId: " << _shape << " )";
qCDebug(entities) << " color:" << _color[0] << "," << _color[1] << "," << _color[2];
qCDebug(entities) << " position:" << debugTreeVector(getPosition());

4
libraries/entities/src/ShapeEntityItem.h
View file

@ -70,7 +70,7 @@ public:
entity::Shape getShape() const { return _shape; }
void setShape(const entity::Shape& shape);
void setShape(const QString& shape);
void setShape(const QString& shape) { setShape(entity::shapeFromString(shape)); }
float getAlpha() const { return _alpha; };
void setAlpha(float alpha) { _alpha = alpha; }
@ -100,7 +100,7 @@ protected:
float _alpha { 1 };
rgbColor _color;
entity::Shape _shape { entity::Shape::Sphere };
ShapeType _collisionShapeType{ ShapeType::SHAPE_TYPE_NONE };
ShapeType _collisionShapeType { ShapeType::SHAPE_TYPE_NONE };
};
#endif // hifi_ShapeEntityItem_h

202
libraries/physics/src/ShapeFactory.cpp
View file

@ -247,123 +247,6 @@ void deleteStaticMeshArray(btTriangleIndexVertexArray* dataArray) {
delete dataArray;
}
ShapeType validateShapeType(ShapeType type, const glm::vec3 &halfExtents, btCollisionShape **outCollisionShape = NULL)
{
if ((type == SHAPE_TYPE_SPHERE) || (type == SHAPE_TYPE_ELLIPSOID))
{
float radius = halfExtents.x;
const float MIN_RADIUS = 0.001f;
const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
if (radius > MIN_RADIUS
&& fabsf(radius - halfExtents.y) / radius < MIN_RELATIVE_SPHERICAL_ERROR
&& fabsf(radius - halfExtents.z) / radius < MIN_RELATIVE_SPHERICAL_ERROR) {
// close enough to true sphere
if (outCollisionShape) {
(*outCollisionShape) = new btSphereShape(radius);
}
return SHAPE_TYPE_SPHERE;
}
else {
ShapeInfo::PointList points;
points.reserve(NUM_UNIT_SPHERE_DIRECTIONS);
for (uint32_t i = 0; i < NUM_UNIT_SPHERE_DIRECTIONS; ++i) {
points.push_back(bulletToGLM(_unitSphereDirections[i]) * halfExtents);
}
if (outCollisionShape) {
(*outCollisionShape) = createConvexHull(points);
}
return SHAPE_TYPE_ELLIPSOID;
}
}
else if ((type == SHAPE_TYPE_CYLINDER_X) || (type == SHAPE_TYPE_CYLINDER_Y) || (type == SHAPE_TYPE_CYLINDER_Z))
{
// TODO_CUSACK: Should allow for minor variance along axes?
const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
if ((halfExtents.y >= halfExtents.x) && (halfExtents.y >= halfExtents.z)) {
if (outCollisionShape) {
(*outCollisionShape) = new btCylinderShape(btHalfExtents);
}
return SHAPE_TYPE_CYLINDER_Y;
}
else if (halfExtents.x >= halfExtents.z) {
if (outCollisionShape) {
(*outCollisionShape) = new btCylinderShapeX(btHalfExtents);
}
return SHAPE_TYPE_CYLINDER_X;
}
else if (halfExtents.z > halfExtents.x) {
if (outCollisionShape) {
(*outCollisionShape) = new btCylinderShapeZ(btHalfExtents);
}
return SHAPE_TYPE_CYLINDER_Z;
}
else //...there was no major axis, treat as a sphere
{
ShapeType cylinderFallback = validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents, outCollisionShape);
return cylinderFallback;
}
}
//Got here, then you are what you are along with outCollisionShape
return type;
}
ShapeType ShapeFactory::computeShapeType(entity::Shape shape, const glm::vec3 &entityDimensions) {
if (shape == entity::Shape::NUM_SHAPES) {
//--EARLY EXIT--
return SHAPE_TYPE_NONE;
}
const glm::vec3 halfExtents = entityDimensions * 0.5f;
switch (shape){
case entity::Shape::Triangle: {
//TODO_CUSACK: Implement this
return validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents);
}
//Note: Intentional Fallthrough from Quad to Cube
case entity::Shape::Quad:
case entity::Shape::Cube: {
return SHAPE_TYPE_BOX;
}
//Note: Intentional Fallthrough from Hexagon to Sphere
case entity::Shape::Hexagon:
case entity::Shape::Octagon:
case entity::Shape::Circle:
case entity::Shape::Sphere: {
return validateShapeType(SHAPE_TYPE_SPHERE, halfExtents);
}
case entity::Shape::Cylinder: {
return validateShapeType(SHAPE_TYPE_CYLINDER_Y, halfExtents);
}
//Note: Intentional Fallthrough from Tetrahedron to Icosahedron
case entity::Shape::Tetrahedron:
case entity::Shape::Octahedron:
case entity::Shape::Dodecahedron:
case entity::Shape::Icosahedron: {
//TODO_CUSACK: Implement the hedrons
return validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents);
}
//Note: Intentional Fallthrough from Torus to default.
case entity::Shape::Torus:
case entity::Shape::Cone: {
// These types are currently unsupported
}
default:
return SHAPE_TYPE_NONE;
}
}
const btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info) {
btCollisionShape* shape = NULL;
int type = info.getType();
@ -372,37 +255,32 @@ const btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info)
shape = new btBoxShape(glmToBullet(info.getHalfExtents()));
}
break;
//case SHAPE_TYPE_SPHERE: {
// glm::vec3 halfExtents = info.getHalfExtents();
// float radius = glm::max(halfExtents.x, glm::max(halfExtents.y, halfExtents.z));
// shape = new btSphereShape(radius);
//}
//break;
case SHAPE_TYPE_SPHERE:
case SHAPE_TYPE_ELLIPSOID: {
case SHAPE_TYPE_SPHERE: {
glm::vec3 halfExtents = info.getHalfExtents();
//float radius = halfExtents.x;
//const float MIN_RADIUS = 0.001f;
//const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
//if (radius > MIN_RADIUS
// && fabsf(radius - halfExtents.y) / radius < MIN_RELATIVE_SPHERICAL_ERROR
// && fabsf(radius - halfExtents.z) / radius < MIN_RELATIVE_SPHERICAL_ERROR) {
// // close enough to true sphere
// shape = new btSphereShape(radius);
//} else {
// ShapeInfo::PointList points;
// points.reserve(NUM_UNIT_SPHERE_DIRECTIONS);
// for (uint32_t i = 0; i < NUM_UNIT_SPHERE_DIRECTIONS; ++i) {
// points.push_back(bulletToGLM(_unitSphereDirections[i]) * halfExtents);
// }
// shape = createConvexHull(points);
//}
validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents, &shape);
float radius = glm::max(halfExtents.x, glm::max(halfExtents.y, halfExtents.z));
shape = new btSphereShape(radius);
}
break;
case SHAPE_TYPE_ELLIPSOID: {
glm::vec3 halfExtents = info.getHalfExtents();
float radius = halfExtents.x;
const float MIN_RADIUS = 0.001f;
const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
if (radius > MIN_RADIUS
&& fabsf(radius - halfExtents.y) / radius < MIN_RELATIVE_SPHERICAL_ERROR
&& fabsf(radius - halfExtents.z) / radius < MIN_RELATIVE_SPHERICAL_ERROR) {
// close enough to true sphere
shape = new btSphereShape(radius);
} else {
ShapeInfo::PointList points;
points.reserve(NUM_UNIT_SPHERE_DIRECTIONS);
for (uint32_t i = 0; i < NUM_UNIT_SPHERE_DIRECTIONS; ++i) {
points.push_back(bulletToGLM(_unitSphereDirections[i]) * halfExtents);
}
shape = createConvexHull(points);
}
}
break;
//TODO_CUSACK: Add Capsules to vetting/validation process for
// type checks.
case SHAPE_TYPE_CAPSULE_Y: {
glm::vec3 halfExtents = info.getHalfExtents();
float radius = halfExtents.x;
@ -424,30 +302,22 @@ const btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info)
shape = new btCapsuleShapeZ(radius, height);
}
break;
case SHAPE_TYPE_CYLINDER_X:
case SHAPE_TYPE_CYLINDER_Z:
case SHAPE_TYPE_CYLINDER_Y: {
// TODO_CUSACK: Should allow for minor variance along axes.
case SHAPE_TYPE_CYLINDER_X: {
const glm::vec3 halfExtents = info.getHalfExtents();
//const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
//if ((halfExtents.y > halfExtents.x) && (halfExtents.y > halfExtents.z)) {
// shape = new btCylinderShape(btHalfExtents);
//}
//else if (halfExtents.x > halfExtents.z) {
// shape = new btCylinderShapeX(btHalfExtents);
//}
//else if (halfExtents.z > halfExtents.x) {
// shape = new btCylinderShapeZ(btHalfExtents);
//}
//else //...there was no major axis, treat as a sphere
//{
// //TODO_CUSACK: Shunt to ELLIPSOID handling
//}
validateShapeType(SHAPE_TYPE_CYLINDER_Y, halfExtents, &shape);
const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
shape = new btCylinderShapeX(btHalfExtents);
}
case SHAPE_TYPE_CYLINDER_Z: {
const glm::vec3 halfExtents = info.getHalfExtents();
const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
shape = new btCylinderShapeZ(btHalfExtents);
}
case SHAPE_TYPE_CYLINDER_Y: {
const glm::vec3 halfExtents = info.getHalfExtents();
const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
shape = new btCylinderShape(btHalfExtents);
}
break;
//TODO_CUSACK: Add compound and simple hull to vetting/validation
// process for types.
case SHAPE_TYPE_COMPOUND:
case SHAPE_TYPE_SIMPLE_HULL: {
const ShapeInfo::PointCollection& pointCollection = info.getPointCollection();

3
libraries/physics/src/ShapeFactory.h
View file

@ -15,14 +15,11 @@
#include <btBulletDynamicsCommon.h>
#include <glm/glm.hpp>
#include <ShapeEntityItem.h> //< Needed for entity::Shape
#include <ShapeInfo.h>
// translates between ShapeInfo and btShape
namespace ShapeFactory {
ShapeType computeShapeType( entity::Shape shape, const glm::vec3 &entityDimensions);
const btCollisionShape* createShapeFromInfo(const ShapeInfo& info);
void deleteShape(const btCollisionShape* shape);

4
libraries/shared/src/ShapeInfo.cpp
View file

@ -29,8 +29,8 @@ void ShapeInfo::clear() {
}
void ShapeInfo::setParams(ShapeType type, const glm::vec3& halfExtents, QString url) {
//TODO_CUSACK: Does this need additional cases and handling added?
_url = "";
//TODO_CUSACK: Does this need additional cases and handling added?
_url = "";
_type = type;
setHalfExtents(halfExtents);
switch(type) {

4
scripts/developer/tests/basicEntityTest/entitySpawner.js
View file

@ -8,9 +8,7 @@
var SCRIPT_URL = Script.resolvePath("myEntityScript.js")
var myEntity = Entities.addEntity({
name: "Cusack_Testing",
type: "Shape",
shapeType: "Cylinder",
type: "Sphere",
color: {
red: 200,
green: 10,