int cg(MAT &A,VEC b,VEC &x,int maxIter,double tol){
int n = A.dim();
int k = 0;
VEC x_next(n);
VEC r_next(n);
VEC p_next(n);
VEC r(n);
VEC p(n);
MAT L(n);
VEC cpr(n);
double alpha,beta;
double err;
double diff;
r = b - A*x; //initial condition
p = r;
while(k<maxIter){ //conjugate gradient decent
alpha = (r*r)/(p*(A*p));
x_next = x + alpha*p;
r_next = r - alpha*(A*p);
beta = (r_next*r_next)/(r*r);
p_next = r_next + beta*p;
k++;
x = x_next; //assign to the x,r,p of the next iteration
r = r_next;
p = p_next;
err = pow((r*r)/n,0.5);
if(err<tol) //see if the error is smaller than the defined tolerance. if so, break out of the loop
break;
}
diff = 0;
//the answer from hw4
L = cholesky(A); //in-place Cholesky Decomposition
cpr = choSolve(L,b); //solve the linear system by forward and backward substitution
//use the same method to compute the error between hw4 and hw5, see if < 10^-7. if not, decrease the tol
for(int i=0;i<n;i++){
diff = max(diff,fabs(x[i]-cpr[i])); //use infinity norm to compute the error
}
printf("error between hw4 and hw6(infinity-norm): %e\n",diff);
return k;
}
static void ShowEigs(const MAT& eigvals)
{
double min_eig = eigvals(0) / 1000;
double var_all = SumElems(eigvals);
double var10 = 0;
int neigs = NSIZE(eigvals);
for (int i = 0; i < MIN(10, neigs); i++)
var10 += eigvals(i);
int iprint = 0;
while (iprint < neigs && eigvals(iprint) > min_eig && iprint < 9)
iprint++;
if (iprint < neigs + 1) // show first small eig value, for context
iprint++;
lprintf("%.0f%% percent variance is explained by %s%d shape eigs:",
100 * var10 / var_all, (iprint < neigs? "the first ": ""), iprint);
const MAT eigvals_t(eigvals.t());
for (int i = 0; i < iprint; i++)
lprintf(" %.0f", 100 * eigvals_t(i) / var_all);
lprintf("%%\n");
}
int EVqr(MAT &A,double tol,int maxiter){
int n=A.dim();
int k=0;
double err=10;
MAT Q(n),R(n),T(A);
while(err>tol && k<maxiter){
QRDecomp(T,Q,R); //QR factorization
T=R*Q; //matrix multiplication
err = ConvErr(T); //get the error term in each iteration
k++;
}
printf("the three largest EV:\n");
printf("%lf %lf %lf\n",T[0][0],T[1][1],T[2][2]);
printf("the three smallest EV:\n");
printf("%lf %lf %lf\n",T[n-1][n-1],T[n-2][n-2],T[n-3][n-3]);
printf("iter = %d\n",k);
printf("error = %e\n",err);
A=T;
return k;
}
void compute_M_row_column_up(int row, int column, MAT & M, MAT2& sign_Fs, MAT2& Fe_M, typename MAT::type det_rat) {
typedef typename MAT::type SCALAR;
SCALAR det_rat_inv=1./det_rat;
double sign=((row+column)%2==0 ? 1 : -1);
Eigen::Matrix<SCALAR,Eigen::Dynamic,Eigen::Dynamic> M_sign_Fs(sign_Fs.size(),1);
M_sign_Fs = M.block()*sign_Fs;
assert(M.size1()==M.size2());
MAT M_new(M.size1()+1,M.size2()+1);
int i_new;
int j_new;
// element (j,i)
M_new(column,row) = sign*det_rat_inv;
// row j and column i
for (int k=0; k<M.size1(); k++) {
i_new = (k<column ? k : k+1);
j_new = (k<row ? k : k+1);
M_new(i_new,row) = -M_sign_Fs(k)*det_rat_inv;
M_new(column,j_new) = -sign*Fe_M(k)*det_rat_inv;
}
// remaining elements
for (int k=0; k<M.size1(); k++) {
i_new = (k<column ? k : k+1);
for (int l=0; l<M.size1(); l++) {
j_new = (l<row ? l : l+1);
M_new(i_new, j_new) = M(k,l) + M_sign_Fs(k)*Fe_M(l)*det_rat_inv;
}
}
M_new.swap(M);
return;
}
static void GenShapeMod(
Shape& meanshape, // out: n x 2
VEC& eigvals, // out: 2n x 1
MAT& eigvecs, // out: 2n x 2n, inverse of eigs of cov mat
vec_Shape& aligned_shapes, // out: shapes aligned to refshape
const ShapeFile& sh, // in
int irefshape, // in: index of shape used to align other shapes
const vec_int& nused_vec, // in: vec [nshapes] of int
const char* outdir, // in: output directory (-d flag)
const char* modname, // in: e.g. "yaw00"
const char* cmdline, // in: command line used to invoke tasm
bool force_facedet, // in: facedet the images themselves (ignore shapefile facedets)
bool write_detpars) // in: write the image detpars to facedet.shape
{
CopyShapeVec(aligned_shapes, sh.shapes_);
// after this, mean shape and aligned_shapes will be aligned to ref shape
AlignTrainingShapes(meanshape, aligned_shapes,
aligned_shapes[irefshape]);
MAT cov(CalcShapeCov(aligned_shapes, meanshape));
EigsOfSymMat(eigvecs, eigvals, cov);
if (eigvals(0) < 0.1) // number is arbitrary
lprintf("eigen data invalid "
"(not enough variation in shapes, max eigenvalue is %g)", eigvals(0));
eigvals *= 1000 / eigvals(0); // normalize so biggest eigval is 1000 (to match old Stasm)
ZapSmallEigs(eigvals, eigvecs);
eigvecs = eigvecs.t(); // invert (eigvecs is orthog so transpose is inverse)
ShowEigs(eigvals);
// now align mean shape to the face detector frame
MeanShapeAlignedToFaceDets(meanshape,
sh, nused_vec, outdir, modname, cmdline, force_facedet, write_detpars);
}
int EVqrShifted(MAT &A,double mu,double tol,int maxiter){
int iter = 0 ;
MAT T(A);
MAT R(A.dim()), Q(A.dim()),muI(A.dim());
//since we are not able to access column of a matrix easily, so we access row of matrices as substitute.
for (int i =0 ; i < A.dim(); i++)
muI[i][i] = mu;
do{
for(int i=0;i<A.dim();i++){ //subtract mu*I before QR factorization
T[i][i] = T[i][i] - mu;
}
//QR decomposition
QRDecomp(T,Q,R);
T = R * Q;
//QR decomposition ends
for(int i=0;i<A.dim();i++){ //add mu*I back
T[i][i] = T[i][i] + mu;
}
iter++;
}while( (iter < maxiter) && (QRerror(T) > tol) );
printf("Largest 3 eigenvalues: ");
for (int i = 0; i < 3; i++)
printf(" %lf;",T[i][i]);
printf("\nSmallest 3 eigenvalues: ");
for (int i = A.dim()-1; i > A.dim()-4; i--)
printf(" %lf;",T[i][i]);
//printf("\niter %d\nerror: %E\n",iter,QRerror(A_k));
return iter;
}
VEC choSolve(MAT &L,VEC b)
{
VEC x(b);
//forward substitutions
for (int i=0; i<x.len(); i++)
{
x[i] /= L[i][i];
for (int j=i+1; j<L.dim(); j++)
x[j] -= L[j][i]*x[i];
}
//backward substitutions
for (int i=(x.len()-1); i>=0; i--)
{
x[i] /= L[i][i];
for (int j=i-1; j>=0; j--)
x[j] -= L[i][j]*x[i];
}
return x;
}
MAT inverse(MAT &A)
{
VEC temp(A.dim());
// I: identity matrix; inv: inverse of A; LU: LU in-place
MAT LU(A.dim()), a = A, I(A.dim()), inv(A.dim());
LU = luFact(a); //LU in-place decomposition
// Form identity matrix
for (int i =0; i < A.dim(); i++){
I[i][i] = 1;
}
// solve inverse of A. Answer is stored row by row
for (int i = 0; i< A.dim(); i++){
temp=fwdSubs(LU,I[i]); //forward substitution
inv[i]= bckSubs(LU,temp);//backward substitution
}
// we need the result of inverse() column by column, so return transpose matrix of inv
return inv.tpose();
}
void construct_blas_matrix(MAT & M, const operator_container_t &creation_operators,
const operator_container_t &annihilation_operators, double BETA, const HYB & F)
{
int N = creation_operators.size();
M.resize(N, N);
int row = -1;
int column = -1;
for (operator_container_t::iterator ita = annihilation_operators.begin(); ita != annihilation_operators.end(); ita++) {
row++;
for (operator_container_t::iterator itc = creation_operators.begin(); itc != creation_operators.end(); itc++) {
column++;
double argument = ita->time() - itc->time();
double sign = 1;
if (argument < 0) {
argument += BETA;
sign = -1;
}
M(row, column) = interpolate_F(argument, BETA, F[ita->flavor()][itc->flavor()]) * sign;
}
column = -1;
}
}
void printMat(MAT& mat, std::string label="", int precision=2)
{
int width = precision + 7;
std::cout<<label<<"["<<mat.size1()<<","<<mat.size2()<<"] "<<"\n";
std::cout<<"[";
for(int i=0;i<mat.size1();i++)
{
if ( i != 0) std::cout<<" ";
for(int j=0;j<mat.size2();j++)
{
printf("%*.*e",width,precision,mat(i,j));
//std::cout<<mat(i,j);
if(j!=mat.size2()-1) std::cout<<", ";
}
std::cout<<";";
if ( i == mat.size1()-1) std::cout<<"]";
std::cout<<std::endl<<std::endl;
}
}
static void InitGradMagAndOrientMats(
MAT& magmat, // out: grad mag mat
MAT& orientmat, // out: grad ori mat
const Image& img) // in: ROI scaled to current pyramid level
{
const int nrows = img.rows, nrows1 = img.rows-1;
const int ncols = img.cols, ncols1 = img.cols-1;
const double bins_per_degree = BINS_PER_HIST / 360.;
magmat.create(nrows, ncols);
orientmat.create(nrows, ncols);
for (int y = 0; y < nrows1; y++)
{
const byte* const buf = (byte*)(img.data) + y * ncols;
const byte* const buf_x1 = (byte*)(img.data) + y * ncols + 1;
const byte* const buf_y1 = (byte*)(img.data) + (y+1) * ncols;
double* const magbuf = Buf(magmat) + y * ncols;
double* const orientbuf = Buf(orientmat) + y * ncols;
for (int x = 0; x < ncols1; x++)
{
const byte pixel = buf[x];
const double xdelta = buf_x1[x] - pixel;
const double ydelta = buf_y1[x] - pixel;
magbuf[x] = sqrt(SQ(xdelta) + SQ(ydelta));
double orient =
RadsToDegrees(atan2(ydelta, xdelta)); // -180 <= orient < 180
if (orient < 0)
orient += 360; // 0 <= orient < 360
orientbuf[x] = orient * bins_per_degree; // 0 <= orient < BINS_PER_HIST
}
}
// fill bottom and right edges
magmat.row(nrows1) = 0;
magmat.col(ncols1) = 0;
orientmat.row(nrows1) = 0;
orientmat.col(ncols1) = 0;
}
int compute_M_shift_start(double new_t_start, int k, int new_position, int flavor_ins,
MAT & M, const operator_container_t & annihilation_operators, const HYB & F, double BETA, SCALAR det_rat) {
std::vector<SCALAR> R(M.size1(), 0), M_k(M.size1(), 0), Fs(M.size1(), 0);
operator_container_t::const_iterator ita = annihilation_operators.begin();
for (int i = 0; i < (int) M_k.size(); i++) {
M_k[i] = M(k, i);
Fs[i] = interpolate_F(ita->time() - new_t_start, BETA, F[ita->flavor()][flavor_ins]);
ita++;
}
for (int i = 0; i < (int) R.size(); i++) {
if (i != k) {
for (int j = 0; j < (int) R.size(); j++)
R[i] += M(i, j) * Fs[j];
}
}
for (int n = 0; n < (int) M.size1(); n++) {
if (n != k) {
for (int m = 0; m < (int) M.size1(); m++) {
M(n, m) -= M_k[m] * R[n] / det_rat;
}
} else {
for (int m = 0; m < (int) M.size1(); m++) {
M(n, m) = M_k[m] / det_rat;
}
}
}
//swap rows
move_row(M, k, new_position);
return std::abs(k-new_position);
}
double QRerror(MAT &A){
double max = std::abs(A[1][0]);
for (int i = 2; i< A.dim(); i++)
max = std::max(std::abs(A[i][i-1]),max);
return max;
}
int jacobi(MAT &A,VEC b,VEC &x, int maxIter, double tol){
int n = A.dim();
VEC S(n); //summation vector
VEC G(n); //diagonal of A
VEC tmp(n); //save the x before iterative method
MAT L(n);
VEC cpr(n); //the result of hw4
//iterative
int k=0;
double err1;
double err2;
double errinf;
double diff1,diff2,diffinf;
while(k<maxIter){
for(int i=0;i<n;i++){
S[i] = 0; //initialize the sum vector to 0
}
for(int i=0;i<n;i++){
G[i] = A[i][i];
//save the previous vector x to tmp(for comparison between iteration k and k+1)
tmp[i] = x[i];
for(int j=0;j<n;j++){
if(j!=i){
S[i] = S[i] + A[i][j]*x[j]; //sum the Aij*xj, where i is not equal to j
}
}
}
for(int i=0;i<n;i++){
x[i] = (1/G[i])*(b[i]-S[i]); //compute the new solution of x at iteration k
}
k++; //after each iteration, k=k+1
err1 = 0; //1-norm
err2 = 0; //2-norm
errinf = 0; //infinity-norm
for(int i=0;i<n;i++){
err1 += fabs(x[i] - tmp[i]); //sum of absolute error
err2 += pow(x[i] - tmp[i], 2); //sum of square error
errinf = max(errinf,fabs(x[i]-tmp[i])); //take the maximum absolute difference as error
} //max(a,b) defined on the top
err2 = pow(err2,0.5); //find the square root of err2 and get the 2-norm
//you can change err1 to err2 or errinf to get different number of iterations k based on which p-norm you preferred
if(err1<tol){
break;
}
}
diff1 = 0;
diff2 = 0;
diffinf = 0;
//the answer from hw4
L = cholesky(A); //in-place Cholesky Decomposition
cpr = choSolve(L,b); //solve the linear system by forward and backward substitution
//use the same method to compute the error between hw4 and hw5, see if < 10^-7. if not, decrease the tol
for(int i=0;i<n;i++){
diff1 += fabs(x[i] - cpr[i]);
diff2 += pow(x[i] - cpr[i], 2);
diffinf = max(diffinf,fabs(x[i]-cpr[i]));
}
diff2 = pow(diff2,0.5);
printf("error between hw4 and hw5(1-norm 2-norm infinity-norm): %e %e %e\n",diff1,diff2,diffinf);
return k;
}
int gaussSeidel(MAT &A,VEC b,VEC &x,int maxIter,double tol)
{
int n = A.dim();
VEC S(n);
VEC G(n);
VEC tmp(n);
MAT L(n);
VEC cpr(n);
//iterative
int k=0;
double err1;
double err2;
double errinf;
double diff1,diff2,diffinf;
while(k<maxIter){
for(int i=0;i<n;i++){
S[i] = 0;
}
for(int i=0;i<n;i++){
G[i] = A[i][i];
tmp[i] = x[i];
for(int j=0;j<n;j++){
if(j!=i){
S[i] = S[i] + A[i][j]*x[j];
}
}
x[i] = (1/G[i])*(b[i]-S[i]);
//both x[i] and S[i] are computed in the same for loop, so some updated values are used in the current iteration
}
k++;
err1 = 0;
err2 = 0;
errinf = 0;
for(int i=0;i<n;i++){
err1 += fabs(x[i] - tmp[i]);
err2 += pow(x[i] - tmp[i], 2);
errinf = max(errinf,fabs(x[i]-tmp[i]));
}
err2 = pow(err2,0.5);
if(err1<tol){
break;
}
}
diff1 = 0;
diff2 = 0;
diffinf = 0;
//the answer from hw4
L = cholesky(A); //in-place Cholesky Decomposition
cpr = choSolve(L,b); //solve the linear system by forward and backward substitution
//use the same method to compute the error between hw4 and hw5, see if < 10^-7. if not, decrease the tol
for(int i=0;i<n;i++){
diff1 += fabs(x[i] - cpr[i]);
diff2 += pow(x[i] - cpr[i], 2);
diffinf = max(diffinf,fabs(x[i]-cpr[i]));
}
diff2 = pow(diff2,0.5);
printf("error between hw4 and hw5(1-norm 2-norm infinity-norm): %e %e %e\n",diff1,diff2,diffinf);
return k;
}
int sgs(MAT &A,VEC b,VEC &x,int maxIter,double tol)
{
int n = A.dim();
VEC S(n);
VEC G(n);
VEC tmp(n);
MAT L(n);
VEC cpr(n);
//iterative
int k=0;
double err1;
double err2;
double errinf;
double diff1,diff2,diffinf;
while(k<maxIter){
for(int i=0;i<n;i++){
S[i] = 0;
}
//forward gauss-seidel
//compute vector x from x[0] to x[n-1]
for(int i=0;i<n;i++){
G[i] = A[i][i];
tmp[i] = x[i];
for(int j=0;j<n;j++){
if(j!=i){
S[i] = S[i] + A[i][j]*x[j];
}
}
x[i] = (1/G[i])*(b[i]-S[i]);
}
//backward gauss-seidel
//use the reslults of forward gauss-seidel to compute vector x
//direction : from x[n-1] to x[0]
for(int i=0;i<n;i++){
S[i] = 0; //we also need to initialize the sum vector.
}
for(int i=n-1;i>=0;i--){
for(int j=n-1;j>=0;j--){
if(j!=i){
S[i] = S[i] + A[i][j]*x[j];
}
}
x[i] = (1/G[i])*(b[i]-S[i]);
}
k++;
err1 = 0;
err2 = 0;
errinf = 0;
for(int i=0;i<n;i++){
err1 += fabs(x[i] - tmp[i]);
err2 += pow(x[i] - tmp[i], 2);
errinf = max(errinf,fabs(x[i]-tmp[i]));
}
err2 = pow(err2,0.5);
if(err1<tol){
break;
}
}
diff1 = 0;
diff2 = 0;
diffinf = 0;
//the answer from hw4
L = cholesky(A); //in-place Cholesky Decomposition
cpr = choSolve(L,b); //solve the linear system by forward and backward substitution
//use the same method to compute the error between hw4 and hw5, see if < 10^-7. if not, decrease the tol
for(int i=0;i<n;i++){
diff1 += fabs(x[i] - cpr[i]);
diff2 += pow(x[i] - cpr[i], 2);
diffinf = max(diffinf,fabs(x[i]-cpr[i]));
}
diff2 = pow(diff2,0.5);
printf("error between hw4 and hw5(1-norm 2-norm infinity-norm): %e %e %e\n",diff1,diff2,diffinf);
return k;
}
/// \brief Solve AX=B for X with Chebyshev iteration with left
/// diagonal scaling, imitating ML's implementation.
///
/// \pre A must be real-valued and symmetric positive definite.
/// \pre numIters >= 0
/// \pre eigRatio >= 1
/// \pre 0 < lambdaMax
/// \pre All entries of D_inv are positive.
///
/// \param A [in] The matrix A in the linear system to solve.
/// \param B [in] Right-hand side(s) in the linear system to solve.
/// \param X [in] Initial guess(es) for the linear system to solve.
/// \param numIters [in] Number of Chebyshev iterations.
/// \param lambdaMax [in] Estimate of max eigenvalue of D_inv*A.
/// \param lambdaMin [in] Estimate of min eigenvalue of D_inv*A. We
/// only use this to determine if A is the identity matrix.
/// \param eigRatio [in] Estimate of max / min eigenvalue ratio of
/// D_inv*A. We use this along with lambdaMax to compute the
/// Chebyshev coefficients. This need not be the same as
/// lambdaMax/lambdaMin.
/// \param D_inv [in] Vector of diagonal entries of A. It must have
/// the same distribution as b.
void
mlApplyImpl (const MAT& A,
const MV& B,
MV& X,
const int numIters,
const ST lambdaMax,
const ST lambdaMin,
const ST eigRatio,
const V& D_inv)
{
const ST zero = Teuchos::as<ST> (0);
const ST one = Teuchos::as<ST> (1);
const ST two = Teuchos::as<ST> (2);
MV pAux (B.getMap (), B.getNumVectors ()); // Result of A*X
MV dk (B.getMap (), B.getNumVectors ()); // Solution update
MV R (B.getMap (), B.getNumVectors ()); // Not in original ML; need for B - pAux
ST beta = Teuchos::as<ST> (1.1) * lambdaMax;
ST alpha = lambdaMax / eigRatio;
ST delta = (beta - alpha) / two;
ST theta = (beta + alpha) / two;
ST s1 = theta / delta;
ST rhok = one / s1;
// Diagonal: ML replaces entries containing 0 with 1. We
// shouldn't have any entries like that in typical test problems,
// so it's OK not to do that here.
// The (scaled) matrix is the identity: set X = D_inv * B. (If A
// is the identity, then certainly D_inv is too. D_inv comes from
// A, so if D_inv * A is the identity, then we still need to apply
// the "preconditioner" D_inv to B as well, to get X.)
if (lambdaMin == one && lambdaMin == lambdaMax) {
solve (X, D_inv, B);
return;
}
// The next bit of code is a direct translation of code from ML's
// ML_Cheby function, in the "normal point scaling" section, which
// is in lines 7365-7392 of ml_smoother.c.
if (! zeroStartingSolution_) {
// dk = (1/theta) * D_inv * (B - (A*X))
A.apply (X, pAux); // pAux = A * X
R = B;
R.update (-one, pAux, one); // R = B - pAux
dk.elementWiseMultiply (one/theta, D_inv, R, zero); // dk = (1/theta)*D_inv*R
X.update (one, dk, one); // X = X + dk
} else {
dk.elementWiseMultiply (one/theta, D_inv, B, zero); // dk = (1/theta)*D_inv*B
X = dk;
}
ST rhokp1, dtemp1, dtemp2;
for (int k = 0; k < numIters-1; ++k) {
A.apply (X, pAux);
rhokp1 = one / (two*s1 - rhok);
dtemp1 = rhokp1*rhok;
dtemp2 = two*rhokp1/delta;
rhok = rhokp1;
R = B;
R.update (-one, pAux, one); // R = B - pAux
// dk = dtemp1 * dk + dtemp2 * D_inv * (B - pAux)
dk.elementWiseMultiply (dtemp2, D_inv, B, dtemp1);
X.update (one, dk, one); // X = X + dk
}
}
int Storm3D_ParticleSystem::QuadArray::lock(VXFORMAT_PART *pointer, int particleOffset, Storm3D_Scene *scene)
{
m_partOffset = particleOffset;
pointer += particleOffset * 4;
VXFORMAT_PART *vp = pointer;
float frameWidth = 0.0f;
float frameHeight = 0.0f;
if(m_animInfo.numFrames > 1)
{
frameWidth = 1.0f / m_animInfo.textureUSubDivs;
frameHeight = 1.0f / m_animInfo.textureVSubDivs;
}
BYTE *verts = (BYTE*)&vp[0].position;
BYTE *uvs = (BYTE*)&vp[0].texcoords;
BYTE *colors = (BYTE*)&vp[0].color;
DWORD stride = sizeof(VXFORMAT_PART);
D3DXMATRIX mv = scene->camera.GetViewMatrix();
DWORD c0 = 0;
// Up rotation
MAT view(scene->camera.GetViewMatrix());
VC3 worldUp(0, 1.f, 0);
view.RotateVector(worldUp);
QUAT q;
rotateToward(worldUp, VC3(0, 0, 1.f), q);
MAT g;
g.CreateRotationMatrix(q);
for(int i = 0; i < m_numParts; i++)
{
Storm3D_PointParticle& p = m_parts[i];
float sa = sinf(p.angle);
float ca = cosf(p.angle);
float hsize = 0.5f*p.size;
float x1,y1,x2,y2,x3,y3,x4,y4;
quad_util::rotatePointFast(x1, y1, -hsize, hsize, ca, sa);
quad_util::rotatePointFast(x2, y2, hsize, hsize, ca, sa);
quad_util::rotatePointFast(x3, y3, -hsize, -hsize, ca, sa);
quad_util::rotatePointFast(x4, y4, hsize, -hsize, ca, sa);
VC3 v;
v.x = p.position.x * mv.m[0][0] +
p.position.y * mv.m[1][0] +
p.position.z * mv.m[2][0] + mv.m[3][0];
v.y = p.position.x * mv.m[0][1] +
p.position.y * mv.m[1][1] +
p.position.z * mv.m[2][1] + mv.m[3][1];
v.z = p.position.x * mv.m[0][2] +
p.position.y * mv.m[1][2] +
p.position.z * mv.m[2][2] + mv.m[3][2];
VC3 v1(x1, y1, 0);
VC3 v2(x2, y2, 0);
VC3 v3(x3, y3, 0);
VC3 v4(x4, y4, 0);
if(faceUp)
{
g.RotateVector(v1);
g.RotateVector(v2);
g.RotateVector(v3);
g.RotateVector(v4);
}
v1 += v;
v2 += v;
v3 += v;
v4 += v;
/*
VC3 v1(v.x + x1, v.y + y1, v.z);
VC3 v2(v.x + x2, v.y + y2, v.z);
VC3 v3(v.x + x3, v.y + y3, v.z);
VC3 v4(v.x + x4, v.y + y4, v.z);
{
v1 -= v;
g.RotateVector(v1);
v1 += v;
v2 -= v;
g.RotateVector(v2);
v2 += v;
v3 -= v;
g.RotateVector(v3);
v3 += v;
v4 -= v;
g.RotateVector(v4);
v4 += v;
}
*/
*((Vector*)verts) = v1; verts += stride;
*((Vector*)verts) = v2; verts += stride;
*((Vector*)verts) = v3; verts += stride;
*((Vector*)verts) = v4; verts += stride;
// Fill texturecoords
if(m_animInfo.numFrames > 1) {
int frame = (int)p.frame % m_animInfo.numFrames;
int col = frame % m_animInfo.textureUSubDivs;
int row = frame / m_animInfo.textureUSubDivs;
float tx = frameWidth * (float)col;
float ty = frameHeight * (float)row;
*((float*)uvs) = tx; uvs += 4; *((float*)uvs) = ty; uvs += (stride - 4);
*((float*)uvs) = tx + frameWidth; uvs += 4; *((float*)uvs) = ty; uvs += (stride - 4);
*((float*)uvs) = tx; uvs += 4; *((float*)uvs) = ty + frameHeight; uvs += (stride - 4);
*((float*)uvs) = tx + frameWidth; uvs += 4; *((float*)uvs) = ty + frameHeight; uvs += (stride - 4);
} else {
*((float*)uvs) = 0.0f; uvs += 4; *((float*)uvs) = 0.0f; uvs += (stride - 4);
*((float*)uvs) = 1.0f; uvs += 4; *((float*)uvs) = 0.0f; uvs += (stride - 4);
*((float*)uvs) = 0.0f; uvs += 4; *((float*)uvs) = 1.0f; uvs += (stride - 4);
*((float*)uvs) = 1.0f; uvs += 4; *((float*)uvs) = 1.0f; uvs += (stride - 4);
}
c0 = (((DWORD)(p.alpha * 255.0f) &0xff) << 24) |
(((DWORD)(factor.r * p.color.r * 255.0f) &0xff) << 16) |
(((DWORD)(factor.g * p.color.g * 255.0f) &0xff) << 8) |
(((DWORD)(factor.b * p.color.b * 255.0f) &0xff) );
*((DWORD*)colors) = c0; colors += stride;
*((DWORD*)colors) = c0; colors += stride;
*((DWORD*)colors) = c0; colors += stride;
*((DWORD*)colors) = c0; colors += stride;
}
return m_numParts;
}
static void generate_transition_matrix_resize(VEC const& weights, MAT& tm) {
std::size_t n = weights.size();
tm.resize(n);
for (std::size_t i = 0; i < n; ++i) tm[i].resize(n);
generate_transition_matrix(weights, tm);
}
// return true if position ok and decal should be added
// false, if position NOT ok and decal should NOT be added
bool DecalPositionCalculator::calculateDecalPosition(
game::GameScene *gameScene,
const VC3 &origin, const VC3 &velocity,
DECAL_POSITIONING positioning, int positionRandom,
VC3 *resultPosition, QUAT *resultRotation)
{
assert(positioning != DecalPositionCalculator::DECAL_POSITIONING_INVALID);
game::GameMap *gameMap = gameScene->getGameMap();
bool hitWall = false;
*resultPosition = origin;
*resultRotation = QUAT((-3.1415926f / 2.0f),0,0);
// if velocity positioning...
if (positioning == DecalPositionCalculator::DECAL_POSITIONING_VELOCITY)
{
VC3 velocityRandomized;
if (positionRandom > 0)
{
velocityRandomized = velocity * GAME_TICKS_PER_SECOND;
// TEMP
//char buf[64];
//sprintf(buf, "%f,%f,%f", velocity.x, velocity.y, velocity.z);
//Logger::getInstance()->error(buf);
// TODO: add positionRandom to velocity _angle_...
// (or maybe just do a quick hack and add it to xz-coordinates?)
velocityRandomized.x += float((SystemRandom::getInstance()->nextInt() % (positionRandom * 2 + 1)) - positionRandom) / 100.0f;
velocityRandomized.z += float((SystemRandom::getInstance()->nextInt() % (positionRandom * 2 + 1)) - positionRandom) / 100.0f;
// add to y too? maybe should add downward only?
// NOTE: biased downward
velocityRandomized.y += float((SystemRandom::getInstance()->nextInt() % (positionRandom * 2 + 1)) - positionRandom) / 100.0f;
velocityRandomized.y -= float(positionRandom) / 100.0f * 0.5f;
} else {
velocityRandomized = velocity;
}
velocityRandomized *= 2.0f;
IStorm3D_Scene *scene = gameScene->getStormScene();
VC3 dir = velocityRandomized.GetNormalized();
VC3 rayOrigin = origin;
float rayLen = velocityRandomized.GetLength();
Storm3D_CollisionInfo sceneColl;
sceneColl.includeTerrainObjects = false;
scene->RayTrace(rayOrigin, dir, rayLen, sceneColl, true);
/*
if (sceneColl.hit)
{
VC3 hitNormal = sceneColl.plane_normal;
// make a "wall" hit if normal-y is not nearly 1
//if (fabs(hitNormal.y) < 0.8f)
{
hitWall = true;
VC3 x(rand() % 1000 / 999.f, 0, rand() % 1000 / 999.f);
x.Normalize();
x -= hitNormal * x.GetDotWith(hitNormal);
VC3 y = -x.GetCrossWith(hitNormal);
assert(fabsf(x.GetDotWith(y)) < 0.0001f);
assert(fabsf(x.GetDotWith(hitNormal)) < 0.0001f);
MAT tm;
tm.Set(0, x.x);
tm.Set(1, x.y);
tm.Set(2, x.z);
tm.Set(4, y.x);
tm.Set(5, y.y);
tm.Set(6, y.z);
tm.Set(8, hitNormal.x);
tm.Set(9, hitNormal.y);
tm.Set(10, hitNormal.z);
*resultRotation = tm.GetRotation();
}
*resultPosition = sceneColl.position;
} else {
*resultPosition += velocityRandomized;
}
*/
// New version
{
VC3 hitNormal(0, 1.f, 0);
if(sceneColl.hit)
{
hitNormal = sceneColl.plane_normal;
*resultPosition = sceneColl.position;
}
else
{
*resultPosition += velocityRandomized;
VC2 p2(resultPosition->x, resultPosition->z);
hitNormal = gameScene->getTerrain()->getFaceNormal(p2);
}
{
if(sceneColl.hit)
hitWall = true;
/*
VC3 y = dir;
VC3 z = hitNormal;
y -= hitNormal * y.GetDotWith(hitNormal);
VC3 x = z.GetCrossWith(y);
*/
VC3 x = dir;
x.y = 0.f;
x.Normalize();
x -= hitNormal * x.GetDotWith(hitNormal);
VC3 y = -x.GetCrossWith(hitNormal);
VC3 z = hitNormal;
MAT tm;
tm.Set(0, x.x);
tm.Set(1, x.y);
tm.Set(2, x.z);
tm.Set(4, y.x);
tm.Set(5, y.y);
tm.Set(6, y.z);
tm.Set(8, z.x);
tm.Set(9, z.y);
tm.Set(10, z.z);
resultRotation->MakeFromAngles(0.f, 0.f, -PI*0.5f);
*resultRotation = (*resultRotation) * tm.GetRotation();
/*
VC3 x(rand() % 1000 / 999.f, 0, rand() % 1000 / 999.f);
x.Normalize();
x -= hitNormal * x.GetDotWith(hitNormal);
VC3 y = -x.GetCrossWith(hitNormal);
assert(fabsf(x.GetDotWith(y)) < 0.0001f);
assert(fabsf(x.GetDotWith(hitNormal)) < 0.0001f);
MAT tm;
tm.Set(0, x.x);
tm.Set(1, x.y);
tm.Set(2, x.z);
tm.Set(4, y.x);
tm.Set(5, y.y);
tm.Set(6, y.z);
tm.Set(8, hitNormal.x);
tm.Set(9, hitNormal.y);
tm.Set(10, hitNormal.z);
*resultRotation = tm.GetRotation();
*/
}
}
// TODO: some kind of terrain raytrace maybe...?
// should collide to walls, etc.
}
// if downward positioning...
if (positioning == DecalPositionCalculator::DECAL_POSITIONING_DOWNWARD)
{
if (positionRandom > 0)
{
// TODO: add a random xz-offset to result position
//*resultPosition += randomizedOffset;
resultPosition->x += float((SystemRandom::getInstance()->nextInt() % (positionRandom * 2 + 1)) - positionRandom) / 100.0f;
resultPosition->z += float((SystemRandom::getInstance()->nextInt() % (positionRandom * 2 + 1)) - positionRandom) / 100.0f;
}
/*
// psd
{
VC2 p2(resultPosition->x, resultPosition->z);
VC3 hitNormal = gameScene->getTerrain()->getFaceNormal(p2);
VC3 x(rand() % 1000 / 999.f, 0, rand() % 1000 / 999.f);
x.Normalize();
x -= hitNormal * x.GetDotWith(hitNormal);
VC3 y = -x.GetCrossWith(hitNormal);
assert(fabsf(x.GetDotWith(y)) < 0.0001f);
assert(fabsf(x.GetDotWith(hitNormal)) < 0.0001f);
MAT tm;
tm.Set(0, x.x);
tm.Set(1, x.y);
tm.Set(2, x.z);
tm.Set(4, y.x);
tm.Set(5, y.y);
tm.Set(6, y.z);
tm.Set(8, hitNormal.x);
tm.Set(9, hitNormal.y);
tm.Set(10, hitNormal.z);
*resultRotation = tm.GetRotation();
}
*/
VC3 fooNormal;
calculateDecalRotation(gameScene, *resultPosition, *resultRotation, 0.f, fooNormal);
}
// now check that we're still inside map boundaries
if (!gameMap->isWellInScaledBoundaries(resultPosition->x, resultPosition->z))
{
// out of map.
return false;
}
// then fix decal height to ground height
if (positioning == DecalPositionCalculator::DECAL_POSITIONING_DOWNWARD
|| positioning == DecalPositionCalculator::DECAL_POSITIONING_VELOCITY)
{
if (!hitWall)
{
resultPosition->y = gameMap->getScaledHeightAt(resultPosition->x, resultPosition->z);
}
}
// check that not on top of metal grid area...
if (game::MaterialManager::isMaterialUnderPosition(gameMap,
*resultPosition, MATERIAL_METAL_GRATE))
{
// on top of grid, no decal here.
return false;
}
// TODO: check that not inside a wall, terrainobject, etc.
// if so, return false
return true;
}
//------------------------------------------------------------------
// Storm3D_Material::Apply
// Applies material. Use pass parameter to tell with pass to
// render. Start with pass=0, and increase it until this routine
// returns false. (=all passes rendered)
//
// Returns:
// false = this was last pass
// true = new pass must be rendered
//------------------------------------------------------------------
bool Storm3D_Material::Apply(Storm3D_Scene *scene,int pass,DWORD fvf,D3DMATRIX *mtx)
{
/*
Basic config:
All textures = NULL
Stage0:
colorop = modulate
colorarg1 = texture
colorarg2 = diffuse
alphaop = disable
texturetransformflags = disable
texcoordindex = 0
Stage1-3:
colorarg1 = texture
colorarg2 = current
alphaop = disable
texturetransformflags = disable
texcoordindex = 0
After rendering material's UnApply() is called, and it
returns these states, if it changes them.
*/
// BETA: UnApply() all (very slow!)
Storm3D2->device.SetRenderState(D3DRS_LIGHTING,TRUE);
Storm3D2->device.SetRenderState(D3DRS_ALPHATESTENABLE,FALSE);
Storm3D2->device.SetTexture(0,NULL);
Storm3D2->device.SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_COLORARG2,D3DTA_DIFFUSE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE);
// FixMe:
// Setting this causes debug runtime to halt (set only to supported stages)
//for (int i=1;i<3;i++)
for (int i=0;i<2;i++)
{
Storm3D2->device.SetTexture(i,NULL);
Storm3D2->device.SetTextureStageState(i,D3DTSS_COLORARG1,D3DTA_TEXTURE);
Storm3D2->device.SetTextureStageState(i,D3DTSS_COLORARG2,D3DTA_CURRENT);
Storm3D2->device.SetTextureStageState(i,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
Storm3D2->device.SetTextureStageState(i,D3DTSS_TEXCOORDINDEX,i);
Storm3D2->device.SetTextureStageState(i,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE);
}
// Animate textures
if (texture_base) texture_base->texture->AnimateVideo();
if (texture_base2) texture_base2->texture->AnimateVideo();
if (texture_reflection) texture_reflection->texture->AnimateVideo();
if (texture_bump) texture_bump->texture->AnimateVideo();
// The superb if(TM) multitexturing (no effects/techniques needed anymore!)
// This routine is much faster than DX8-effect system (and bugfree also;)...
if (multitexture_type==MTYPE_COLORONLY) // COL only
{
// Set stages (color only)
//Storm3D2->device.SetTexture(0,NULL);
// psd: assume lightmap if base2 defined
if(texture_base2)
{
texture_base2->texture->Apply(0);
Storm3D2->device.SetTextureStageState(0,D3DTSS_COLOROP,texture_base2->GetDX8MultitexBlendingOp());
}
else
{
Storm3D2->device.SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG1);
Storm3D2->device.SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_DIFFUSE);
Storm3D2->device.SetTextureStageState(1,D3DTSS_COLOROP,D3DTOP_DISABLE);
}
}
else if (multitexture_type==MTYPE_TEXTURE) // Base
{
// Set stage (base)
texture_base->texture->Apply(0);
// Disable last stage
Storm3D2->device.SetTextureStageState(1,D3DTSS_COLOROP,D3DTOP_DISABLE);
}
else if (multitexture_type==MTYPE_DUALTEX) // Base+Base2
{
// Set stage (base)
texture_base->texture->Apply(0);
// Set stage (base2)
texture_base2->texture->Apply(1);
Storm3D2->device.SetTextureStageState(1,D3DTSS_COLOROP,texture_base2->GetDX8MultitexBlendingOp());
// Disable last stage
Storm3D2->device.SetTextureStageState(2,D3DTSS_COLOROP,D3DTOP_DISABLE);
}
else if (multitexture_type==MTYPE_REF) // Reflection
{
// Set stage (reflection)
texture_reflection->texture->Apply(0);
// Reflection texture (or projective?)
if (texture_reflection->texcoord_gen==TEX_GEN_REFLECTION)
{
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
// Correct number of texturecoordinates
if (texture_reflection->texture->IsCube())
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3);
else
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT2);
// Rotate the reflection
VC3 camdir=scene->camera.GetDirection();
float angle_y=VC2(camdir.x,camdir.z).CalculateAngle();
float angle_x=VC2(VC2(camdir.x,camdir.z).GetLength(),camdir.y).CalculateAngle();
MAT mat;
mat.CreateRotationMatrix(QUAT(-angle_x,-angle_y,0));
if (!texture_reflection->texture->IsCube())
{
// Fix reflection (v2.3)
float mt[16]=
{
0.5, 0, 0, 0,
0, -0.5, 0, 0,
0, 0, 1, 0,
0.5, 0.5, 0, 1
};
MAT mat2(mt);
mat.Multiply(mat2);
// Flip texture upside down
//mat.Multiply(MAT(VC3(1,-1,1)));
}
// Set texture rotation matrix
D3DMATRIX dxmat;
mat.GetAsD3DCompatible4x4((float*)&dxmat);
Storm3D2->device.SetTransform(D3DTS_TEXTURE0,&dxmat);
}
else // Projective texture
{
// Create matrix, tu=(0.5+0.87*x)/z, tv=(0.5-0.87*y)/z
D3DXMATRIX mat;
mat._11=0.866f;mat._12=0.0f;mat._13=0.0f;
mat._21=0.0f;mat._22=-0.866f;mat._23=0.0f;
mat._31=0.5f;mat._32=0.5f;mat._33=1.0f;
mat._41=0.0f;mat._42=0.0f;mat._43=0.0f;
// If it's mirror negate _11
if (texture_reflection->texcoord_gen==TEX_GEN_PROJECTED_MIRROR)
mat._11*=-1;
Storm3D2->device.SetTransform(D3DTS_TEXTURE0,&mat);
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3|D3DTTFF_PROJECTED);
Storm3D2->device.SetTextureStageState(0,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION);
}
// Disable last stage
Storm3D2->device.SetTextureStageState(1,D3DTSS_COLOROP,D3DTOP_DISABLE);
}
else if (multitexture_type==MTYPE_TEX_REF) // Base+Reflection
{
// Set stage (base)
texture_base->texture->Apply(0);
// Set stage (reflection)
texture_reflection->texture->Apply(1);
Storm3D2->device.SetTextureStageState(1,D3DTSS_COLOROP,texture_reflection->GetDX8MultitexBlendingOp());
// Reflection texture (or projective?)
if (texture_reflection->texcoord_gen==TEX_GEN_REFLECTION)
{
Storm3D2->device.SetTextureStageState(1,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
// Correct number of texturecoordinates
if (texture_reflection->texture->IsCube())
Storm3D2->device.SetTextureStageState(1,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3);
else
Storm3D2->device.SetTextureStageState(1,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT2);
// Rotate the reflection
VC3 camdir=scene->camera.GetDirection();
float angle_y=VC2(camdir.x,camdir.z).CalculateAngle();
float angle_x=VC2(VC2(camdir.x,camdir.z).GetLength(),camdir.y).CalculateAngle();
MAT mat;
mat.CreateRotationMatrix(QUAT(-angle_x,-angle_y,0));
if (!texture_reflection->texture->IsCube())
{
// Fix reflection (v2.3)
float mt[16]=
{
0.5, 0, 0, 0,
0, -0.5, 0, 0,
0, 0, 1, 0,
0.5, 0.5, 0, 1
};
MAT mat2(mt);
mat.Multiply(mat2);
}
// Set texture rotation matrix
D3DMATRIX dxmat;
mat.GetAsD3DCompatible4x4((float*)&dxmat);
Storm3D2->device.SetTransform(D3DTS_TEXTURE1,&dxmat);
}
else // Projective mirror texture
{
// Create matrix, tu=(0.5+0.87*x)/z, tv=(0.5-0.87*y)/z
D3DXMATRIX mat;
mat._11=0.866f;mat._12=0.0f;mat._13=0.0f;
mat._21=0.0f;mat._22=-0.866f;mat._23=0.0f;
mat._31=0.5f;mat._32=0.5f;mat._33=1.0f;
mat._41=0.0f;mat._42=0.0f;mat._43=0.0f;
// If it's mirror negate _11
if (texture_reflection->texcoord_gen==TEX_GEN_PROJECTED_MIRROR)
mat._11*=-1;
Storm3D2->device.SetTransform(D3DTS_TEXTURE1,&mat);
Storm3D2->device.SetTextureStageState(1,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3|D3DTTFF_PROJECTED);
Storm3D2->device.SetTextureStageState(1,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION);
}
// Disable last stage
Storm3D2->device.SetTextureStageState(2,D3DTSS_COLOROP,D3DTOP_DISABLE);
}
// Setup material
D3DMATERIAL9 mat;
// Set diffuse
mat.Diffuse.r=mat.Ambient.r=color.r;
mat.Diffuse.g=mat.Ambient.g=color.g;
mat.Diffuse.b=mat.Ambient.b=color.b;
mat.Diffuse.a=mat.Ambient.a=0;
// Set self.illum
mat.Emissive.r=self_illum.r;
mat.Emissive.g=self_illum.g;
mat.Emissive.b=self_illum.b;
mat.Emissive.a=0;
// Set specular
mat.Specular.r=specular.r;
mat.Specular.g=specular.g;
mat.Specular.b=specular.b;
mat.Specular.a=0;
mat.Power=specular_sharpness;
// Set specular on only if it's used
if ((specular_sharpness>1)&&
((specular.r>0.01f)||(specular.g>0.01f)||(specular.b>0.01f)))
{
Storm3D2->device.SetRenderState(D3DRS_SPECULARENABLE,TRUE);
} else Storm3D2->device.SetRenderState(D3DRS_SPECULARENABLE,FALSE);
// Set 2sided
// if (doublesided) Storm3D2->device.SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
// else Storm3D2->device.SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
// Set wireframe
if (wireframe) Storm3D2->device.SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
else Storm3D2->device.SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
// BETA!!!
//Storm3D2->device.SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
// Set alphablending
if (alphablend_type==ATYPE_NONE)
{
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,TRUE);
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
}
else if (alphablend_type==ATYPE_USE_TRANSPARENCY)
{
if (transparency>0.001f)
{
mat.Diffuse.a=1.0f-transparency;
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
Storm3D2->device.SetRenderState(D3DRS_ALPHATESTENABLE,FALSE);
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_DIFFUSE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
Storm3D2->device.SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
Storm3D2->device.SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
}
else
{
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,TRUE);
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
}
}
else if (alphablend_type==ATYPE_USE_TEXTRANSPARENCY || alphablend_type==IStorm3D_Material::ATYPE_USE_ALPHATEST)
{
mat.Diffuse.a=1.0f-transparency;
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
if(alphablend_type==IStorm3D_Material::ATYPE_USE_ALPHATEST)
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,TRUE);
else
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
if ((multitexture_type==MTYPE_DOT3_TEX)||(multitexture_type==MTYPE_DOT3_REF))
{
// Stage 1 alphamap (no diffuse)
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG2);
Storm3D2->device.SetTextureStageState(1,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
Storm3D2->device.SetTextureStageState(1,D3DTSS_ALPHAARG2,D3DTA_CURRENT);
Storm3D2->device.SetTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
}
else
{
// Stage 0 alphamap * diffuse
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE);
Storm3D2->device.SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_MODULATE);
}
Storm3D2->device.SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
Storm3D2->device.SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
Storm3D2->device.SetRenderState(D3DRS_ALPHAREF,(DWORD)0x00000001);
Storm3D2->device.SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_GREATEREQUAL);
Storm3D2->device.SetRenderState(D3DRS_ALPHATESTENABLE,TRUE);
}
else if (alphablend_type==ATYPE_ADD)
{
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
Storm3D2->device.SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
Storm3D2->device.SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
}
else if (alphablend_type==ATYPE_MUL)
{
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
Storm3D2->device.SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ZERO);
Storm3D2->device.SetRenderState(D3DRS_DESTBLEND,D3DBLEND_SRCCOLOR);
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
}
else if (alphablend_type==ATYPE_MUL2X)
{
Storm3D2->device.SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
Storm3D2->device.SetRenderState(D3DRS_SRCBLEND,D3DBLEND_DESTCOLOR);
Storm3D2->device.SetRenderState(D3DRS_DESTBLEND,D3DBLEND_SRCCOLOR);
Storm3D2->device.SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
}
// Use this material
Storm3D2->device.SetMaterial(&mat);
/* PSD
// Apply shader
if (!ApplyShaderIfAvailable(scene,mtx)) Storm3D2->device.SetVertexShader(fvf);
*/
// Set active material
Storm3D2->active_material=this;
return false;
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
typedef Epetra_CrsMatrix MAT;
typedef Epetra_MultiVector MV;
using Tpetra::global_size_t;
using Teuchos::tuple;
using Teuchos::RCP;
using Teuchos::rcp;
#ifdef HAVE_MPI
const Epetra_MpiComm comm (MPI_COMM_WORLD);
#else
const Epetra_SerialComm comm;
#endif
size_t myRank = comm.MyPID();
RCP<Teuchos::FancyOStream> fos = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
*fos << myRank << " : " << Amesos2::version() << std::endl << std::endl;
bool printMatrix = false;
bool printSolution = false;
bool printTiming = false;
bool verbose = false;
std::string solver_name = "SuperLU";
std::string filedir = "../test/matrices/";
std::string filename = "arc130.mtx";
Teuchos::CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("filedir",&filedir,"Directory where matrix-market files are located");
cmdp.setOption("filename",&filename,"Filename for Matrix-Market test matrix.");
cmdp.setOption("print-matrix","no-print-matrix",&printMatrix,"Print the full matrix after reading it.");
cmdp.setOption("print-solution","no-print-solution",&printSolution,"Print solution vector after solve.");
cmdp.setOption("print-timing","no-print-timing",&printTiming,"Print solver timing statistics");
cmdp.setOption("solver", &solver_name, "Which TPL solver library to use.");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
return -1;
}
// Before we do anything, check that the solver is enabled
if( !Amesos2::query(solver_name) ){
std::cerr << solver_name << " not enabled. Exiting..." << std::endl;
return EXIT_SUCCESS; // Otherwise CTest will pick it up as
// failure, which it isn't really
}
const size_t numVectors = 1;
std::string mat_pathname = filedir + filename;
MAT* A;
int ret = EpetraExt::MatrixMarketFileToCrsMatrix(mat_pathname.c_str(), comm, A, false, false);
if( ret == -1 ){
*fos << "error reading matrix file from disk, aborting..." << std::endl;
return EXIT_FAILURE;
}
if( printMatrix ){
A->Print(*(fos->getOStream()));
}
// get the maps
const Epetra_Map dmnmap = A->DomainMap();
const Epetra_Map rngmap = A->RangeMap();
// Create random X
RCP<MV> X = rcp( new MV(dmnmap,numVectors) );
X->Random();
RCP<MV> B = rcp(new MV(rngmap,numVectors));
B->Random();
// Constructor from Factory
RCP<Amesos2::Solver<MAT,MV> > solver;
try{
solver = Amesos2::create<MAT,MV>(solver_name, rcp(A), X, B);
} catch (std::invalid_argument e){
*fos << e.what() << std::endl;
return 0;
}
#ifdef HAVE_AMESOS2_SHYLUBASKER
if( Amesos2::query("shylubasker") ) {
Teuchos::ParameterList amesos2_params("Amesos2");
amesos2_params.sublist(solver_name).set("num_threads", 1, "Number of threads");
solver->setParameters( Teuchos::rcpFromRef(amesos2_params) );
}
#endif
solver->solve();
if( printSolution ){
// Print the solution
X->Print(*(fos->getOStream()));
}
if( printTiming ){
// Print some timing statistics
solver->printTiming(*fos);
}
// We are done.
return 0;
}
inline void updateGSBasis_noapprox() {
int n = L.NumRows();
GScomputed = 0;
updateGSBasis_noapprox(1,n);
}
void resize(int n,int m) {
L.SetDims(n,m);
dim = n; //number of rows
isNecessaryGSUpdate=true;
}
MatrixRow(const MAT& mat, uint32_t row) : matrix(mat.Cast()), row(row) {
}