void HexagonGame::update(float mFrameTime)
{
if(!hasDied)
{
manager.update(mFrameTime);
updateLevelEvents(mFrameTime);
if(timeStop <= 0)
{
currentTime += mFrameTime / 60.0f;
incrementTime += mFrameTime / 60.0f;
}
else timeStop -= 1 * mFrameTime;
updateIncrement();
updateLevel(mFrameTime);
updateRadius(mFrameTime);
if(!getBlackAndWhite()) styleData.update(mFrameTime);
}
else setRotationSpeed(getRotationSpeed() / 1.001f);
updateKeys();
if(!getNoRotation()) updateRotation(mFrameTime);
if(mustRestart) newGame(levelData.getId(), false);
}
TargetVisualizerDisplay::TargetVisualizerDisplay():
message_recieved_(false)
{
target_name_property_ = new rviz::StringProperty(
"target name", "target",
"name of the target",
this, SLOT(updateTargetName())
);
radius_property_ = new rviz::FloatProperty(
"radius", 1.0,
"radius of the target mark",
this, SLOT(updateRadius()));
radius_property_->setMin(0.0);
alpha_property_ = new rviz::FloatProperty(
"alpha", 0.8,
"0 is fully transparent, 1.0 is fully opaque.",
this, SLOT(updateAlpha()));
alpha_property_->setMin(0.0);
alpha_property_->setMax(1.0);
color_property_ = new rviz::ColorProperty(
"color", QColor(25, 255, 240),
"color of the target",
this, SLOT(updateColor()));
shape_type_property_ = new rviz::EnumProperty(
"type", "Simple Circle",
"Shape to display the pose as",
this, SLOT(updateShapeType()));
shape_type_property_->addOption("Simple Circle", SimpleCircle);
shape_type_property_->addOption("Decoreted Circle", GISCircle);
}
// ***************************************************************************
void CAABBoxExt::serial(NLMISC::IStream &f)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
CAABBox::serial(f);
if(f.isReading())
updateRadius();
}
void TargetVisualizerDisplay::onInitialize()
{
MFDClass::onInitialize();
scene_node_ = scene_manager_->getRootSceneNode()->createChildSceneNode();
updateRadius();
updateShapeType();
// updateTargetName();
// updateColor();
// updateAlpha();
}
LLDrawable* LLVOTree::createDrawable(LLPipeline *pipeline)
{
pipeline->allocDrawable(this);
mDrawable->setLit(FALSE);
mDrawable->setRenderType(LLPipeline::RENDER_TYPE_TREE);
LLDrawPoolTree *poolp = (LLDrawPoolTree*) gPipeline.getPool(LLDrawPool::POOL_TREE, mTreeImagep);
// Just a placeholder for an actual object...
LLFace *facep = mDrawable->addFace(poolp, mTreeImagep);
facep->setSize(1, 3);
updateRadius();
return mDrawable;
}
void DiagnosticsDisplay::onInitialize()
{
static int counter = 0;
scene_node_ = scene_manager_->getRootSceneNode()->createChildSceneNode();
orbit_node_ = scene_node_->createChildSceneNode(); // ??
line_ = new rviz::BillboardLine(context_->getSceneManager(), scene_node_);
msg_ = new rviz::MovableText("not initialized", "Liberation Sans", 0.05);
msg_->setTextAlignment(rviz::MovableText::H_CENTER,
rviz::MovableText::V_ABOVE);
frame_id_property_->setFrameManager(context_->getFrameManager());
orbit_node_->attachObject(msg_);
msg_->setVisible(false);
orbit_theta_ = M_PI * 2.0 / 6 * counter++;
updateLineWidth();
updateAxis();
updateDiagnosticsNamespace();
updateRadius();
updateRosTopic();
updateFontSize();
}
DiagnosticsDisplay::DiagnosticsDisplay()
: rviz::Display(), msg_(0)
{
ros_topic_property_
= new rviz::RosTopicProperty(
"Topic", "/diagnostics_agg",
ros::message_traits::datatype<diagnostic_msgs::DiagnosticArray>(),
"diagnostic_msgs::DiagnosticArray topic to subscribe to.",
this, SLOT( updateRosTopic() ));
frame_id_property_ = new rviz::TfFrameProperty(
"frame_id", rviz::TfFrameProperty::FIXED_FRAME_STRING,
"the parent frame_id to visualize diagnostics",
this, 0, true);
diagnostics_namespace_property_ = new rviz::EditableEnumProperty(
"diagnostics namespace", "/",
"diagnostics namespace to visualize diagnostics",
this, SLOT(updateDiagnosticsNamespace()));
radius_property_ = new rviz::FloatProperty(
"radius", 1.0,
"radius of diagnostics circle",
this, SLOT(updateRadius()));
line_width_property_ = new rviz::FloatProperty(
"line width", 0.03,
"line width",
this, SLOT(updateLineWidth()));
axis_property_ = new rviz::EnumProperty(
"axis", "x",
"axis",
this, SLOT(updateAxis()));
axis_property_->addOption("x", 0);
axis_property_->addOption("y", 1);
axis_property_->addOption("z", 2);
font_size_property_ = new rviz::FloatProperty(
"font size", 0.05,
"font size",
this, SLOT(updateFontSize()));
}
//----------------------------------------------------------------------------
// Summary:
// Parameters:
// Returns:
//----------------------------------------------------------------------------
void dmGLPolarCamera_zup::spinScene(int delta[2], int button)
{
if (button & MOUSE_LEFT_DOWN)
{
// mouse x position controls azimuth
// mouse y position controls elevation
updateAzimuth(-delta[0]*0.5);
updateElevation(-delta[1]*0.5);
}
if (button & MOUSE_MIDDLE_DOWN)
{
static float delta_pos[3];
delta_pos[0] =-m_trans_scale*delta[0];
delta_pos[1] = m_trans_scale*delta[1];
//delta_pos[2] = 0.0;
m_pos_coi[0] += delta_pos[0]*m_cos_az
+ delta_pos[1]*m_sin_az*m_sin_el;
//+ delta_pos[2]*m_sin_az*m_cos_el;
m_pos_coi[1] += delta_pos[0]*m_sin_az
- delta_pos[1]*m_cos_az*m_sin_el;
//- delta_pos[2]*m_cos_az*m_cos_el;
m_pos_coi[2] += delta_pos[1]*m_cos_el;
//- delta_pos[2]*m_sin_el;
}
if (button & MOUSE_RIGHT_DOWN)
{
updateRadius(-m_trans_scale*delta[1]);
}
}
void ParticleEffectEntityItem::stepSimulation(float deltaTime) {
_particleMinBound = glm::vec3(-1.0f, -1.0f, -1.0f);
_particleMaxBound = glm::vec3(1.0f, 1.0f, 1.0f);
// update particles between head and tail
for (quint32 i = _particleHeadIndex; i != _particleTailIndex; i = (i + 1) % _maxParticles) {
_particleLifetimes[i] -= deltaTime;
// if particle has died.
if (_particleLifetimes[i] <= 0.0f || _lifespan == 0.0f) {
// move head forward
_particleHeadIndex = (_particleHeadIndex + 1) % _maxParticles;
}
else {
float age = 1.0f - _particleLifetimes[i] / _lifespan; // 0.0 .. 1.0
updateRadius(i, age);
updateColor(i, age);
updateAlpha(i, age);
integrateParticle(i, deltaTime);
extendBounds(_particlePositions[i]);
}
}
// emit new particles, but only if we are emmitting
if (getIsEmitting() && _emitRate > 0.0f && _lifespan > 0.0f && _polarStart <= _polarFinish) {
float timeLeftInFrame = deltaTime;
while (_timeUntilNextEmit < timeLeftInFrame) {
timeLeftInFrame -= _timeUntilNextEmit;
_timeUntilNextEmit = 1.0f / _emitRate;
// emit a new particle at tail index.
quint32 i = _particleTailIndex;
_particleLifetimes[i] = _lifespan;
// Radius
if (_radiusSpread == 0.0f) {
_radiusStarts[i] = getRadiusStart();
_radiusMiddles[i] =_particleRadius;
_radiusFinishes[i] = getRadiusFinish();
} else {
float spreadMultiplier;
if (_particleRadius > 0.0f) {
spreadMultiplier = 1.0f + randFloatInRange(-1.0f, 1.0f) * _radiusSpread / _particleRadius;
} else {
spreadMultiplier = 1.0f;
}
_radiusStarts[i] =
glm::clamp(spreadMultiplier * getRadiusStart(), MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
_radiusMiddles[i] =
glm::clamp(spreadMultiplier * _particleRadius, MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
_radiusFinishes[i] =
glm::clamp(spreadMultiplier * getRadiusFinish(), MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
}
updateRadius(i, 0.0f);
// Position, velocity, and acceleration
if (_polarStart == 0.0f && _polarFinish == 0.0f && _emitDimensions.z == 0.0f) {
// Emit along z-axis from position
_particlePositions[i] = getPosition();
_particleVelocities[i] =
(_emitSpeed + randFloatInRange(-1.0f, 1.0f) * _speedSpread) * (_emitOrientation * Z_AXIS);
_particleAccelerations[i] = _emitAcceleration + randFloatInRange(-1.0f, 1.0f) * _accelerationSpread;
} else {
// Emit around point or from ellipsoid
// - Distribute directions evenly around point
// - Distribute points relatively evenly over ellipsoid surface
// - Distribute points relatively evenly within ellipsoid volume
float elevationMinZ = sin(PI_OVER_TWO - _polarFinish);
float elevationMaxZ = sin(PI_OVER_TWO - _polarStart);
float elevation = asin(elevationMinZ + (elevationMaxZ - elevationMinZ) * randFloat());
float azimuth;
if (_azimuthFinish >= _azimuthStart) {
azimuth = _azimuthStart + (_azimuthFinish - _azimuthStart) * randFloat();
} else {
azimuth = _azimuthStart + (TWO_PI + _azimuthFinish - _azimuthStart) * randFloat();
}
glm::vec3 emitDirection;
if (_emitDimensions == glm::vec3()) {
// Point
emitDirection = glm::quat(glm::vec3(PI_OVER_TWO - elevation, 0.0f, azimuth)) * Z_AXIS;
_particlePositions[i] = getPosition();
} else {
// Ellipsoid
float radiusScale = 1.0f;
if (_emitRadiusStart < 1.0f) {
float emitRadiusStart = glm::max(_emitRadiusStart, EPSILON); // Avoid math complications at center
float randRadius =
emitRadiusStart + randFloatInRange(0.0f, MAXIMUM_EMIT_RADIUS_START - emitRadiusStart);
radiusScale = 1.0f - std::pow(1.0f - randRadius, 3.0f);
}
glm::vec3 radiuses = radiusScale * 0.5f * _emitDimensions;
float x = radiuses.x * glm::cos(elevation) * glm::cos(azimuth);
float y = radiuses.y * glm::cos(elevation) * glm::sin(azimuth);
float z = radiuses.z * glm::sin(elevation);
glm::vec3 emitPosition = glm::vec3(x, y, z);
emitDirection = glm::normalize(glm::vec3(
radiuses.x > 0.0f ? x / (radiuses.x * radiuses.x) : 0.0f,
radiuses.y > 0.0f ? y / (radiuses.y * radiuses.y) : 0.0f,
radiuses.z > 0.0f ? z / (radiuses.z * radiuses.z) : 0.0f
));
_particlePositions[i] = getPosition() + _emitOrientation * emitPosition;
}
_particleVelocities[i] =
(_emitSpeed + randFloatInRange(-1.0f, 1.0f) * _speedSpread) * (_emitOrientation * emitDirection);
_particleAccelerations[i] = _emitAcceleration + randFloatInRange(-1.0f, 1.0f) * _accelerationSpread;
}
integrateParticle(i, timeLeftInFrame);
extendBounds(_particlePositions[i]);
// Color
if (_colorSpread == xColor{ 0, 0, 0 }) {
_colorStarts[i] = getColorStart();
_colorMiddles[i] = getXColor();
_colorFinishes[i] = getColorFinish();
} else {
xColor startColor = getColorStart();
xColor middleColor = getXColor();
xColor finishColor = getColorFinish();
float spread = randFloatInRange(-1.0f, 1.0f);
float spreadMultiplierRed =
middleColor.red > 0 ? 1.0f + spread * (float)_colorSpread.red / (float)middleColor.red : 1.0f;
float spreadMultiplierGreen =
middleColor.green > 0 ? 1.0f + spread * (float)_colorSpread.green / (float)middleColor.green : 1.0f;
float spreadMultiplierBlue =
middleColor.blue > 0 ? 1.0f + spread * (float)_colorSpread.blue / (float)middleColor.blue : 1.0f;
_colorStarts[i].red = (int)glm::clamp(spreadMultiplierRed * (float)startColor.red, 0.0f, 255.0f);
_colorStarts[i].green = (int)glm::clamp(spreadMultiplierGreen * (float)startColor.green, 0.0f, 255.0f);
_colorStarts[i].blue = (int)glm::clamp(spreadMultiplierBlue * (float)startColor.blue, 0.0f, 255.0f);
_colorMiddles[i].red = (int)glm::clamp(spreadMultiplierRed * (float)middleColor.red, 0.0f, 255.0f);
_colorMiddles[i].green = (int)glm::clamp(spreadMultiplierGreen * (float)middleColor.green, 0.0f, 255.0f);
_colorMiddles[i].blue = (int)glm::clamp(spreadMultiplierBlue * (float)middleColor.blue, 0.0f, 255.0f);
_colorFinishes[i].red = (int)glm::clamp(spreadMultiplierRed * (float)finishColor.red, 0.0f, 255.0f);
_colorFinishes[i].green = (int)glm::clamp(spreadMultiplierGreen * (float)finishColor.green, 0.0f, 255.0f);
_colorFinishes[i].blue = (int)glm::clamp(spreadMultiplierBlue * (float)finishColor.blue, 0.0f, 255.0f);
}
updateColor(i, 0.0f);
// Alpha
if (_alphaSpread == 0.0f) {
_alphaStarts[i] = getAlphaStart();
_alphaMiddles[i] = _alpha;
_alphaFinishes[i] = getAlphaFinish();
} else {
float spreadMultiplier = 1.0f + randFloatInRange(-1.0f, 1.0f) * _alphaSpread / _alpha;
_alphaStarts[i] = spreadMultiplier * getAlphaStart();
_alphaMiddles[i] = spreadMultiplier * _alpha;
_alphaFinishes[i] = spreadMultiplier * getAlphaFinish();
}
updateAlpha(i, 0.0f);
_particleTailIndex = (_particleTailIndex + 1) % _maxParticles;
// overflow! move head forward by one.
// because the case of head == tail indicates an empty array, not a full one.
// This can drop an existing older particle, but this is by design, newer particles are a higher priority.
if (_particleTailIndex == _particleHeadIndex) {
_particleHeadIndex = (_particleHeadIndex + 1) % _maxParticles;
}
}
_timeUntilNextEmit -= timeLeftInFrame;
}
}
