void CameraRig::setRotation(const glm::quat& transform_rotation) {
// Get head transform (a child of camera rig object)
Transform* transform = getHeadTransform();
if (camera_rig_type_ == FREE) {
transform->set_rotation(transform_rotation);
} else if (camera_rig_type_ == YAW_ONLY) {
glm::vec3 look_at = glm::rotate(transform_rotation,
glm::vec3(0.0f, 0.0f, -1.0f));
float yaw = atan2f(-look_at.x, -look_at.z) * 180.0f / M_PI;
transform->set_rotation(
glm::angleAxis(yaw, glm::vec3(0.0f, 1.0f, 0.0f)));
} else if (camera_rig_type_ == ROLL_FREEZE) {
glm::vec3 look_at = glm::rotate(transform_rotation,
glm::vec3(0.0f, 0.0f, -1.0f));
float pitch = atan2f(look_at.y,
sqrtf(look_at.x * look_at.x + look_at.z * look_at.z)) * 180.0f
/ M_PI;
float yaw = atan2f(-look_at.x, -look_at.z) * 180.0f / M_PI;
transform->set_rotation(
glm::angleAxis(pitch, glm::vec3(1.0f, 0.0f, 0.0f)));
transform->rotateByAxis(yaw, 0.0f, 1.0f, 0.0f);
} else if (camera_rig_type_ == FREEZE) {
transform->set_rotation(glm::quat());
} else if (camera_rig_type_ == ORBIT_PIVOT) {
glm::vec3 pivot(getVec3("pivot"));
transform->set_position(pivot.x, pivot.y,
pivot.z + getFloat("distance"));
transform->set_rotation(glm::quat());
transform->rotateWithPivot(transform_rotation.w,
transform_rotation.x, transform_rotation.y,
transform_rotation.z, pivot.x, pivot.y, pivot.z);
}
}
void PerlinFace::init() {
if (_initialized) {
return;
}
glGenBuffers(1, &_vboID);
glGenBuffers(1, &_nboID);
glGenBuffers(1, &_cboID);
_vertexNumber = sizeof(VERTICES) / (FLOAT_PER_VERTEX * sizeof(float));
_oldNormals = new glm::vec3[_vertexNumber];
_newNormals = new glm::vec3[_vertexNumber];
if (_vertices == NULL) {
_vertices = new glm::vec3[_vertexNumber];
for (int i = 0; i < _vertexNumber; ++i) {
_vertices[i] = getVec3(i);
}
_trianglesPos = _triangles = new GLfloat[FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * TRIANGLES_NUMBER];
_normalsPos = _normals = new GLfloat[FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * TRIANGLES_NUMBER];
_colorsPos = _colors = new GLubyte[FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * TRIANGLES_NUMBER];
atexit(staticCleanup);
}
_initialized = true;
}
InstanceModel* Scene::buildInstance(Json::Value defInstance) {
InstanceModel* instance = new InstanceModel(
idModels[defInstance["reference"].asString()]);
mat4 modelView(1);
modelView *= Translate(getVec3(defInstance.get("translate","[0,0,0]")));
instance->setModelView(modelView);
models.push_back(instance);
return instance;
}
void Scene::buildAnimation(Json::Value anim) {
//printf("creating anim: %s\n",anim.toStyledString().c_str());
string type = anim["type"].asString();
//orbit
if(type.compare("orbit") == 0) {
Animation* animation = new OrbitalModel(
(idModels.find(anim["center"].asString())->second),
(idModels.find(anim["orbiter"].asString())->second),
anim.get("distance","1").asFloat(),
anim.get("theta","0").asFloat(),
anim.get("phi","0").asFloat());
animations.push_back(animation);
}
//oscillate
else if(type.compare("oscillate") == 0) {
vec3 max = getVec3(anim.get("max","[0,0,0]"));
vec3 rate = getVec3(anim.get("rate","[0,0,0]"));
vec3 center = getVec3(anim.get("center","[0,0,0]"));
Animation* animation = new OscillatingModel(
(idModels.find(anim["object"].asString())->second),
max.x, max.y, max.z,
rate.x, rate.y, rate.z,
center.x, center.y, center.z );
animations.push_back(animation);
}
else if(type.compare("controlled") == 0) {
vec3 limit = getVec3(anim.get("limit","[0,0,0]"));
Animation* animation = new ControlledModel(
(idModels.find(anim["object"].asString())->second),
anim.get("speed",0.1).asFloat(),
limit.x, limit.y, limit.z );
animations.push_back(animation);
}
else if(type.compare("physics") == 0) {
Animation* animation = new ParticlesModel( (Particles*)(idModels.find(anim["object"].asString())->second) );
animations.push_back(animation);
}
}
void CameraRig::predict(float time) {
long long clock_time = getCurrentTime();
float time_diff = (clock_time - rotation_sensor_data_.time_stamp())
/ 1000000000.0f;
glm::vec3 axis = rotation_sensor_data_.gyro();
float angle = glm::length(axis);
if (angle != 0.0f) {
axis /= angle;
}
angle *= (time + time_diff) * 180.0f / M_PI;
glm::quat rotation = rotation_sensor_data_.quaternion()
* glm::angleAxis(angle, axis);
glm::quat transfrom_rotation = complementary_rotation_ * rotation;
if (camera_rig_type_ == FREE) {
owner_object()->transform()->set_rotation(transfrom_rotation);
} else if (camera_rig_type_ == YAW_ONLY) {
glm::vec3 look_at = glm::rotate(transfrom_rotation,
glm::vec3(0.0f, 0.0f, -1.0f));
float yaw = atan2f(-look_at.x, -look_at.z) * 180.0f / M_PI;
owner_object()->transform()->set_rotation(
glm::angleAxis(yaw, glm::vec3(0.0f, 1.0f, 0.0f)));
} else if (camera_rig_type_ == ROLL_FREEZE) {
glm::vec3 look_at = glm::rotate(transfrom_rotation,
glm::vec3(0.0f, 0.0f, -1.0f));
float pitch = atan2f(look_at.y,
sqrtf(look_at.x * look_at.x + look_at.z * look_at.z)) * 180.0f
/ M_PI;
float yaw = atan2f(-look_at.x, -look_at.z) * 180.0f / M_PI;
owner_object()->transform()->set_rotation(
glm::angleAxis(pitch, glm::vec3(1.0f, 0.0f, 0.0f)));
owner_object()->transform()->rotateByAxis(yaw, 0.0f, 1.0f, 0.0f);
} else if (camera_rig_type_ == FREEZE) {
owner_object()->transform()->set_rotation(glm::quat());
} else if (camera_rig_type_ == ORBIT_PIVOT) {
glm::vec3 pivot(getVec3("pivot"));
owner_object()->transform()->set_position(pivot.x, pivot.y,
pivot.z + getFloat("distance"));
owner_object()->transform()->set_rotation(glm::quat());
owner_object()->transform()->rotateWithPivot(transfrom_rotation.w,
transfrom_rotation.x, transfrom_rotation.y,
transfrom_rotation.z, pivot.x, pivot.y, pivot.z);
}
}
// ----------------------------------------------------------------------------
KartUpdateMessage::KartUpdateMessage(ENetPacket* pkt)
: Message(pkt, MT_KART_INFO)
{
World *world = World::getWorld();
unsigned int num_karts = getInt();
for(unsigned int i=0; i<num_karts; i++)
{
// Currently not used
KartControl kc(this);
Vec3 xyz = getVec3();
btQuaternion q = getQuaternion();
Kart *kart = world->getKart(i);
kart->setXYZ(xyz);
kart->setRotation(q);
} // for i
}; // KartUpdateMessage
void PerlinFace::updatePositions() {
const float BROWS_UP_MAX = 3;
const float BROWS_DOWN_MAX = 1;
const float BROWS_UP_CENTER_MAX = 1;
Faceshift* faceshift = Application::getInstance()->getFaceshift();
if (faceshift->isActive()) {
_browsD_L = faceshift->getBrowDownLeft();
_browsD_R = faceshift->getBrowDownRight();
_browsU_C = faceshift->getBrowUpCenter();
_browsU_L = faceshift->getBrowUpLeft();
_browsU_R = faceshift->getBrowUpRight();
_mouthSize = faceshift->getMouthSize();
_mouthSmileLeft = faceshift->getMouthSmileLeft();
_mouthSmileRight = faceshift->getMouthSmileRight();
_eyeBlink_L = faceshift->getLeftBlink();
_eyeBlink_R = faceshift->getRightBlink();
_eyeOpen_L = faceshift->getLeftEyeOpen();
_eyeOpen_R = faceshift->getRightEyeOpen();
}
// Update left brow
_vertices[BROW_LEFT].y = getVec3(BROW_LEFT).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX
- _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[BROW_MID_TOP].y = getVec3(BROW_MID_TOP).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX;
_vertices[BROW_MID_BOTTOM].y = getVec3(BROW_MID_BOTTOM).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX;
_vertices[BROW_RIGHT_TOP].y = getVec3(BROW_RIGHT_TOP).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[BROW_RIGHT_BOTTOM].y = getVec3(BROW_RIGHT_BOTTOM).y
+ _browsU_L * BROWS_UP_MAX
- _browsD_L * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
// Update right brow
_vertices[NUM_VERTICES + BROW_LEFT].y = getVec3(NUM_VERTICES + BROW_LEFT).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX
- _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[NUM_VERTICES + BROW_MID_TOP].y = getVec3(NUM_VERTICES + BROW_MID_TOP).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX;
_vertices[NUM_VERTICES + BROW_MID_BOTTOM].y = getVec3(NUM_VERTICES + BROW_MID_BOTTOM).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX;
_vertices[NUM_VERTICES + BROW_RIGHT_TOP].y = getVec3(NUM_VERTICES + BROW_RIGHT_TOP).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
_vertices[NUM_VERTICES + BROW_RIGHT_BOTTOM].y = getVec3(NUM_VERTICES + BROW_RIGHT_BOTTOM).y
+ _browsU_R * BROWS_UP_MAX
- _browsD_R * BROWS_DOWN_MAX
+ _browsU_C * BROWS_UP_CENTER_MAX;
const float MOUTH_UP_MAX = 6.5f;
const float MOUTH_SIDE_UP_MAX = 4.0f;
const float SMILE_FACTOR = 1.0f / 3.0f; // 0 = No smile, 1 = The Jocker.
// Mouth
_vertices[MOUTH_BOTTOM_IN].y = getVec3(MOUTH_BOTTOM_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[MOUTH_BOTTOM_OUT].y = getVec3(MOUTH_BOTTOM_OUT).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[MOUTH_MID_IN] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(MOUTH_MID_IN)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(CHICK_MID);
_vertices[MOUTH_MID_OUT] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(MOUTH_MID_OUT)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(CHICK_MID);
_vertices[NUM_VERTICES + MOUTH_BOTTOM_IN].y = getVec3(NUM_VERTICES + MOUTH_BOTTOM_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES + MOUTH_BOTTOM_OUT].y = getVec3(NUM_VERTICES + MOUTH_BOTTOM_OUT).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES + MOUTH_MID_IN] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(NUM_VERTICES + MOUTH_MID_IN)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(NUM_VERTICES + CHICK_MID);
_vertices[NUM_VERTICES + MOUTH_MID_OUT] = (1.0f - (_mouthSmileLeft * SMILE_FACTOR)) * (getVec3(NUM_VERTICES + MOUTH_MID_OUT)
+ glm::vec3(0, (1.0 - _mouthSize) * MOUTH_SIDE_UP_MAX, 0))
+ (_mouthSmileLeft * SMILE_FACTOR) * getVec3(NUM_VERTICES + CHICK_MID);
// Jaw
_vertices[CHIN_IN].y = getVec3(CHIN_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[CHIN_TIP].y = getVec3(CHIN_TIP).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[CHIN_BOTTOM].y = getVec3(CHIN_BOTTOM).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES +CHIN_IN].y = getVec3(NUM_VERTICES + CHIN_IN).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES +CHIN_TIP].y = getVec3(NUM_VERTICES + CHIN_TIP).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
_vertices[NUM_VERTICES +CHIN_BOTTOM].y = getVec3(NUM_VERTICES + CHIN_BOTTOM).y
+ (1.0 - _mouthSize) * MOUTH_UP_MAX;
// Eyelids
glm::vec3 topLeftEyelid = getVec3(EYE_MID_TOP);
glm::vec3 bottomLeftEyelid = getVec3(EYE_MID_BOTTOM);
glm::vec3 topRightEyelid = getVec3(NUM_VERTICES + EYE_MID_TOP);
glm::vec3 bottomRightEyelid = getVec3(NUM_VERTICES + EYE_MID_BOTTOM);
_vertices[EYE_MID_TOP] = (1.0f - (_eyeBlink_L - _eyeOpen_L / 2.0f)) * topLeftEyelid
+ (_eyeBlink_L - _eyeOpen_L / 2.0f) * (topLeftEyelid + bottomLeftEyelid) / 2.0f;
_vertices[EYE_MID_BOTTOM] = (1.0f - (_eyeBlink_L - _eyeOpen_L / 2.0f)) * bottomLeftEyelid
+ (_eyeBlink_L - _eyeOpen_L / 2.0f) * (topLeftEyelid + bottomLeftEyelid) / 2.0f;
_vertices[NUM_VERTICES + EYE_MID_TOP] = (1.0f - (_eyeBlink_R - _eyeOpen_R / 2.0f)) * topRightEyelid
+ (_eyeBlink_R - _eyeOpen_R / 2.0f) * (topRightEyelid + bottomRightEyelid) / 2.0f;
_vertices[NUM_VERTICES + EYE_MID_BOTTOM] = (1.0f - (_eyeBlink_R - _eyeOpen_R / 2.0f)) * bottomRightEyelid
+ (_eyeBlink_R - _eyeOpen_R / 2.0f) * (topRightEyelid + bottomRightEyelid) / 2.0f;
}
Model* Scene::buildModel(Json::Value model) {
string type = model["class"].asString();
Model *retModel;
// menger
if(type.compare("Menger") == 0) {
vec3 center = getVec3(model.get("center", "[0,0,0]"));
printVec("center",center);
float radius = model.get("radius", "1.0").asFloat();
int subdivs = model.get("subdivisions", "2").asInt();
retModel = new Menger(center, radius, subdivs);
}
// sphere
else if(type.compare("Sphere") == 0) {
Sphere *sphere;
if(!model.isMember("ambient")) {
sphere = new Sphere(
model["radius"].asFloat(),
model["subdivs"].asInt(),
lights.size());
} else {
sphere = new Sphere(
model["radius"].asFloat(),
model["subdivs"].asInt(),
lights.size(),
getVec4(model.get("ambient","[1,0,1,1]")),
getVec4(model.get("diffuse","[1,0.8,0,1]")),
getVec4(model.get("specular","[1,0,1,1]")));
}
vector<Light*>::iterator it;
int light = 0;
for(it = lights.begin(); it != lights.end(); it++) {
sphere->setLight((*it), light++);
}
retModel = sphere;
} else if(type.compare("TexTri") == 0) {
retModel = new TexTri(model["texture"].asString().c_str());
printf("created textri\n");
} else if(type.compare("ObjModel") == 0) {
ObjModel *obj = new ObjModel(model["objfile"].asString().c_str(),
lights.size(),
getVec4(model.get("ambient","[1,1,1,1]")),
getVec4(model.get("diffuse","[1,1,1,1]")),
getVec4(model.get("specular","[1,1,1,1]")));
vector<Light*>::iterator it;
int light = 0;
for(it = lights.begin(); it != lights.end(); it++) {
obj->setLight((*it), light++);
}
retModel = obj;
} else if(type.compare("Tesseract") == 0) {
Tesseract *tess = new Tesseract( lights.size() );
vector<Light*>::iterator it;
int light = 0;
for(it = lights.begin(); it != lights.end(); it++) {
tess->setLight((*it), light++);
}
retModel = tess;
} else if(type.compare("Particles") == 0) {
Particles *part = new Particles( model.get("number",50).asInt() );
retModel = part;
}
// map model if it has an id
if(model.isMember("id")) {
string id = model["id"].asString();
nodes[id] = retModel;
idModels[id] = retModel;
}
return retModel;
}
