void ParticleSkinnedModel::resetParticlePositions()
{
const size_t max_bones = 128;
glm::mat4 finalMat[max_bones];
// 16K on the stack thanks to this, perhaps allocate in heap?
// The idéa is to make sure it is coherent in memory.
size_t boneCount = m_body->getBoneCount();
assert(boneCount < max_bones);
calculateFinalBoneMatrices(finalMat, boneCount);
for(size_t i=0; i<m_particles.size(); ++i)
{
const Body::sVertex v = m_body->getVertexData()[i];
sParticle& p = m_particles[i];
glm::vec4 finalPos(0.0f);
for(size_t u=0; u<MAX_WEIGHTS; ++u)
{
if(v.weight[u].unused())
break;
int index = v.weight[u].getIndex();
float weight = v.weight[u].getWeight();
finalPos += weight * finalMat[index] * glm::vec4(v.position, 1);
}
p.oldPosition = p.position = glm::vec3(finalPos);
//p.mass = 0.1f;
}
m_ps->setData(&m_particles[0], m_particles.size());
}
void ListboxNumberItem::draw(RenderCache& cache,const Rect& targetRect, float zBase, float alpha, const Rect* clipper) const
{
if (d_selected && d_selectBrush != 0)
{
cache.cacheImage(*d_selectBrush, targetRect, zBase, getModulateAlphaColourRect(d_selectCols, alpha), clipper);
}
const Font* font = getFont();
if (font)
{
Rect finalPos(targetRect);
finalPos.d_top -= (font->getLineSpacing() - font->getBaseline()) * 0.5f;
cache.cacheText(d_itemText, font, LeftAligned, finalPos, zBase, getModulateAlphaColourRect(d_textCols, alpha), clipper);
}
}
void ListboxTextItem::draw(RenderCache& cache,const Rect& targetRect, float zBase, float alpha, const Rect* clipper) const
{
if (d_selected && d_selectBrush != 0)
{
cache.cacheImage(*d_selectBrush, targetRect, zBase, getModulateAlphaColourRect(d_selectCols, alpha), clipper);
}
const FontBase* font = getFont();
if (font)
{
Rect finalPos(targetRect);
finalPos.d_top += PixelAligned( FontBase::LineSpace * 0.5f);
cache.cacheText( getOwnerWindow(), d_itemText, font, d_horzFormateing, finalPos, zBase, getModulateAlphaColourRect(d_textCols, alpha), clipper);
}
}
/*************************************************************************
Draw the list box item in its current state.
*************************************************************************/
void ListboxNumberItem::draw(const Vector3& position, float alpha, const Rect& clipper) const
{
if (d_selected && (d_selectBrush != NULL))
{
d_selectBrush->draw(clipper, position.d_z, clipper, getModulateAlphaColourRect(d_selectCols, alpha));
}
const Font* fnt = getFont();
if (fnt != NULL)
{
Vector3 finalPos(position);
finalPos.d_y -= PixelAligned((fnt->getLineSpacing() - fnt->getBaseline()) * 0.5f);
fnt->drawText(d_itemText, finalPos, clipper, getModulateAlphaColourRect(d_textCols, alpha));
}
}
/*************************************************************************
Draw the tree item in its current state.
*************************************************************************/
void TreeItem::draw(GeometryBuffer& buffer, const Rect &targetRect,
float alpha, const Rect *clipper) const
{
Rect finalRect(targetRect);
if (d_iconImage != 0)
{
Rect finalPos(finalRect);
finalPos.setWidth(targetRect.getHeight());
finalPos.setHeight(targetRect.getHeight());
d_iconImage->draw(buffer, finalPos, clipper,
ColourRect(colour(1,1,1,alpha)));
finalRect.d_left += targetRect.getHeight();
}
if (d_selected && d_selectBrush != 0)
d_selectBrush->draw(buffer, finalRect, clipper,
getModulateAlphaColourRect(d_selectCols, alpha));
Font* font = getFont();
if (!font)
return;
Vector2 draw_pos(finalRect.getPosition());
draw_pos.d_y -= (font->getLineSpacing() - font->getBaseline()) * 0.5f;
if (!d_renderedStringValid)
parseTextString();
const ColourRect final_colours(
getModulateAlphaColourRect(ColourRect(0xFFFFFFFF), alpha));
for (size_t i = 0; i < d_renderedString.getLineCount(); ++i)
{
d_renderedString.draw(i, buffer, draw_pos, &final_colours, clipper, 0.0f);
draw_pos.d_y += d_renderedString.getPixelSize(i).d_height;
}
}
void Camara_main_movimiento(CGameObject* gameObject)
{
// lerp
static float initial_fixed_rotation_time = 0.f;
static bool train_move = false;
if(initial_fixed_rotation_time != 0.f)
{
// Interpolate Y axis to angle "0"
vector3f initialAngles = gameObject->Transform()->LRotation();
vector3f finalAngle(0.f, 0.f, 0.f);
float current_alpha = (gTime.GetTicks_s() - initial_fixed_rotation_time)/50.f; // 50 -> Arbitrary value
gameObject->Transform()->SetAngle(gMath.lerpAngles(initialAngles, finalAngle, current_alpha));
float epsilon = 1.f;
if((gMath.abs(finalAngle.x - initialAngles.x) <= epsilon or gMath.abs(finalAngle.x - initialAngles.x) >= 360 - epsilon)
and (gMath.abs(finalAngle.y - initialAngles.y) <= epsilon or gMath.abs(finalAngle.y - initialAngles.y) >= 360 - epsilon)
and (gMath.abs(finalAngle.z - initialAngles.z) <= epsilon or gMath.abs(finalAngle.z - initialAngles.z) >= 360 - epsilon))
{
initial_fixed_rotation_time = 0.f;
return;
}
return;
}
if(train_move)
{
vector3f initialPos = gameObject->Transform()->Position();
vector3f finalPos(0.f, 0.f, 0.f);
gameObject->Transform()->SetPosition(gMath.lerp(initialPos, finalPos, 0.05f));
if(initialPos == finalPos)
train_move = false;
return;
}
if (gUserInput.Keyboard("T"))
{
initial_fixed_rotation_time = gTime.GetTicks_s();
}
if (gUserInput.Keyboard("Y"))
{
train_move = true;
}
float boost = 1.f;
if (gUserInput.Keyboard("left shift"))
boost = 3.f;
gameObject->Transform()->LTranslate(gUserInput.axis1.horizontal * boost * -3.f * gTime.deltaTime_s(), 0.f, gUserInput.axis1.vertical * boost * 3.f * gTime.deltaTime_s());
if (gUserInput.Keyboard("E"))
{
gameObject->Transform()->Translate(0.f, boost * -3.f * gTime.deltaTime_s(), 0.f);
}
if (gUserInput.Keyboard("Q"))
{
gameObject->Transform()->Translate(0.f, boost * 3.f * gTime.deltaTime_s(), 0.f);
}
// Viewport
if(gUserInput.axis2.vertical > 0)
{
gameObject->Camera()->viewport.height += 0.1f * gTime.deltaTime_s();
if(gameObject->Camera()->viewport.height > 1.f)
gameObject->Camera()->viewport.height = 1.f;
}
else if(gUserInput.axis2.vertical < 0)
{
gameObject->Camera()->viewport.height -= 0.1f * gTime.deltaTime_s();
if(gameObject->Camera()->viewport.height < 0.f)
gameObject->Camera()->viewport.height = 0.f;
}
if(gUserInput.axis2.horizontal < 0)
{
gameObject->Camera()->viewport.width -= 0.1f * gTime.deltaTime_s();
if(gameObject->Camera()->viewport.width < 0.f)
gameObject->Camera()->viewport.width = 0.f;
}
else if(gUserInput.axis2.horizontal > 0)
{
gameObject->Camera()->viewport.width += 0.1f * gTime.deltaTime_s();
if(gameObject->Camera()->viewport.width > 1.f)
gameObject->Camera()->viewport.width = 1.f;
}
/*if (gUserInput.Keyboard("T"))
{
gameObject->Transform()->LookAt(vector3f(0.f, 0.f, 0.f));
}*/
Camara_mouse_movimiento(gameObject);
Camara_Joystick_movimiento(gameObject);
}
void ParticleSkinnedModel::update(float dt)
{
// Send update call to superclass
Model::update(dt);
const int PS_SUB_UPDATE_STEPS = 2;
const int PS_CONSTRAINT_STEPS = 0;
const float TARGET_TIME = (float)(1.0 / (60.0 * PS_SUB_UPDATE_STEPS));
dt = TARGET_TIME;
if(m_simulateOnGPU)
{
int loc;
Shader& shader = m_ps->getShader();
shader.bind();
loc = shader.getUniformLocation("modelMatrix");
glUniformMatrix4fv(loc, 1, false, glm::value_ptr(getTransform().getMat4()));
loc = shader.getUniformLocation("invModelMatrix");
glUniformMatrix4fv(loc, 1, false, glm::value_ptr(getTransform().getInvMat4()));
loc = shader.getUniformLocation("boneMatrix");
calculateAndSetBoneMatrices(loc);
//loc = shader.getUniformLocation("randomForce");
for(int i=0; i<PS_SUB_UPDATE_STEPS; ++i)
{
m_ps->update(dt);
}
}
else
{
const size_t max_bones = 128;
glm::mat4 finalMat[max_bones];
// 16K on the stack thanks to this, perhaps allocate in heap?
// The idéa is to make sure it is coherent in memory.
std::vector<glm::vec3> targetPos(m_particles.size());
size_t boneCount = m_body->getBoneCount();
assert(boneCount < max_bones);
calculateFinalBoneMatrices(finalMat, boneCount);
for(size_t i=0; i<targetPos.size(); ++i)
{
const Body::sVertex& v = m_body->getVertexData()[i];
glm::vec4 finalPos(0.0f);
for(size_t u=0; u<MAX_WEIGHTS; ++u)
{
if(v.weight[u].unused())
break;
int index = v.weight[u].getIndex();
float weight = v.weight[u].getWeight();
finalPos += weight * finalMat[index] * glm::vec4(v.position, 1);
}
targetPos[i] = glm::vec3(finalPos);
}
const glm::vec3 externalForce(0);
const glm::vec3 externalAcc(0,-9.82,0);
const float maxDist = 0.1;
for(int u=0; u<PS_SUB_UPDATE_STEPS; ++u)
{
// Simulate timesteps
for(size_t i=0; i<m_particles.size(); ++i)
{
sParticle& p = m_particles[i];
glm::vec3& target = targetPos[i];
float mass = p.mass_k_d.x;
float k = p.mass_k_d.y;
float d = p.mass_k_d.z * 0.4f;
//float len = glm::length(target - p.position);
glm::vec3 attrForce = (target - p.position) * k;
glm::vec3 force = externalForce + attrForce;
glm::vec3 acc = externalAcc + force / mass;
glm::vec3 pos = p.position;
glm::vec3 vel = (1.0f - d) * (p.position - p.oldPosition) + acc * dt * dt;
// This part can probably be optimized further
// This is to make a soft clamp of the particle pos to the max allowed distance
float dist = glm::distance(pos, target);
glm::vec3 goPath = (pos-target) / dist;
pos += vel;
if(dist < maxDist) {
p.oldPosition = p.position;
p.position = pos;
}else{
glm::vec3 maxDistPos = target + goPath * maxDist;
p.position = glm::mix(pos, maxDistPos, glm::clamp(glm::distance(maxDistPos,pos), 0.0f, 1.0f));
p.oldPosition = p.position - vel;
}
}
}
const std::vector<Body::sVertex>& vertexData = m_body->getVertexData();
const float stiffness = 0.1f;
for(int u=0; u<PS_CONSTRAINT_STEPS; ++u)
{
// Update constraints
for(size_t i=0; i<m_constraints.size(); ++i)
{
size_t i0 = m_constraints[i].index[0];
size_t i1 = m_constraints[i].index[1];
sParticle& p0 = m_particles[i0];
sParticle& p1 = m_particles[i1];
float m0 = p0.mass_k_d.x;
float m1 = p1.mass_k_d.x;
glm::vec3 delta = p1.position - p0.position;
glm::vec3 restDelta = vertexData[i1].position - vertexData[i0].position;
float restLength2 = glm::dot(restDelta, restDelta);
delta *= (1.0f - 2.0f * restLength2 / (restLength2 + glm::dot(delta,delta)) ) * (m0 + m1);
glm::vec3 val = stiffness * delta;
p0.position += val / m0;
p1.position -= val / m1;
}
// Merge seems and maintain velocity
for(size_t i=0; i<m_postVertexMerge.size(); ++i)
{
const unsigned int i0 = m_postVertexMerge[i].index[0];
const unsigned int i1 = m_postVertexMerge[i].index[1];
glm::vec3 v0 = m_particles[i0].position - m_particles[i0].oldPosition;
glm::vec3 v1 = m_particles[i1].position - m_particles[i1].oldPosition;
glm::vec3 p = m_particles[i0].position * 0.5f + m_particles[i1].position * 0.5f;
m_particles[i0].position = p;
m_particles[i0].oldPosition = p - v0;
m_particles[i1].position = p;
m_particles[i1].oldPosition = p - v1;
}
}
// Update bufferdata!
m_particleBuffer.bind();
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(sParticle) * m_particles.size(), &m_particles[0]);
m_particleBuffer.unbind();
}
}
