void setRay() {
vert = vec3(0, 1, 0);
hori = vert ^ dir;
dir = dir.normalize();
vert = vert.normalize();
hori = hori.normalize();
hori = hori * ( dir.length() * Tan(Fangle/2) / (Rw/2) );
vert = vert * ( dir.length() * Tan(Fangle/2) / (Rh/2) );
dir = dir - Rw/2 * hori + Rh/2 * vert;
///cout << dir[0] << ", " << dir[1] << ", " << dir[2] << endl;
}
void EarthquakeApp::setup()
{
gl::Texture earthDiffuse = gl::Texture( loadImage( loadResource( RES_EARTHDIFFUSE ) ) );
gl::Texture earthNormal = gl::Texture( loadImage( loadResource( RES_EARTHNORMAL ) ) );
gl::Texture earthMask = gl::Texture( loadImage( loadResource( RES_EARTHMASK ) ) );
earthDiffuse.setWrap( GL_REPEAT, GL_REPEAT );
earthNormal.setWrap( GL_REPEAT, GL_REPEAT );
earthMask.setWrap( GL_REPEAT, GL_REPEAT );
mStars = gl::Texture( loadImage( loadResource( RES_STARS_PNG ) ) );
mEarthShader = gl::GlslProg( loadResource( RES_PASSTHRU_VERT ), loadResource( RES_EARTH_FRAG ) );
mQuakeShader = gl::GlslProg( loadResource( RES_QUAKE_VERT ), loadResource( RES_QUAKE_FRAG ) );
mCounter = 0.0f;
mCurrentFrame = 0;
mSaveFrames = false;
mShowEarth = true;
mShowText = true;
mShowQuakes = true;
mLightDir = vec3( 0.025f, 0.25f, 1.0f );
mLightDir.normalize();
mPov = POV( this, ci::vec3( 0.0f, 0.0f, 1000.0f ), ci::vec3( 0.0f, 0.0f, 0.0f ) );
mEarth = Earth( earthDiffuse, earthNormal, earthMask );
parseEarthquakes( "http://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_week.geojson" );
mEarth.setQuakeLocTip();
}
bool triangle3<T>::is_front_facing(const vec3<T>& lookDirection) const
{
const vec3<T> n = get_normal();
n.normalize();
const T d = dot(n, lookDirection);
return F32_LOWER_EQUAL_0(d);
}
vec3 randomCirclePoint(vec3 normal) {
//generate random sphere points and then change the z components so that the
//points are perpendicular to the normal
normal.normalize();
vec3 point = randomSpherePoint();
point[2] = -(point[0]*normal[0] + point[1]*normal[1]) / normal[2];
return point;
}
Triangle::Triangle(vec3 v1,vec3 v2, vec3 v3, vec3 n1, vec3 n2, vec3 n3, Material material, Transformation& transformation) {
this->transform = transformation.transform;
this->transformI = transformation.transformI;
this->transformTI = transformation.transformTI;
this->v1 = v1;
this->v2 = v2;
this->v3 = v3;
this->material = material;
this->isSphere=false;
this->n1 = n1.normalize();
this->n2 = n2.normalize();
this->n3 = n3.normalize();
}
void draw_stuff(const controls& c, float density)
{
float mx = c.m_mouse_x - 500.0f;
float my = 500.0f - c.m_mouse_y;
vec3 mouse_pos(mx, my, 0);
if (c.m_mouse_right)
{
// Re-compute light direction.
s_light_direction = mouse_pos - s_light_arrow_spot;
s_light_direction.normalize();
// Direction perpendicular to the light.
s_light_right = vec3(s_light_direction.y, -s_light_direction.x, 0);
// Draw a white line to the mouse, so the user can see
// what they're orbiting around.
glColor3f(1, 1, 1);
draw_segment(s_light_arrow_spot, mouse_pos);
}
if (c.m_mouse_left_click)
{
// Add or delete an occluder.
// If we're on an occluder, then delete it.
bool deleted = false;
for (int i = 0; i < s_occluders.size(); i++)
{
if (s_occluders[i].hit(mouse_pos))
{
// Remove this guy.
s_occluders[i] = s_occluders.back();
s_occluders.resize(s_occluders.size() - 1);
deleted = true;
break;
}
}
if (!deleted)
{
// If we didn't delete, then the user want to
// add an occluder.
s_occluders.push_back(occluder(mouse_pos, 20));
}
}
draw_light_arrow();
draw_light_rays(density);
draw_occluders();
// Draw a line at the "near clip plane".
glColor3f(0, 0, 1);
draw_segment(vec3(-1000, s_viewer_y, 0), vec3(1000, s_viewer_y, 0));
draw_frustum();
}
color sample(PosNormal point)
{
vec3 n = point.n;
n.normalize();
direction.normalize();
float k = n.x*direction.x + n.y*direction.y + n.z*direction.z;
k = k < 0.0f ? 0.0f : k;
return{ col.r*k, col.g*k, col.b*k, 1.0f };
}
void Model::Rotate( float angle, vec3 vector) {
vector.normalize();
float d=sqrt(vector.y*vector.y+vector.z*vector.z);
Matrix m1, m2, m3, m4;
m1.init(), m2.init(), m3.init(), m4.init();
if(d>=1e-10) {
m4.mat[5]=vector.z/d;
m4.mat[6]=vector.y/d;
m4.mat[9]=-vector.y/d;
m4.mat[10]=vector.z/d;
m3.mat[0]=d;
m3.mat[2]=vector.x;
m3.mat[8]=-vector.x;
m3.mat[10]=d;
m1.mat[5]=m4.mat[5];
m1.mat[6]=-m4.mat[6];
m1.mat[9]=-m4.mat[9];
m1.mat[10]=m4.mat[10];
m2.mat[0]=m3.mat[0];
m2.mat[2]=-m3.mat[2];
m2.mat[8]=-m3.mat[8];
m2.mat[10]=m3.mat[10];
m3.MultiMatrix(m4);
m1.MultiMatrix(m2);
m2.init();
m2.mat[0]=cos(angle);
m2.mat[4]=-sin(angle);
m2.mat[1]=sin(angle);
m2.mat[5]=cos(angle);
m1.MultiMatrix(m2);
m1.MultiMatrix(m3);
md_mat.MultiMatrix(m1);
}
else {
m3.mat[0]=d;
m3.mat[2]=vector.x;
m3.mat[8]=-vector.x;
m3.mat[10]=d;
m1.mat[0]=m3.mat[0];
m1.mat[2]=-m3.mat[2];
m1.mat[8]=-m3.mat[8];
m1.mat[10]=m3.mat[10];
m2.mat[0]=cos(angle);
m2.mat[4]=-sin(angle);
m2.mat[1]=sin(angle);
m2.mat[5]=cos(angle);
m1.MultiMatrix(m2);
m1.MultiMatrix(m3);
md_mat.MultiMatrix(m1);
}
}
//--------------------------------------------------------------------------------
// get target look at
//--------------------------------------------------------------------------------
bool zz_camera_follow::get_target_dir (vec3& dir)
{
if (!target_) {
dir.set(0, 1, 0);
return false;
}
dir = target_->get_look_at();
dir.normalize();
return true;
}
// Multiplying a quaternion q with a vector v applies the q-rotation to v
vec3 tgQuaternion::operator* (vec3 v){
v.normalize();
tgQuaternion vecQuat, resQuat;
vecQuat.x = v.x;
vecQuat.y = v.y;
vecQuat.z = v.z;
vecQuat.w = 0.0f;
resQuat = vecQuat * getConjugate();
resQuat = *this * resQuat;
return (vec3(resQuat.x, resQuat.y, resQuat.z));
}
void
tgPose::RotateAxis (vec3 r)
{
// tgQuaternion q2;
// q2.fromEuler(rot.x,rot.y,rot.z);
// q = q2 * q;
// q.normalise();
tgQuaternion q2;
float a = r.length ();
r.normalize ();
q2.fromAxis (r, a);
q = q2 * q;
q.normalise ();
}
// Use Rodriques formula
mat3 getRotationMatrix(vec3 axis, double angle)
{
mat3 R = mat3(vec3(1,0,0),vec3(0,1,0),vec3(0,0,1));
axis = axis.normalize();
for (int i = 0; i < 3; ++i)
{
vec3 currCol = R.col(i);
//currCol = (currCol * cos(angle)) + (mAxis.cross(currCol) * sin(angle)) + (Mat(mAxis_t * currCol).at<double>(0,0) * (1 - cos(angle)) * mAxis);
currCol = (currCol * cos(angle)) + ((axis ^ currCol) * sin(angle)) + ((axis * currCol) * (1 - cos(angle)) * axis);
R[0][i] = currCol[0];
R[1][i] = currCol[1];
R[2][i] = currCol[2];
}
return R;
}
void mat4::createRotation(vec3 axis, float rad)
{
axis.normalize();
float cosine = cos(rad);
float sine = sin(rad);
elements[0] = cosine + pow(axis.x, 2)*(1-cosine);
elements[1] = axis.x*axis.y*(1 - cosine) - axis.z*sine;
elements[2] = axis.x*axis.z*(1 - cosine) + axis.y*sine;
elements[4] = axis.y*axis.x*(1 - cosine) + axis.z*sine;
elements[5] = cosine + pow(axis.y, 2)*(1 - cosine);
elements[6] = axis.z*axis.y*(1 - cosine) - axis.x*sine;
elements[8] = axis.x*axis.z*(1 - cosine) - axis.y*sine;
elements[9] = axis.z*axis.y*(1 - cosine) + axis.x*sine;
elements[10] = cosine + pow(axis.z, 2)*(1 - cosine);
elements[15] = 1.0f;
}
bool World::intersect(Ray & r, double & bestT, vec3 &outn, MaterialInfo &outm) {
double thisT;
Ray w2mRay;
bestT = numeric_limits<double>::infinity();
for (vector<Sphere>::iterator it = _spheres.begin();it != _spheres.end();it++) {
w2mRay = Ray(r);
w2mRay.transform(it->w2m());
thisT = it->intersect(w2mRay);
if (thisT<bestT && thisT>=0){
vec4 p = w2mRay.getPos(thisT);
outn = vec3(it->w2m().transpose() * it->calculateNormal(p),VW);
outn.normalize();
outm = it->getMaterial();
bestT = thisT;
}
}
return bestT < numeric_limits<double>::infinity();
}
mat33 getMatrix(vec3 vec, double alpha)
{
mat33 res;
mat33 I;
for(int i=0;i<3;++i){
for(int j=0;j<3;++j){
I(i,j)=(i==j)?1.0:.0;
}
}
vec.normalize();
mat33 E=crossProductMat(vec);
//print(E);
//print(I);
//std::cout<<vec.transpose()<<"\n";
res=cos(alpha)*I+(1-cos(alpha))*vec*vec.transpose()-sin(alpha)*E;
return res;
}
/////////////////////////////////////////////////////////////////////
// get the closest point to pt in the primative
bool
sphere::
closestPtIn ( vec3& dest, ValueType xval, ValueType yval, ValueType zval ) const
{
if ( isEmpty () )
return false;
if ( contains ( xval, yval, zval ) )
dest.set ( xval, yval, zval );
else
{
dest.set ( xval, yval, zval );
dest -= center;
dest.normalize ();
dest *= radius;
dest += center;
}
return true;
}
mat4 rotation3Drad(vec3& Axis, const double angleRad) {
double c = cos(angleRad),
s = sin(angleRad),
t = 1.0 - c;
Axis.normalize();
return mat4(vec4(t * Axis[VX] * Axis[VX] + c,
t * Axis[VX] * Axis[VY] - s * Axis[VZ],
t * Axis[VX] * Axis[VZ] + s * Axis[VY],
0.0),
vec4(t * Axis[VX] * Axis[VY] + s * Axis[VZ],
t * Axis[VY] * Axis[VY] + c,
t * Axis[VY] * Axis[VZ] - s * Axis[VX],
0.0),
vec4(t * Axis[VX] * Axis[VZ] - s * Axis[VY],
t * Axis[VY] * Axis[VZ] + s * Axis[VX],
t * Axis[VZ] * Axis[VZ] + c,
0.0),
vec4(0.0, 0.0, 0.0, 1.0));
}
void getRayFromMouse(vec2 mouse, vec3 &start, vec3 &dir) {
int viewport[4];
double modelview[16], projection[16];
glGetIntegerv(GL_VIEWPORT, viewport); // Retrieves The Viewport Values (X, Y, Width, Height)
glGetDoublev(GL_MODELVIEW_MATRIX, modelview); // Retrieve The Modelview Matrix
glGetDoublev(GL_PROJECTION_MATRIX, projection); // Retrieve The Projection Matrix
int mx = (int)mouse[0];
int my = (int)mouse[1];
my = viewport[3] - my; // convert to opengl's coordinates (y axis from bottom left)
double sx,sy,sz;
gluUnProject((float)mx, (float)my, 0, modelview, projection, viewport, &sx, &sy, &sz);
double ex,ey,ez;
gluUnProject((float)mx, (float)my, .3, modelview, projection, viewport, &ex, &ey, &ez);
start = vec3(sx,sy,sz);
vec3 end(ex, ey, ez);
dir = end-start;
dir.normalize();
}
void EnvironmentRender::reflection(vec3 pos, vec3 nor, f32 dis, gchandle tex)
{
kgmCamera cam;
vec3 cpos = gr->m_camera->mPos;
vec3 cdir = gr->m_camera->mDir;
f32 fov = gr->m_camera->mFov;
f32 asp = gr->m_camera->mAspect;
f32 zfar = gr->m_camera->mFar;
f32 zner = gr->m_camera->mNear;
cpos.z *= -1;
cdir.z *= -1;
cam.set(fov, asp, zner, zfar, cpos, cdir, vec3(0, 0, 1));
kgmGraphics::Options o;
o.width = 512;
o.height = 512;
o.clipping = true;
o.light = false;
nor.normalize();
plane plane(nor, pos);
o.plane[0] = plane.x;
o.plane[1] = plane.y;
o.plane[2] = plane.z;
o.plane[3] = plane.w;
o.discard = m_discard;
gc->gcTexTarget(m_target, tex, gctype_tex2d);
gc->gcSetTarget(m_target);
gr->render(cam, o);
gc->gcSetTarget(null);
}
mat4 mat4::RotationMatrix(vec3 axis,double angle)
{
const float MATH_PI = 3.141592653f;
float rad = angle*MATH_PI/180.0f;
mat4 R;
axis.normalize();
double x=axis.X;
double y = axis.Y;
double z = axis.Z;
double c = cos(rad);
double s = sin(rad);
R.m_Mat[0][0] = x*x*(1-c)+c;
R.m_Mat[0][1] = x*y*(1-c)-z*s;
R.m_Mat[0][2] = x*z*(1-c)+y*s;
R.m_Mat[1][0] = y*x*(1-c)+z*s;
R.m_Mat[1][1] = y*y*(1-c)+c;
R.m_Mat[1][2] = y*z*(1-c)-x*s;
R.m_Mat[2][0] = z*x*(1-c)-y*s;
R.m_Mat[2][1] = z*y*(1-c)+x*s;
R.m_Mat[2][2] = z*z*(1-c)+c;
return R;
}
ray3(const T* coords): p0(coords), u(coords + 3) {
u.normalize();
}
plane3(T v0x, T v0y, T v0z, T norm_x, T norm_y, T norm_z): v0(v0x, v0y, v0z), n(norm_x, norm_y, norm_z) {
n.normalize();
}
ray3(T p0x, T p0y, T p0z, T ux, T uy, T uz): u(ux, uy, uz), p0(p0x, p0y, p0z) {
u.normalize();
}
ray3(vec3<T> &p0, vec3<T> &u): u(u), p0(p0) {
u.normalize();
}
plane3(const T* coords): v0(coords), n(coords + 3) {
n.normalize();
}
void missil::setDirection(vec3 d)
{
this->direction = d.normalize();
}
plane3(vec3<T> &v0, vec3<T> &norm): n(norm), v0(v0) {
n.normalize();
}
