void RenderableZoneEntityItem::render(RenderArgs* args) {
Q_ASSERT(getType() == EntityTypes::Zone);
if (_drawZoneBoundaries) {
switch (getShapeType()) {
case SHAPE_TYPE_COMPOUND: {
PerformanceTimer perfTimer("zone->renderCompound");
updateGeometry();
if (_model && _model->needsFixupInScene()) {
// check to see if when we added our models to the scene they were ready, if they were not ready, then
// fix them up in the scene
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
render::PendingChanges pendingChanges;
_model->removeFromScene(scene, pendingChanges);
_model->addToScene(scene, pendingChanges);
scene->enqueuePendingChanges(pendingChanges);
_model->setVisibleInScene(getVisible(), scene);
}
break;
}
case SHAPE_TYPE_BOX:
case SHAPE_TYPE_SPHERE: {
PerformanceTimer perfTimer("zone->renderPrimitive");
glm::vec4 DEFAULT_COLOR(1.0f, 1.0f, 1.0f, 1.0f);
Q_ASSERT(args->_batch);
gpu::Batch& batch = *args->_batch;
batch.setModelTransform(getTransformToCenter());
auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
if (getShapeType() == SHAPE_TYPE_SPHERE) {
const int SLICES = 15, STACKS = 15;
deferredLightingEffect->renderWireSphere(batch, 0.5f, SLICES, STACKS, DEFAULT_COLOR);
} else {
deferredLightingEffect->renderWireCube(batch, 1.0f, DEFAULT_COLOR);
}
break;
}
default:
// Not handled
break;
}
}
if ((!_drawZoneBoundaries || getShapeType() != SHAPE_TYPE_COMPOUND) &&
_model && !_model->needsFixupInScene()) {
// If the model is in the scene but doesn't need to be, remove it.
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
render::PendingChanges pendingChanges;
_model->removeFromScene(scene, pendingChanges);
scene->enqueuePendingChanges(pendingChanges);
}
}
void RenderableZoneEntityItem::render(RenderArgs* args) {
if (_drawZoneBoundaries) {
switch (getShapeType()) {
case SHAPE_TYPE_COMPOUND: {
updateGeometry();
if (_model && _model->isActive()) {
PerformanceTimer perfTimer("zone->renderCompound");
glPushMatrix();
_model->renderInScene(getLocalRenderAlpha(), args);
glPopMatrix();
}
break;
}
case SHAPE_TYPE_BOX:
case SHAPE_TYPE_SPHERE: {
PerformanceTimer perfTimer("zone->renderPrimitive");
glm::vec3 position = getPosition();
glm::vec3 center = getCenter();
glm::vec3 dimensions = getDimensions();
glm::quat rotation = getRotation();
glm::vec4 DEFAULT_COLOR(1.0f, 1.0f, 1.0f, getLocalRenderAlpha());
glPushMatrix(); {
glTranslatef(position.x, position.y, position.z);
glm::vec3 axis = glm::axis(rotation);
glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
glPushMatrix(); {
glm::vec3 positionToCenter = center - position;
glTranslatef(positionToCenter.x, positionToCenter.y, positionToCenter.z);
glScalef(dimensions.x, dimensions.y, dimensions.z);
auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
if (getShapeType() == SHAPE_TYPE_SPHERE) {
const int SLICES = 15;
const int STACKS = 15;
deferredLightingEffect->renderWireSphere(0.5f, SLICES, STACKS, DEFAULT_COLOR);
} else {
deferredLightingEffect->renderWireCube(1.0f, DEFAULT_COLOR);
}
} glPopMatrix();
} glPopMatrix();
break;
}
default:
// Not handled
break;
}
}
}
void PhysicsRigidBody::transformChanged(Transform* transform, long cookie)
{
if (getShapeType() == PhysicsCollisionShape::SHAPE_HEIGHTFIELD)
{
GP_ASSERT(_collisionShape && _collisionShape->_shapeData.heightfieldData);
// Dirty the heightfield's inverse kmMat4 (used to compute height values from world-space coordinates)
_collisionShape->_shapeData.heightfieldData->inverseIsDirty = true;
// Update local scaling for the heightfield.
kmVec3 scale = vec3Zero;
//_node->getWorldMatrix().getScale(&scale);
kmMat4Decompose(&_node->getWorldMatrix(), &scale, NULL, NULL);
// If the node has a terrain attached, factor in the terrain local scaling as well for the collision shape
Terrain* terrain = dynamic_cast<Terrain*>(_node->getDrawable());
if (terrain)
{
const kmVec3& tScale = terrain->_localScale;
scale = { scale.x * tScale.x, scale.y * tScale.y, scale.z * tScale.z };
}
_collisionShape->_shape->setLocalScaling(BV(scale));
// Update center of mass offset
float minHeight = _collisionShape->_shapeData.heightfieldData->minHeight;
float maxHeight = _collisionShape->_shapeData.heightfieldData->maxHeight;
_motionState->setCenterOfMassOffset({ 0, -(minHeight + (maxHeight - minHeight)*0.5f) * scale.y, 0 });
}
}
void ZoneEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeDataPointer modelTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount,
OctreeElement::AppendState& appendState) const {
bool successPropertyFits = true;
_keyLightProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
propertyFlags, propertiesDidntFit, propertyCount, appendState);
_stageProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
propertyFlags, propertiesDidntFit, propertyCount, appendState);
APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)getShapeType());
APPEND_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, getCompoundShapeURL());
APPEND_ENTITY_PROPERTY(PROP_BACKGROUND_MODE, (uint32_t)getBackgroundMode()); // could this be a uint16??
_skyboxProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
propertyFlags, propertiesDidntFit, propertyCount, appendState);
APPEND_ENTITY_PROPERTY(PROP_FLYING_ALLOWED, getFlyingAllowed());
APPEND_ENTITY_PROPERTY(PROP_GHOSTING_ALLOWED, getGhostingAllowed());
APPEND_ENTITY_PROPERTY(PROP_FILTER_URL, getFilterURL());
}
bool RenderableModelEntityItem::isReadyToComputeShape() {
ShapeType type = getShapeType();
if (type == SHAPE_TYPE_COMPOUND) {
if (!_model) {
return false; // hmm...
}
if (_needsInitialSimulation) {
// the _model's offset will be wrong until _needsInitialSimulation is false
return false;
}
assert(!_model->getCollisionURL().isEmpty());
if (_model->getURL().isEmpty()) {
// we need a render geometry with a scale to proceed, so give up.
return false;
}
const QSharedPointer<NetworkGeometry> collisionNetworkGeometry = _model->getCollisionGeometry();
const QSharedPointer<NetworkGeometry> renderNetworkGeometry = _model->getGeometry();
if ((collisionNetworkGeometry && collisionNetworkGeometry->isLoaded()) &&
(renderNetworkGeometry && renderNetworkGeometry->isLoaded())) {
// we have both URLs AND both geometries AND they are both fully loaded.
return true;
}
// the model is still being downloaded.
return false;
}
return true;
}
void PhysicsRigidBody::transformChanged(Transform* transform, long cookie)
{
if (getShapeType() == PhysicsCollisionShape::SHAPE_HEIGHTFIELD)
{
GP_ASSERT(_collisionShape && _collisionShape->_shapeData.heightfieldData);
_collisionShape->_shapeData.heightfieldData->inverseIsDirty = true;
}
}
gep::CollisionMesh* gep::CollisionMeshFileLoader::loadResource(CollisionMesh* pInPlace)
{
CollisionMesh* result = nullptr;
bool isInPlace = true;
if (pInPlace == nullptr)
{
result = new CollisionMesh();
isInPlace = false;
}
auto* havokLoader = g_resourceManager.getHavokResourceLoader();
auto* container = havokLoader->load(m_path.c_str());
GEP_ASSERT(container != nullptr, "Could not load asset! %s", m_path.c_str());
if (container)
{
auto* physicsData = reinterpret_cast<hkpPhysicsData*>(container->findObjectByType(hkpPhysicsDataClass.getName()));
GEP_ASSERT(physicsData != nullptr, "Unable to load physics data!");
if (physicsData)
{
const auto& physicsSystems = physicsData->getPhysicsSystems();
GEP_ASSERT(physicsSystems.getSize() == 1, "Wrong number of physics systems!");
auto body = physicsSystems[0]->getRigidBodies()[0];
auto hkShape = body->getCollidable()->getShape();
auto shape = conversion::hk::from(const_cast<hkpShape*>(hkShape));
auto type = shape->getShapeType();
if ( type == hkcdShapeType::BV_COMPRESSED_MESH ||
type == hkcdShapeType::CONVEX_VERTICES )
{
hkTransform transform = body->getTransform();
transform.getRotation().setAxisAngle(hkVector4(0.0f, 0.0f, 1.0f), GetPi<float>::value());
auto hkTransformShape = new hkpTransformShape(hkShape, transform);
hkTransformShape->addReference();
shape = GEP_NEW(m_pAllocator, HavokShape_Transform)(hkTransformShape);
//auto meshShape = static_cast<HavokMeshShape*>(shape);
//Transform* tempTrans = new Transform();
//conversion::hk::from(transform, *tempTrans);
//
//// Since havok content tools are buggy (?) and no custom transformation can be applied,
//// we have to convert into our engine's space by hand.
//// TODO: Ensure, that this transformation is correct in every case
//tempTrans->setRotation(tempTrans->getRotation() * Quaternion(vec3(1,0,0),180));
//meshShape->setTransform(tempTrans);
}
result->setShape(shape);
}
}
return result;
}
dReal ODE_Particle::getRadius()
{
if (getShapeType() == dSphereClass)
{
return dGeomSphereGetRadius(geom);
}
else
{
printf("ERROR in ODE_Particle.cpp: Requesting radius for non spherical object");
exit(0);
}
}
bool RenderableZoneEntityItem::contains(const glm::vec3& point) const {
if (getShapeType() != SHAPE_TYPE_COMPOUND) {
return EntityItem::contains(point);
}
const_cast<RenderableZoneEntityItem*>(this)->updateGeometry();
if (_model && _model->isActive() && EntityItem::contains(point)) {
return _model->convexHullContains(point);
}
return false;
}
void ShapeEntityItem::debugDump() const {
quint64 now = usecTimestampNow();
qCDebug(entities) << "SHAPE EntityItem id:" << getEntityItemID() << "---------------------------------------------";
qCDebug(entities) << " name:" << _name;
qCDebug(entities) << " shape:" << stringFromShape(_shape) << " (EnumId: " << _shape << " )";
qCDebug(entities) << " collisionShapeType:" << ShapeInfo::getNameForShapeType(getShapeType());
qCDebug(entities) << " color:" << _color[0] << "," << _color[1] << "," << _color[2];
qCDebug(entities) << " position:" << debugTreeVector(getWorldPosition());
qCDebug(entities) << " dimensions:" << debugTreeVector(getScaledDimensions());
qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
qCDebug(entities) << "SHAPE EntityItem Ptr:" << this;
}
void ODE_Particle::getLengths(dVector3 &sides)
{
if (getShapeType() == dBoxClass)
{
dGeomBoxGetLengths (geom,sides);
}
else
{
printf("ERROR in ODE_Particle.cpp: Requesting dimensions for non box object");
exit(0);
}
}
//set mass and radius by available total mass
void Particle::setMassTotal(dReal total_mass, dReal rad)
{
if (getShapeType() == dSphereClass)
{
radius=rad;
mass=total_mass;
inv_mass=1/mass;
}
else
{
printf("ERROR in Particle.cpp: Setting totalMass for non spherical object");
exit(0);
}
}
void Particle::getLengths(dVector3 &s)
{
if (getShapeType() == dBoxClass)
{
s[0]=sides[0];
s[1]=sides[1];
s[2]=sides[2];
}
else
{
printf("ERROR in Particle.cpp: Requesting dimensions for non box object");
exit(0);
}
}
void Particle::getLengths(dReal &r0,dReal &r1,dReal &r2)
{
if (getShapeType() == dBoxClass)
{
r0=sides[0];
r1=sides[1];
r2=sides[2];
}
else
{
printf("ERROR in Particle.cpp: Requesting dimensions for non box object");
exit(0);
}
}
//set mass by radius and density
void Particle::setMass(dReal density, dReal rad)
{
if (getShapeType() == dSphereClass)
{
radius=rad;
mass=4.18879*radius*radius*radius*density; // 4/3*PI=4.18879
inv_mass=1/mass;
}
else
{
printf("ERROR in Particle.cpp: Setting Mass using density for non spherical object");
exit(0);
}
}
GUIGLObjectPopupMenu*
GNEPOI::getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent) {
GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this);
buildPopupHeader(ret, app);
buildCenterPopupEntry(ret);
buildNameCopyPopupEntry(ret);
// build selection and show parameters menu
myNet->getViewNet()->buildSelectionACPopupEntry(ret, this);
buildShowParamsPopupEntry(ret);
if (getLaneParents().size() > 0) {
// build shape header
buildShapePopupOptions(app, ret, getShapeType());
// add option for convert to GNEPOI
new FXMenuCommand(ret, ("Release from " + toString(SUMO_TAG_LANE)).c_str(), GUIIconSubSys::getIcon(ICON_LANE), &parent, MID_GNE_POI_TRANSFORM);
return ret;
} else {
// build shape header
buildShapePopupOptions(app, ret, getShapeType());
// add option for convert to GNEPOI
new FXMenuCommand(ret, ("Attach to nearest " + toString(SUMO_TAG_LANE)).c_str(), GUIIconSubSys::getIcon(ICON_LANE), &parent, MID_GNE_POI_TRANSFORM);
}
return ret;
}
std::string
GNEPOI::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return myID;
case SUMO_ATTR_COLOR:
return toString(getShapeColor());
case SUMO_ATTR_LANE:
return myLane;
case SUMO_ATTR_POSITION:
if (getLaneParents().size() > 0) {
return toString(myPosOverLane);
} else {
return toString(*this);
}
case SUMO_ATTR_POSITION_LAT:
return toString(myPosLat);
case SUMO_ATTR_GEOPOSITION:
return toString(myGEOPosition, gPrecisionGeo);
case SUMO_ATTR_GEO:
return toString(myGeo);
case SUMO_ATTR_TYPE:
return getShapeType();
case SUMO_ATTR_LAYER:
if (getShapeLayer() == Shape::DEFAULT_LAYER_POI) {
return "default";
} else {
return toString(getShapeLayer());
}
case SUMO_ATTR_IMGFILE:
return getShapeImgFile();
case SUMO_ATTR_RELATIVEPATH:
return toString(getShapeRelativePath());
case SUMO_ATTR_WIDTH:
return toString(getWidth());
case SUMO_ATTR_HEIGHT:
return toString(getHeight());
case SUMO_ATTR_ANGLE:
return toString(getShapeNaviDegree());
case GNE_ATTR_BLOCK_MOVEMENT:
return toString(myBlockMovement);
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " attribute '" + toString(key) + "' not allowed");
}
}
void basicShape::buildBasicMenu(){
// build custom UI
basicShapeGui.clear();
basicShapeGui.setup( getShapeType() );
basicShapeGui.setShowHeader(true);
basicShapeGui.add( (new ofxIntSlider( groupID )) );
basicShapeGui.add( (new ofxLabel( shapeName )) );
shapeGui.setup();
shapeGui.add( &basicShapeGui );
//shapeGui->setShowHeader(false);
}
// writes the shape data to XML. xml's cursor is already pushed into the right <shape> tag.
// return success state
bool basicShape::saveToXML(ofxXmlSettings &xml){
// create position tag
xml.addTag("position");
xml.pushTag("position");
xml.addValue("X", getPositionUnaltered()->x);
xml.addValue("Y", getPositionUnaltered()->y);
xml.popTag();
xml.addValue("shapeType", getShapeType() );
xml.addValue("groupID", getGroupID() );
xml.addValue("shapeName", shapeName );
return true;
}
//set mass and sides by available dimensions for box objects
void ODE_Particle::setMassTotal(dReal total_mass, dReal side1,dReal side2,dReal side3)
{
dMass m;
dMassSetZero(&m);
if (getShapeType() == dBoxClass)
{
dMassSetBoxTotal(&m,total_mass,side1,side2,side3);
dBodySetMass(body,&m);
}
else
{
printf("ERROR in ODE_Particle.cpp: Setting Mass using total mass for non box object");
exit(0);
}
}
void ODE_Particle::getLengths(dReal &r0,dReal &r1,dReal &r2)
{
if (getShapeType() == dBoxClass)
{
dVector3 sides;
dGeomBoxGetLengths (geom,sides);
r0=sides[0];
r1=sides[1];
r2=sides[2];
}
else
{
printf("ERROR in ODE_Particle.cpp: Requesting dimensions for non box object");
exit(0);
}
}
//set mass by sides and density for box objects
void Particle::setMass(dReal density, dReal side1,dReal side2,dReal side3)
{
if (getShapeType() == dBoxClass)
{
mass=density*side1*side2*side3;
inv_mass=1/mass;
sides[0]=side1;
sides[1]=side2;
sides[2]=side3;
}
else
{
printf("ERROR in Particle.cpp: Setting Mass using density for non box object");
exit(0);
}
}
//set mass by sides and density for box objects
void ODE_Particle::setMass(dReal density, dReal side1,dReal side2,dReal side3)
{
dMass m;
dMassSetZero(&m);
if (getShapeType() == dBoxClass)
{
dMassSetBox (&m,density,side1,side2,side3);
dBodySetMass(body,&m);
}
else
{
printf("ERROR in ODE_Particle.cpp: Setting Mass using density for non box object");
exit(0);
}
}
//set mass and sides by available dimensions for box objects
void Particle::setMassTotal(dReal total_mass, dReal side1,dReal side2,dReal side3)
{
if (getShapeType() == dBoxClass)
{
mass=total_mass;
inv_mass=1/mass;
sides[0]=side1;
sides[1]=side2;
sides[2]=side3;
}
else
{
printf("ERROR in Particle.cpp: Setting Mass using total mass for non box object");
exit(0);
}
}
//set mass and radius by available total mass
void ODE_Particle::setMassTotal(dReal total_mass, dReal rad)
{
dMass m;
dMassSetZero(&m);
if (getShapeType() == dSphereClass)
{
dMassSetSphereTotal(&m,total_mass,rad); // set a given mass to sphere
dBodySetMass(body,&m);
}
else
{
printf("ERROR in ODE_Particle.cpp: Setting totalMass for non spherical object");
exit(0);
}
}
//set mass by radius and density
void ODE_Particle::setMass(dReal density, dReal rad)
{
dMass m;
dMassSetZero(&m);
if (getShapeType() == dSphereClass)
{
dMassSetSphere (&m,density,rad); // calculate a mass for a sphere
dBodySetMass(body,&m);
}
else
{
printf("ERROR in ODE_Particle.cpp: Setting Mass using density for non spherical object");
exit(0);
}
}
void ModelEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* entityTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount, OctreeElement::AppendState& appendState) const {
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
APPEND_ENTITY_PROPERTY(PROP_MODEL_URL, getModelURL());
APPEND_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, getCompoundShapeURL());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures());
_animationProperties.appendSubclassData(packetData, params, entityTreeElementExtraEncodeData, requestedProperties,
propertyFlags, propertiesDidntFit, propertyCount, appendState);
APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)getShapeType());
}
void ModelEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* entityTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount, OctreeElement::AppendState& appendState) const {
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
APPEND_ENTITY_PROPERTY(PROP_MODEL_URL, getModelURL());
APPEND_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, getCompoundShapeURL());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_URL, getAnimationURL());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_FPS, getAnimationFPS());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_FRAME_INDEX, getAnimationFrameIndex());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_PLAYING, getAnimationIsPlaying());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_SETTINGS, getAnimationSettings());
APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)getShapeType());
}
void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* entityTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount,
OctreeElement::AppendState& appendState) const {
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
APPEND_ENTITY_PROPERTY(PROP_EMITTING_PARTICLES, getIsEmitting());
APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)getShapeType());
APPEND_ENTITY_PROPERTY(PROP_MAX_PARTICLES, getMaxParticles());
APPEND_ENTITY_PROPERTY(PROP_LIFESPAN, getLifespan());
APPEND_ENTITY_PROPERTY(PROP_EMIT_RATE, getEmitRate());
APPEND_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, getEmitAcceleration());
APPEND_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, getAccelerationSpread());
APPEND_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, getParticleRadius());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures());
APPEND_ENTITY_PROPERTY(PROP_RADIUS_SPREAD, getRadiusSpread());
APPEND_ENTITY_PROPERTY(PROP_RADIUS_START, getRadiusStart());
APPEND_ENTITY_PROPERTY(PROP_RADIUS_FINISH, getRadiusFinish());
APPEND_ENTITY_PROPERTY(PROP_COLOR_SPREAD, getColorSpread());
APPEND_ENTITY_PROPERTY(PROP_COLOR_START, getColorStart());
APPEND_ENTITY_PROPERTY(PROP_COLOR_FINISH, getColorFinish());
APPEND_ENTITY_PROPERTY(PROP_ALPHA, getAlpha());
APPEND_ENTITY_PROPERTY(PROP_ALPHA_SPREAD, getAlphaSpread());
APPEND_ENTITY_PROPERTY(PROP_ALPHA_START, getAlphaStart());
APPEND_ENTITY_PROPERTY(PROP_ALPHA_FINISH, getAlphaFinish());
APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, getEmitSpeed());
APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, getSpeedSpread());
APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, getEmitOrientation());
APPEND_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, getEmitDimensions());
APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, getEmitRadiusStart());
APPEND_ENTITY_PROPERTY(PROP_POLAR_START, getPolarStart());
APPEND_ENTITY_PROPERTY(PROP_POLAR_FINISH, getPolarFinish());
APPEND_ENTITY_PROPERTY(PROP_AZIMUTH_START, getAzimuthStart());
APPEND_ENTITY_PROPERTY(PROP_AZIMUTH_FINISH, getAzimuthFinish());
APPEND_ENTITY_PROPERTY(PROP_EMITTER_SHOULD_TRAIL, getEmitterShouldTrail());
}
bool RenderableModelEntityItem::isReadyToComputeShape() {
ShapeType type = getShapeType();
if (type == SHAPE_TYPE_COMPOUND) {
if (!_model || _model->getCollisionURL().isEmpty()) {
EntityTreePointer tree = getTree();
if (tree) {
QMetaObject::invokeMethod(tree.get(), "callLoader", Qt::QueuedConnection, Q_ARG(EntityItemID, getID()));
}
return false;
}
if (_model->getURL().isEmpty()) {
// we need a render geometry with a scale to proceed, so give up.
return false;
}
const QSharedPointer<NetworkGeometry> collisionNetworkGeometry = _model->getCollisionGeometry();
const QSharedPointer<NetworkGeometry> renderNetworkGeometry = _model->getGeometry();
if ((collisionNetworkGeometry && collisionNetworkGeometry->isLoaded()) &&
(renderNetworkGeometry && renderNetworkGeometry->isLoaded())) {
// we have both URLs AND both geometries AND they are both fully loaded.
if (_needsInitialSimulation) {
// the _model's offset will be wrong until _needsInitialSimulation is false
PerformanceTimer perfTimer("_model->simulate");
_model->simulate(0.0f);
_needsInitialSimulation = false;
}
return true;
}
// the model is still being downloaded.
return false;
}
return true;
}
