void set_matrix_item(float *matrix, int width, int height) {
float a[16];
float b[16];
float aspect = (float)width / height;
float size = 64;
float box = height / size / 2;
float xoffset = 1 - size / width * 2;
float yoffset = 1 - size / height * 2;
mat_identity(a);
mat_rotate(b, 0, 1, 0, -PI / 4);
mat_multiply(a, b, a);
mat_rotate(b, 1, 0, 0, -PI / 10);
mat_multiply(a, b, a);
mat_ortho(b, -box * aspect, box * aspect, -box, box, -1, 1);
mat_multiply(a, b, a);
mat_translate(b, -xoffset, -yoffset, 0);
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
static void
Redisplay(void)
{
GLfloat rot[4][4];
GLfloat trans[16], mvp[16];
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
/* Build the modelview * projection matrix */
build_rotmatrix(rot, CurQuat);
mat_translate(trans, 0, 0, -10);
mat_multiply(mvp, trans, (GLfloat *) rot);
mat_multiply(mvp, Projection, mvp);
/* Set the MVP matrix */
glUniformMatrix4fv(uModelViewProj, 1, GL_FALSE, (float *) mvp);
/* Draw */
glDrawArrays(GL_TRIANGLES, 0, 3);
glutSwapBuffers();
}
void make_player(
float *data,
float x, float y, float z, float rx, float ry)
{
float ao[6][4] = {0};
make_cube_faces(
data, ao,
1, 1, 1, 1, 1, 1,
226, 224, 241, 209, 225, 227,
0, 0, 0, 0.4);
float ma[16];
float mb[16];
mat_identity(ma);
mat_rotate(mb, 0, 1, 0, rx);
mat_multiply(ma, mb, ma);
mat_rotate(mb, cosf(rx), 0, sinf(rx), -ry);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 36, 3, 9);
mat_translate(mb, x, y, z);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 36, 0, 9);
}
void palImpulseActuator::Apply()
{
palMatrix4x4 m;
mat_identity(&m);
mat_translate(&m,m_fRelativePosX,m_fRelativePosY,m_fRelativePosZ);
//printf("rel:%f %f %f ",m._41,m._42,m._43);
palMatrix4x4 bodypos = m_pBody->GetLocationMatrix();
palMatrix4x4 out;
mat_multiply(&out,&bodypos,&m);
palVector3 newpos;
newpos.x=out._41;
newpos.y=out._42;
newpos.z=out._43;
// printf("output : %f %f %f ",out._41,out._42,out._43);
// imp_pos=out;
mat_identity(&m);
mat_translate(&m,m_fAxisX,m_fAxisY,m_fAxisZ);
mat_multiply(&out,&bodypos,&m);
// printf("output : %f %f %f\n",out._41,out._42,out._43);
// imp_axis=out;
palVector3 newaxis;
newaxis.x=out._41-bodypos._41;
newaxis.y=out._42-bodypos._42;
newaxis.z=out._43-bodypos._43;
vec_norm(&newaxis);
m_pBody->ApplyImpulseAtPosition(newpos.x,newpos.y,newpos.z,newaxis.x*m_fImpulse,newaxis.y*m_fImpulse,newaxis.z*m_fImpulse);
}
void update_matrix_item(float *matrix) {
float a[16];
float b[16];
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
float aspect = (float)width / height;
float size = 64;
float box = height / size / 2;
float xoffset = 1 - size / width * 2;
float yoffset = 1 - size / height * 2;
mat_identity(a);
mat_rotate(b, 0, 1, 0, PI / 4);
mat_multiply(a, b, a);
mat_rotate(b, 1, 0, 0, -PI / 10);
mat_multiply(a, b, a);
mat_ortho(b, -box * aspect, box * aspect, -box, box, -1, 1);
mat_multiply(a, b, a);
mat_translate(b, -xoffset, -yoffset, 0);
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
void mat_translate(matrix4 m, vector3 v)
{
matrix4 m2;
m2[0][0] =
m2[1][1] =
m2[2][2] =
m2[3][3] = 1.0f;
m2[0][1] =
m2[0][2] =
m2[0][3] =
m2[1][0] =
m2[1][2] =
m2[1][3] =
m2[2][0] =
m2[2][1] =
m2[2][3] = 0.0f;
m2[3][0] = v[0];
m2[3][1] = v[1];
m2[3][2] = v[2];
mat_multiply(m, m2);
}
void palPropeller::Apply() {
palMatrix4x4 m;
mat_identity(&m);
mat_translate(&m,m_fRelativePosX,m_fRelativePosY,m_fRelativePosZ);
//printf("rel:%f %f %f ",m._41,m._42,m._43);
palMatrix4x4 bodypos = m_pBody->GetLocationMatrix();
palMatrix4x4 out;
mat_multiply(&out,&bodypos,&m);
palVector3 newpos;
newpos.x=out._41;
newpos.y=out._42;
newpos.z=out._43;
if (newpos.y > 0.1f ) return;
Float thrust = m_Voltage*m_a_l;
SetImpulse(thrust);
palImpulseActuator::Apply();
}
void make_cube(
float *data, float ao[6][4], float light[6][4],
int left, int right, int top, int bottom, int front, int back,
float x, float y, float z, float n, int w, const int blocks[256][6])
{
int wleft = blocks[w][0];
int wright = blocks[w][1];
int wtop = blocks[w][2];
int wbottom = blocks[w][3];
int wfront = blocks[w][4];
int wback = blocks[w][5];
make_cube_faces(
data, ao, light,
left, right, top, bottom, front, back,
wleft, wright, wtop, wbottom, wfront, wback,
n);
float ma[16];
float mb[16];
mat_identity(ma);
mat_translate(mb, x, y, z);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, (left + right + top + bottom + front + back)*6, 0, 10);
}
void palForceActuator::Apply() {
palMatrix4x4 m,resp;
mat_identity(&m);
mat_translate(&m,m_fRelativePosX,m_fRelativePosY,m_fRelativePosZ);
palMatrix4x4 bodypos = m_pBody->GetLocationMatrix();
mat_multiply(&resp,&m,&bodypos); //the acting force points resulting position.
palVector3 tpos,respos;
tpos.x=resp._41; tpos.y=resp._42; tpos.z=resp._43;
vec_mat_mul(&respos,&bodypos,&tpos);
//printf("body is at : %f %f %f\n",bodypos._41,bodypos._42,bodypos._43);
//printf("forcepoint is at: %f %f %f\n",respos.x,respos.y,respos.z);
palVector3 axis,resaxis;
axis.x=m_fAxisX; axis.y=m_fAxisY; axis.z=m_fAxisZ;
//printf("axis was: %f %f %f\n",axis.x,axis.y,axis.z);
vec_mat_mul(&resaxis,&bodypos,&axis);
//printf("axis is: %f %f %f\n",resaxis.x,resaxis.y,resaxis.z);
//printf("forcepoint is at: %f %f %f\n",resp._41,resp._42,resp._43);
//m_pBody->AddForceAtPosition(respos.x,respos.y,respos.z,resaxis.x*m_fForce,resaxis.y*m_fForce,resaxis.z*m_fForce);
//m_pBody->AddForceAtPosition(respos.x,respos.y,respos.z,axis.x*m_fForce,axis.y*m_fForce,axis.z*m_fForce);
m_pBody->ApplyForceAtPosition(tpos.x,tpos.y,tpos.z,axis.x*m_fForce,axis.y*m_fForce,axis.z*m_fForce);
//m_pBody->AddForceAtPosition(1,1,0,axis.x*m_fForce,axis.y*m_fForce,axis.z*m_fForce);
}
void set_matrix_item_r(float *matrix, int width, int height, float scale,
float xoffset, float yoffset, float rx, float ry, float rz) {
float a[16];
float b[16];
float aspect = (float)width / height;
float size = 64 * scale;
float box = height / size / 2;
mat_identity(a);
mat_rotate(b, 0, 1, 0, rx);
mat_multiply(a, b, a);
mat_rotate(b, 1, 0, 0, ry);
mat_multiply(a, b, a);
mat_rotate(b, 0, 0, 1, rz);
mat_multiply(a, b, a);
mat_ortho(b, -box * aspect, box * aspect, -box, box, -3, 2);
mat_multiply(a, b, a);
mat_translate(b, -xoffset, -yoffset, 0);
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
void
summa_mult (int m, int n, int k, int s_max,
const double* A_local, const double* B_local,
double* C_local, MPI_Comm comm2d,
double* p_t_comp, double* p_t_comm)
{
int rank = mpih_getRank (comm2d);
int P_row, P_col;
summa_getProcSize (comm2d, &P_row, &P_col);
int rank_row, rank_col;
summa_getProcCoords (comm2d, &rank_row, &rank_col);
MPI_Comm comm_row = getCommRow__ (comm2d);
MPI_Comm comm_col = getCommCol__ (comm2d);
int m_local, n_local;
summa_getMatDims (m, n, comm2d, &m_local, &n_local);
double* A_strip = (double *)malloc (m_local * s_max * sizeof (double));
double* B_strip = (double *)malloc (s_max * n_local * sizeof (double));
mpih_assert (A_strip && B_strip);
double t_comp = 0, t_comm = 0; /* Time in computation vs. communication */
int iter_k = 0; /* iterates over strips in k dimension */
int owner_A = 0; /* owner of current A strip */
int owner_B = 0; /* owner of current B strip */
while (iter_k < k) {
int k_start_A = mm1d_getBlockStart (k, P_col, owner_A);
int k_local_A = mm1d_getBlockLength (k, P_col, owner_A);
int k_start_B = mm1d_getBlockStart (k, P_row, owner_B);
int k_local_B = mm1d_getBlockLength (k, P_row, owner_B);
/* Determine a strip width, s, that still resides in both the
current A and B blocks. */
int s = min_int (s_max, min_int (k_start_A + k_local_A - iter_k,
k_start_B + k_local_B - iter_k));
double t_start = MPI_Wtime (); /* For timing communication */
/* Step 1: Broadcast m_local x s strip of A */
/* === @@ YOUR CODE GOES HERE @@ === */
/* Step 2: Broadcast s x n_local strip of B */
/* === @@ YOUR CODE GOES HERE @@ === */
t_comm += MPI_Wtime () - t_start;
/* Step 3: Local multiply */
t_start = MPI_Wtime (); /* For timing computation */
mat_multiply (m_local, n_local, s,
A_strip, m_local, B_strip, s,
C_local, m_local);
t_comp += MPI_Wtime () - t_start;
iter_k += s;
if (iter_k >= k_start_A + k_local_A) ++owner_A;
if (iter_k >= k_start_B + k_local_B) ++owner_B;
}
/* Clean-up and return */
MPI_Comm_free (&comm_row);
MPI_Comm_free (&comm_col);
free (A_strip);
free (B_strip);
if (p_t_comp) *p_t_comp = t_comp;
if (p_t_comm) *p_t_comm = t_comm;
}
static
void
verify__ (int m, int n, int k)
{
MPI_Comm comm = MPI_COMM_WORLD;
if (!isEnvEnabled_mpi__ (comm, "VERIFY", 1)) return;
double* A = NULL;
double* B = NULL;
double* C_soln = NULL;
double* C_bound = NULL;
/* First, run the trusted sequential version */
int rank = mpih_getRank (comm);
if (rank == 0) {
setupSeqProblem__ (m, n, k, &A, &B, &C_soln, &C_bound);
/* Measure time for the sequential problem. */
mat_setZero (m, n, C_soln);
double t_start = MPI_Wtime ();
mat_multiply (m, n, k, A, m, B, k, C_soln, m);
double dt_seq = MPI_Wtime () - t_start;
mpih_debugmsg (comm, "t_seq = %g s\n", dt_seq);
/* Recompute, to get the error bound this time */
mpih_debugmsg (MPI_COMM_WORLD, "Estimating error bound...\n");
mat_multiplyErrorbound (m, n, k, A, m, B, k, C_soln, m, C_bound, m);
}
/* Next, run the untrusted 1D algorithm */
if (rank == 0) mpih_debugmsg (comm, "Distributing A, B, and C...\n");
double* A_local = mm1d_distribute (m, k, A, comm);
double* B_local = mm1d_distribute (k, n, B, comm);
double* C_local = mm1d_alloc (m, n, comm);
mm1d_setZero (m, n, C_local, comm);
/* Do multiply */
if (rank == 0) mpih_debugmsg (comm, "Computing C <- C + A*B...\n");
mm1d_mult (m, n, k, A_local, B_local, C_local, comm, NULL, NULL);
/* Compare the two answers (in parallel) */
if (rank == 0) mpih_debugmsg (comm, "Verifying...\n");
int P = mpih_getSize (comm);
double* C_soln_local = mm1d_distribute (m, n, C_soln, comm);
double* C_bound_local = mm1d_distribute (m, n, C_bound, comm);
for (int i = 0; i < m; ++i) {
int n_local = mm1d_getBlockLength (n, P, rank);
for (int j = 0; j < n_local; ++j) {
const double errbound = C_bound_local[i + j*m] * 3.0 * k * DBL_EPSILON;
const double c_trusted = C_soln_local[i + j*m];
const double c_untrusted = C_local[i + j*m];
double delta = fabs (c_untrusted - c_trusted);
if (delta > errbound)
mpih_debugmsg (comm,
"*** Entry (%d, %d) --- Error bound violated ***\n ==> |%g - %g| == %g > %g\n",
c_untrusted, c_trusted, delta, errbound, i, j);
mpih_assert (delta <= errbound);
}
}
if (rank == 0) mpih_debugmsg (comm, "Passed!\n");
/* Cleanup */
if (rank == 0) {
free (A);
free (B);
free (C_soln);
free (C_bound);
}
mm1d_free (A_local, comm);
mm1d_free (B_local, comm);
mm1d_free (C_local, comm);
}
void palFakeBuoyancy::Apply() {
palMatrix4x4 m;
m=m_pBody->GetLocationMatrix();
palBoxGeometry *pbg;
pbg = dynamic_cast<palBoxGeometry *>(m_pBody->m_Geometries[0]);
if (pbg ){
/*
float box_height = pbg->m_fHeight;
if (m._42 < box_height) {
float hunder = box_height - m._42; //how much of the box's height is under water?
if (hunder > box_height) hunder = box_height; //maximum is box height
float volume = pbg->m_fWidth*pbg->m_fDepth * hunder;
float gravity = 9.8f;
float fb = volume * gravity * m_density;
m_pBody->AddForce(0,fb,0);
}
*/
Float volume = pbg->m_fWidth*pbg->m_fDepth * pbg->m_fHeight;
Float quatervolume = volume/4;
Float quatersphereradius = (Float) pow((3/4.0)*quatervolume / M_PI,1/3.0);
Float r = quatersphereradius;
//r = pbg->m_fHeight
palMatrix4x4 m;
palMatrix4x4 bodypos = m_pBody->GetLocationMatrix();
palMatrix4x4 out;
mat_identity(&m);
mat_translate(&m,pbg->m_fWidth*0.5f,0,0);
mat_multiply(&out,&bodypos,&m);
m_pBody->ApplyForceAtPosition(out._41,out._42,out._43,0,
CalcSphereForce(r,out._42,m_density),0);
// CalcSphereForce(pbg->m_fHeight,out._42,m_density,volume*0.5f),0);
mat_identity(&m);
mat_translate(&m,-pbg->m_fWidth*0.5f,0,0);
mat_multiply(&out,&bodypos,&m);
m_pBody->ApplyForceAtPosition(out._41,out._42,out._43,0,
CalcSphereForce(r,out._42,m_density),0);
// CalcSphereForce(pbg->m_fHeight,out._42,m_density,volume*0.5f),0);
//the following are the z-axis floats:
mat_identity(&m);
mat_translate(&m,0,0,pbg->m_fDepth*0.5f);
mat_multiply(&out,&bodypos,&m);
m_pBody->ApplyForceAtPosition(out._41,out._42,out._43,0,
CalcSphereForce(r,out._42,m_density),0);
mat_identity(&m);
mat_translate(&m,0,0,-pbg->m_fDepth*0.5f);
mat_multiply(&out,&bodypos,&m);
m_pBody->ApplyForceAtPosition(out._41,out._42,out._43,0,
CalcSphereForce(r,out._42,m_density),0);
}
palSphereGeometry *psg;
psg = dynamic_cast<palSphereGeometry *>(m_pBody->m_Geometries[0]);
if (psg) {
m_pBody->ApplyForce(0,
CalcSphereForce(psg->m_fRadius,m._42,m_density),0);
/*
float sphere_radius = psg->m_fRadius;
if (m._42 < sphere_radius*2) {
float hunder = sphere_radius*2 - m._42; //how much of the box's height is under water?
if (hunder > sphere_radius*2) hunder = sphere_radius*2; //maximum is box height
//float volume = sphere_radius*sphere_radius * hunder; //wrong wrong wrong.
float volume = M_PI * hunder * (3 * sphere_radius * hunder - hunder*hunder) / 3.0f;
float gravity = 9.8f;
float fb = volume * gravity * m_density;
m_pBody->AddForce(0,fb,0);
}
*/
}
}
void sc_light_updateSpotMtx(ENTITY* inLight)
{
SC_OBJECT* ObjData = (SC_OBJECT*)(inLight.SC_SKILL);
float fTexAdj[16] =
{ 0.5, 0.0, 0.0, 0.0,
0.0,-0.5, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0 };
fTexAdj[12] = 0.5 + ((float)0.5/(float)256);
fTexAdj[13] = 0.5 + ((float)0.5/(float)256);
VECTOR lightDir;
//lightDir = malloc(sizeof(VECTOR));
if(inLight.tilt > 89.9 && inLight.tilt < 90.1 || inLight.tilt < -89.9 && inLight.tilt > -90.1)
{
vec_set(lightDir, inLight.pan);
lightDir.y += 0.2;
vec_for_angle(lightDir,lightDir);
}
else vec_for_angle(lightDir, inLight.pan);
sc_skill(inLight, SC_OBJECT_LIGHT_DIR, lightDir);
//if(lightDir.y == -90) lightDir.y = 80; //might have to comment this in again (?)
/*
//if spotlight has a shadowview attached
if(ObjData.light.view != NULL)
{
D3DXMATRIX matView_, matProj_;
view_to_matrix(ObjData.light.view, &matView_, &matProj_);
mat_multiply(&matView_, &matProj_);
mat_multiply(&matView_, fTexAdj);
sc_skill(inLight, SC_OBJECT_LIGHT_MATRIX, &matView_);
ptr_remove(matView_);
ptr_remove(matProj_);
return;
}
*/
//create lightViewMatrix
D3DXVECTOR3 vEyePt;
D3DXVECTOR3 vLookatPt;
D3DXVECTOR3 vUpVec;
//vEyePt = sys_malloc(sizeof(D3DXVECTOR3));
//vLookatPt = sys_malloc(sizeof(D3DXVECTOR3));
//vUpVec = sys_malloc(sizeof(D3DXVECTOR3));
vEyePt.x = inLight.x;
vEyePt.y = inLight.z;
vEyePt.z = inLight.y;
vLookatPt.x = inLight.x + lightDir.x;
vLookatPt.y = inLight.z + lightDir.z;
vLookatPt.z = inLight.y + lightDir.y;
vUpVec.x = 0;
vUpVec.y = 1;
vUpVec.z = 0;
D3DXMATRIX mtxLightView;
//mtxLightView = sys_malloc(sizeof(D3DXMATRIX));
D3DXMatrixLookAtLH( &mtxLightView, vEyePt, vLookatPt, vUpVec);
//create lightProjectionMatrix
D3DXMATRIX mtxLightProj;
D3DXMatrixPerspectiveFovLH(&mtxLightProj, (((float)ObjData.light.arc/(float)180))*SC_PI, (float)1, (float)1, (float)ObjData.light.range );
//pass projection matrix to light
D3DXMATRIX mtxLightWorldViewProj;
//mtxLightWorldViewProj = sys_malloc(sizeof(D3DXMATRIX));
mat_set(&mtxLightWorldViewProj, &mtxLightView);
mat_multiply(&mtxLightWorldViewProj, &mtxLightProj);
mat_multiply(&mtxLightWorldViewProj, fTexAdj);
sc_skill(inLight, SC_OBJECT_LIGHT_MATRIX, &mtxLightWorldViewProj);
/*
//this lags like hell
sys_free(vEyePt);
sys_free(vLookatPt);
sys_free(vUpVec);
sys_free(mtxLightView);
sys_free(mtxLightProj);
sys_free(mtxLightWorldViewProj);
*/
//better
ptr_remove(vEyePt);
ptr_remove(vLookatPt);
ptr_remove(vUpVec);
ptr_remove(mtxLightView);
ptr_remove(mtxLightProj);
ptr_remove(mtxLightWorldViewProj);
}
void example_matrix_utilities() {
// Run this and look at stdout to see examples using the multi-dimensional matrix.
// Note: MatrixF is a typedef for Matrix<float>
cout << "Matrix utility examples." << endl;
cout << "// 3 x 4 matrix, initialized to 0." << endl;
cout << "MatrixF X(3,4);" << endl;
MatrixF X(3,4);
cout << "cout << X << endl;" << endl;
cout << X << endl;
cout << "// Create range of values in X." << endl;
cout << "float i = 0;" << endl;
float i = 0;
cout << "// Fill up X." << endl;
cout << R"(apply_sequential(X, [&] (float a) {
// Ignore the value of a.
i += 0.1f;
return i;
});)" << endl;
apply_sequential(X, [&] (float a) {
// Ignore the value of a.
i += 0.1f;
return i;
});
cout << "cout << X << endl;" << endl;
cout << X << endl;
cout << "// Apply sqrt() to all elements in X." << endl;
cout << R"(apply(X, [] (float a) {
return std::sqrt(a);
});)" << endl;
apply(X, [] (float a) {
return std::sqrt(a);
});
cout << "cout << X << endl;" << endl;
cout << X << endl;
cout << "MatrixF Y(4,5);" << endl;
MatrixF Y(4,5);
cout << "cout << Y << endl;" << endl;
cout << Y << endl;
cout << "i = 0;" << endl;
i = 0;
cout << R"(apply_sequential(Y, [&] (float a) {
// Ignore the value of a.
i += 1.0f;
return i;
});)" << endl;
apply_sequential(Y, [&] (float a) {
// Ignore the value of a.
i += 1.0f;
return i;
});
cout << endl << "// map2() example:" << endl;
cout << "cout << Y << endl;" << endl;
cout << Y << endl;
cout << "MatrixF A = Y;" << endl;
MatrixF A = Y;
cout << "cout << A << endl;" << endl;
cout << A << endl;
cout << "MatrixF B = Y;" << endl;
MatrixF B = Y;
cout << "cout << B << endl;" << endl;
cout << B << endl;
cout << "// Apply map2(): " << endl;
cout << R"(map2(Y, A, B, [] (float a, float b) {
return a + 2*b;
});)" << endl << endl;
map2(Y, A, B, [] (float a, float b) {
return a + 2*b;
});
cout << "cout << Y << endl;" << endl;
cout << Y << endl;
cout << "// narrow() example:" << endl;
i = 0;
cout << R"(apply_sequential(Y, [&] (float a) {
// Ignore the value of a.
i += 1.0f;
return i;
});)" << endl;
apply_sequential(Y, [&] (float a) {
// Ignore the value of a.
i += 1.0f;
return i;
});
cout << "cout << Y << endl;" << endl;
cout << Y << endl;
cout << "MatrixF D = narrow(Y, 1, 1, 2);" << endl;
MatrixF D = narrow(Y, 1, 1, 2);
cout << "cout << D << endl;" << endl;
cout << D << endl;
cout << "// Now randomize D:" << endl;
cout << "randomize_normal(D, 1.0f, 1.0f);" << endl;
randomize_normal(D, 1.0f, 1.0f);
cout << "cout << D << endl;" << endl;
cout << D << endl;
cout << "// Now copy data from D back into same locations in Y:" << endl;
cout << "reverse_narrow(D, Y, 1, 1, 2);" << endl;
reverse_narrow(D, Y, 1, 1, 2);
cout << "cout << Y << endl;" << endl;
cout << Y << endl;
cout << "// Matrix multilication example:" << endl;
cout << "MatrixF U(3,4);" << endl;
MatrixF U(3,4);
cout << "cout << U << endl;" << endl;
cout << U << endl;
cout << "randomize_uniform(U, -1.0f, 1.0f);" << endl;
randomize_uniform(U, -1.0f, 1.0f);
cout << "cout << U << endl;" << endl;
cout << U << endl;
cout << "MatrixF R(4,5);" << endl;
MatrixF R(4,5);
cout << "cout << R << endl;" << endl;
cout << R << endl;
cout << "set_value(R, 1.0f);" << endl;
set_value(R, 1.0f);
cout << "cout << R << endl;" << endl;
cout << R << endl;
cout << "// Compute C = U*R:" << endl;
cout << "MatrixF C;" << endl;
MatrixF C;
cout << "// Note: C has not been initialized to the required output dimensions but will be " << endl;
cout << "// resized to the correct dimensions inside the matrix multiplication function." << endl;
cout << "// Many of the matrix utility functions work like this (auto re-sizing of result)." << endl;
cout << "mat_multiply(C, U, R);" << endl;
mat_multiply(C, U, R);
cout << "cout << C << endl;" << endl;
cout << C << endl;
}
void make_plant(
float *data, float ao, float light,
float px, float py, float pz, float n, int w, float rotation)
{
//四个面的顶点
static const float positions[4][4][3] = {
{{ 0, -1, -1}, { 0, -1, +1}, { 0, +1, -1}, { 0, +1, +1}},
{{ 0, -1, -1}, { 0, -1, +1}, { 0, +1, -1}, { 0, +1, +1}},
{{-1, -1, 0}, {-1, +1, 0}, {+1, -1, 0}, {+1, +1, 0}},
{{-1, -1, 0}, {-1, +1, 0}, {+1, -1, 0}, {+1, +1, 0}}
};
//x，z方向
static const float normals[4][3] = {
{-1, 0, 0},
{+1, 0, 0},
{0, 0, -1},
{0, 0, +1}
};
//贴图坐标
static const float uvs[4][4][2] = {
{{0, 0}, {1, 0}, {0, 1}, {1, 1}},
{{1, 0}, {0, 0}, {1, 1}, {0, 1}},
{{0, 0}, {0, 1}, {1, 0}, {1, 1}},
{{1, 0}, {1, 1}, {0, 0}, {0, 1}}
};
//索引
static const float indices[4][6] = {
{0, 3, 2, 0, 1, 3},
{0, 3, 1, 0, 2, 3},
{0, 3, 2, 0, 1, 3},
{0, 3, 1, 0, 2, 3}
};
float *d = data;
float s = 0.0625;
float a = 0;
float b = s;
float du = (plants[w] % 16) * s;
float dv = (plants[w] / 16) * s;
for (int i = 0; i < 4; i++) {
for (int v = 0; v < 6; v++) {
int j = indices[i][v];
*(d++) = n * positions[i][j][0];
*(d++) = n * positions[i][j][1];
*(d++) = n * positions[i][j][2];
*(d++) = normals[i][0];
*(d++) = normals[i][1];
*(d++) = normals[i][2];
*(d++) = du + (uvs[i][j][0] ? b : a);
*(d++) = dv + (uvs[i][j][1] ? b : a);
*(d++) = ao;
*(d++) = light;
}
}
float ma[16];
float mb[16];
mat_identity(ma);
mat_rotate(mb, 0, 1, 0, RADIANS(rotation));
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 24, 3, 10);
mat_translate(mb, px, py, pz);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 24, 0, 10);
}
static
void
verify__ (int m, int n, int k, int P_row, int P_col, int s)
{
if (!checkEnvEnabled__ ("VERIFY", 1)) return;
MPI_Comm comm2d = summa_createTopology (MPI_COMM_WORLD, P_row, P_col);
int rank = mpih_getRank (comm2d);
double* A = NULL;
double* B = NULL;
double* C_soln = NULL;
double* C_bound = NULL;
/* Whoever has rank == 0 will create the test problem. */
if (rank == 0) {
setupSeqProblem__ (m, n, k, &A, &B, &C_soln, &C_bound);
/* Measure time for the sequential problem. */
mat_setZero (m, n, C_soln);
double t_start = MPI_Wtime ();
mat_multiply (m, n, k, A, m, B, k, C_soln, m);
double dt_seq = MPI_Wtime () - t_start;
mpih_debugmsg (MPI_COMM_WORLD, "t_seq = %g s\n", dt_seq);
/* Recompute, to get the error bound this time */
mpih_debugmsg (MPI_COMM_WORLD, "Estimating error bound...\n");
mat_multiplyErrorbound (m, n, k, A, m, B, k, C_soln, m, C_bound, m);
}
/* Next, run the (untrusted) SUMMA algorithm */
if (rank == 0) mpih_debugmsg (comm2d, "Distributing A, B, and C...\n");
double* A_local = summa_distribute (m, k, A, 0, comm2d);
double* B_local = summa_distribute (k, n, B, 0, comm2d);
double* C_local = summa_alloc (m, n, comm2d);
summa_setZero (m, n, C_local, comm2d);
/* Do multiply */
if (rank == 0) mpih_debugmsg (comm2d, "Computing C <- C + A*B...\n");
summa_mult (m, n, k, s, A_local, B_local, C_local, comm2d, NULL, NULL);
/* Compare the two answers (in parallel) */
if (rank == 0) mpih_debugmsg (comm2d, "Verifying...\n");
int rank_row, rank_col;
summa_getProcCoords (comm2d, &rank_row, &rank_col);
double* C_soln_local = summa_distribute (m, n, C_soln, 0, comm2d);
double* C_bound_local = summa_distribute (m, n, C_bound, 0, comm2d);
int m_local = mm1d_getBlockLength (m, P_row, rank_row);
int n_local = mm1d_getBlockLength (n, P_col, rank_col);
for (int i = 0; i < m_local; ++i) {
for (int j = 0; j < n_local; ++j) {
const double errbound = C_bound_local[i + j*m_local] * 3.0 * k * DBL_EPSILON;
const double c_trusted = C_soln_local[i + j*m_local];
const double c_untrusted = C_local[i + j*m_local];
double delta = fabs (c_untrusted - c_trusted);
if (delta > errbound)
mpih_debugmsg (comm2d,
"*** Entry (%d, %d) --- Error bound violated ***\n ==> |%g - %g| == %g > %g\n",
c_untrusted, c_trusted, delta, errbound, i, j);
mpih_assert (delta <= errbound);
}
}
if (rank == 0) mpih_debugmsg (comm2d, "Passed!\n");
/* Clean-up */
summa_free (A_local, comm2d);
summa_free (B_local, comm2d);
summa_free (C_local, comm2d);
summa_free (C_soln_local, comm2d);
summa_free (C_bound_local, comm2d);
if (rank == 0) {
free (A);
free (B);
free (C_soln);
free (C_bound);
}
summa_freeTopology (comm2d);
}
