void RAS_IDisplayArray::UpdateFrom(RAS_IDisplayArray *other, int flag)
{
if (flag & TANGENT_MODIFIED) {
for (unsigned int i = 0, size = other->GetVertexCount(); i < size; ++i) {
GetVertex(i)->SetTangent(MT_Vector4(other->GetVertex(i)->getTangent()));
}
}
if (flag & UVS_MODIFIED) {
const unsigned short uvSize = min_ii(GetVertexUvSize(), other->GetVertexUvSize());
for (unsigned int i = 0, size = other->GetVertexCount(); i < size; ++i) {
for (unsigned int uv = 0; uv < uvSize; ++uv) {
GetVertex(i)->SetUV(uv, MT_Vector2(other->GetVertex(i)->getUV(uv)));
}
}
}
if (flag & POSITION_MODIFIED) {
for (unsigned int i = 0, size = other->GetVertexCount(); i < size; ++i) {
GetVertex(i)->SetXYZ(MT_Vector3(other->GetVertex(i)->getXYZ()));
}
}
if (flag & NORMAL_MODIFIED) {
for (unsigned int i = 0, size = other->GetVertexCount(); i < size; ++i) {
GetVertex(i)->SetNormal(MT_Vector3(other->GetVertex(i)->getNormal()));
}
}
if (flag & COLORS_MODIFIED) {
const unsigned short colorSize = min_ii(GetVertexColorSize(), other->GetVertexColorSize());
for (unsigned int i = 0, size = other->GetVertexCount(); i < size; ++i) {
for (unsigned int color = 0; color < colorSize; ++color) {
GetVertex(i)->SetRGBA(color, other->GetVertex(i)->getRawRGBA(color));
}
}
}
}
void KX_FontObject::UpdateBuckets()
{
// Update datas and add mesh slot to be rendered only if the object is not culled.
if (m_bVisible && m_meshUser) {
if (m_pSGNode->IsDirty()) {
GetOpenGLMatrix();
}
// Allow for some logic brick control
if (GetProperty("Text")) {
m_text = split_string(GetProperty("Text")->GetText());
}
// update the animated color
GetObjectColor().getValue(m_color);
// Font Objects don't use the glsl shader, this color management code is copied from gpu_shader_material.glsl
float color[4];
if (m_do_color_management) {
linearrgb_to_srgb_v4(color, m_color);
}
else {
copy_v4_v4(color, m_color);
}
// HARDCODED MULTIPLICATION FACTOR - this will affect the render resolution directly
const float RES = BGE_FONT_RES * m_resolution;
const float size = m_fsize * NodeGetWorldScaling()[0] * RES;
const float aspect = m_fsize / size;
// Account for offset
MT_Vector3 offset = NodeGetWorldOrientation() * m_offset * NodeGetWorldScaling();
// Orient the spacing vector
MT_Vector3 spacing = NodeGetWorldOrientation() * MT_Vector3(0.0f, m_fsize * m_line_spacing, 0.0f) * NodeGetWorldScaling()[1];
RAS_TextUser *textUser = (RAS_TextUser *)m_meshUser;
textUser->SetColor(MT_Vector4(color));
textUser->SetFrontFace(!m_bIsNegativeScaling);
textUser->SetFontId(m_fontid);
textUser->SetSize(size);
textUser->SetDpi(m_dpi);
textUser->SetAspect(aspect);
textUser->SetOffset(offset);
textUser->SetSpacing(spacing);
textUser->SetTexts(m_text);
textUser->ActivateMeshSlots();
}
}
void KX_BlenderMaterial::setObjectMatrixData(int i, RAS_IRasterizer *ras)
{
KX_GameObject *obj =
(KX_GameObject*)
mScene->GetObjectList()->FindValue(mMaterial->mapping[i].objconame);
if (!obj) return;
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
GLenum plane = GL_EYE_PLANE;
// figure plane gen
float proj[4] = {0.f,0.f,0.f,0.f};
GetProjPlane(mMaterial, i, 0, proj);
glTexGenfv(GL_S, plane, proj);
GetProjPlane(mMaterial, i, 1, proj);
glTexGenfv(GL_T, plane, proj);
GetProjPlane(mMaterial, i, 2, proj);
glTexGenfv(GL_R, plane, proj);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
const MT_Matrix4x4& mvmat = ras->GetViewMatrix();
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glScalef(
mMaterial->mapping[i].scale[0],
mMaterial->mapping[i].scale[1],
mMaterial->mapping[i].scale[2]
);
MT_Point3 pos = obj->NodeGetWorldPosition();
MT_Vector4 matmul = MT_Vector4(pos[0], pos[1], pos[2], 1.f);
MT_Vector4 t = mvmat*matmul;
glTranslatef( (float)(-t[0]), (float)(-t[1]), (float)(-t[2]) );
glMatrixMode(GL_MODELVIEW);
}
RAS_MeshSlot::RAS_MeshSlot() : SG_QList()
{
m_clientObj = NULL;
m_pDeformer = NULL;
m_OpenGLMatrix = NULL;
m_mesh = NULL;
m_bucket = NULL;
m_bVisible = false;
m_bCulled = true;
m_bObjectColor = false;
m_RGBAcolor = MT_Vector4(0.0, 0.0, 0.0, 0.0);
m_DisplayList = NULL;
m_bDisplayList = true;
m_joinSlot = NULL;
m_pDerivedMesh = NULL;
}
void RAS_TexVert::Transform(const MT_Matrix4x4& mat, const MT_Matrix4x4& nmat)
{
SetXYZ((mat*MT_Vector4(m_localxyz[0], m_localxyz[1], m_localxyz[2], 1.0)).getValue());
SetNormal((nmat*MT_Vector4(m_normal[0], m_normal[1], m_normal[2], 1.0)).getValue());
SetTangent((nmat*MT_Vector4(m_tangent[0], m_tangent[1], m_tangent[2], 1.0)).getValue());
}
void RAS_TexVert::TransformUV(int index, const MT_Matrix4x4& mat)
{
SetUV(index, (mat * MT_Vector4(m_uvs[index][0], m_uvs[index][1], 0.0, 1.0)).getValue());
}
bool KX_SteeringActuator::Update(double curtime, bool frame)
{
if (frame)
{
double delta = curtime - m_updateTime;
m_updateTime = curtime;
if (m_posevent && !m_isActive)
{
delta = 0.0;
m_pathUpdateTime = -1.0;
m_updateTime = curtime;
m_isActive = true;
}
bool bNegativeEvent = IsNegativeEvent();
if (bNegativeEvent)
m_isActive = false;
RemoveAllEvents();
if (!delta)
return true;
if (bNegativeEvent || !m_target)
return false; // do nothing on negative events
KX_GameObject *obj = (KX_GameObject*) GetParent();
const MT_Vector3& mypos = obj->NodeGetWorldPosition();
const MT_Vector3& targpos = m_target->NodeGetWorldPosition();
MT_Vector3 vectotarg = targpos - mypos;
MT_Vector3 vectotarg2d = vectotarg;
vectotarg2d.z() = 0.0f;
m_steerVec = MT_Vector3(0.0f, 0.0f, 0.0f);
bool apply_steerforce = false;
bool terminate = true;
switch (m_mode) {
case KX_STEERING_SEEK:
if (vectotarg2d.length2()>m_distance*m_distance)
{
terminate = false;
m_steerVec = vectotarg;
m_steerVec.normalize();
apply_steerforce = true;
}
break;
case KX_STEERING_FLEE:
if (vectotarg2d.length2()<m_distance*m_distance)
{
terminate = false;
m_steerVec = -vectotarg;
m_steerVec.normalize();
apply_steerforce = true;
}
break;
case KX_STEERING_PATHFOLLOWING:
if (m_navmesh && vectotarg.length2()>m_distance*m_distance)
{
terminate = false;
static const MT_Scalar WAYPOINT_RADIUS(0.25f);
if (m_pathUpdateTime<0 || (m_pathUpdatePeriod>=0 &&
curtime - m_pathUpdateTime>((double)m_pathUpdatePeriod/1000.0)))
{
m_pathUpdateTime = curtime;
m_pathLen = m_navmesh->FindPath(mypos, targpos, m_path, MAX_PATH_LENGTH);
m_wayPointIdx = m_pathLen > 1 ? 1 : -1;
}
if (m_wayPointIdx>0)
{
MT_Vector3 waypoint(&m_path[3*m_wayPointIdx]);
if ((waypoint-mypos).length2()<WAYPOINT_RADIUS*WAYPOINT_RADIUS)
{
m_wayPointIdx++;
if (m_wayPointIdx>=m_pathLen)
{
m_wayPointIdx = -1;
terminate = true;
}
else
waypoint.setValue(&m_path[3*m_wayPointIdx]);
}
m_steerVec = waypoint - mypos;
apply_steerforce = true;
if (m_enableVisualization)
{
//debug draw
static const MT_Vector4 PATH_COLOR(1.0f, 0.0f, 0.0f, 1.0f);
m_navmesh->DrawPath(m_path, m_pathLen, PATH_COLOR);
}
}
}
break;
}
if (apply_steerforce)
{
bool isdyna = obj->IsDynamic();
if (isdyna)
m_steerVec.z() = 0;
if (!m_steerVec.fuzzyZero())
m_steerVec.normalize();
MT_Vector3 newvel = m_velocity * m_steerVec;
//adjust velocity to avoid obstacles
if (m_simulation && m_obstacle /*&& !newvel.fuzzyZero()*/)
{
if (m_enableVisualization)
KX_RasterizerDrawDebugLine(mypos, mypos + newvel, MT_Vector4(1.0f, 0.0f, 0.0f, 1.0f));
m_simulation->AdjustObstacleVelocity(m_obstacle, m_mode!=KX_STEERING_PATHFOLLOWING ? m_navmesh : NULL,
newvel, m_acceleration*(float)delta, m_turnspeed/(180.0f*(float)(M_PI*delta)));
if (m_enableVisualization)
KX_RasterizerDrawDebugLine(mypos, mypos + newvel, MT_Vector4(0.0f, 1.0f, 0.0f, 1.0f));
}
HandleActorFace(newvel);
if (isdyna)
{
//temporary solution: set 2D steering velocity directly to obj
//correct way is to apply physical force
MT_Vector3 curvel = obj->GetLinearVelocity();
if (m_lockzvel)
newvel.z() = 0.0f;
else
newvel.z() = curvel.z();
obj->setLinearVelocity(newvel, false);
}
else
{
MT_Vector3 movement = delta*newvel;
obj->ApplyMovement(movement, false);
}
}
else
{
if (m_simulation && m_obstacle)
{
m_obstacle->dvel[0] = 0.f;
m_obstacle->dvel[1] = 0.f;
}
}
if (terminate && m_isSelfTerminated)
return false;
}
return true;
}