void NDG2D::PoissonIPDGbc2D(
CSd& spOP //[out] sparse operator
)
{
// function [OP] = PoissonIPDGbc2D()
// Purpose: Set up the discrete Poisson matrix directly
// using LDG. The operator is set up in the weak form
// build DG derivative matrices
int max_OP = (K*Np*Np*(1+Nfaces));
//initialize parameters
DVec faceR("faceR"), faceS("faceS");
IVec Fm("Fm"), Fm1("Fm1"), fidM("fidM");
DMat V1D("V1D"); int i=0;
// build local face matrices
DMat massEdge[4]; // = zeros(Np,Np,Nfaces);
for (i=1; i<=Nfaces; ++i) {
massEdge[i].resize(Np,Np);
}
// face mass matrix 1
Fm = Fmask(All,1); faceR = r(Fm);
V1D = Vandermonde1D(N, faceR);
massEdge[1](Fm,Fm) = inv(V1D*trans(V1D));
// face mass matrix 2
Fm = Fmask(All,2); faceR = r(Fm);
V1D = Vandermonde1D(N, faceR);
massEdge[2](Fm,Fm) = inv(V1D*trans(V1D));
// face mass matrix 3
Fm = Fmask(All,3); faceS = s(Fm);
V1D = Vandermonde1D(N, faceS);
massEdge[3](Fm,Fm) = inv(V1D*trans(V1D));
//continue initialize parameters
DMat Dx("Dx"),Dy("Dy"), Dn1("Dn1"), mmE_Fm1("mmE(:,Fm1)");
double lnx=0.0,lny=0.0,lsJ=0.0,hinv=0.0,gtau=0.0;
int k1=0,f1=0,id=0;
IVec i1_Nfp = Range(1,Nfp);
double N1N1 = double((N+1)*(N+1));
// "OP" triplets (i,j,x), extracted to {Ai,Aj,Ax}
IVec OPi(max_OP),OPj(max_OP), Ai,Aj; DVec OPx(max_OP), Ax;
IMat rows1, cols1; Index1D entries; DMat OP11(Np,Nfp, 0.0);
// global node numbering
entries.reset(1,Np*Nfp);
cols1 = outer(Ones(Np), Range(1,Nfp));
umMSG(1, "\n ==> {OP} assembly [bc]: ");
for (k1=1; k1<=K; ++k1)
{
if (! (k1%100)) { umMSG(1, "%d, ",k1); }
rows1 = outer(Range((k1-1)*Np+1,k1*Np), Ones(Nfp));
// Build element-to-element parts of operator
for (f1=1; f1<=Nfaces; ++f1)
{
if (BCType(k1,f1))
{
////////////////////////added by Kevin ///////////////////////////////
Fm1 = Fmask(All,f1);
fidM = (k1-1)*Nfp*Nfaces + (f1-1)*Nfp + i1_Nfp;
id = 1+(f1-1)*Nfp + (k1-1)*Nfp*Nfaces;
lnx = nx(id); lny = ny(id);
lsJ = sJ(id); hinv = Fscale(id);
Dx = rx(1,k1)*Dr + sx(1,k1)*Ds;
Dy = ry(1,k1)*Dr + sy(1,k1)*Ds;
Dn1 = lnx*Dx + lny*Dy;
//mmE = lsJ*massEdge(:,:,f1);
//bc(All,k1) += (gtau*mmE(All,Fm1) - Dn1'*mmE(All,Fm1))*ubc(fidM);
mmE_Fm1 = massEdge[f1](All,Fm1); mmE_Fm1 *= lsJ;
gtau = 10*N1N1*hinv; // set penalty scaling
//bc(All,k1) += (gtau*mmE_Fm1 - trans(Dn1)*mmE_Fm1) * ubc(fidM);
switch(BCType(k1,f1)){
case BC_Dirichlet:
OP11 = gtau*mmE_Fm1 - trans(Dn1)*mmE_Fm1;
break;
case BC_Neuman:
OP11 = mmE_Fm1;
break;
default:
std::cout<<"warning: boundary condition is incorrect"<<std::endl;
}
OPi(entries)=rows1; OPj(entries)=cols1; OPx(entries)=OP11;
entries += (Np*Nfp);
}
cols1 += Nfp;
}
}
umMSG(1, "\n ==> {OPbc} to sparse\n");
entries.reset(1, entries.hi()-(Np*Nfp));
// extract triplets from large buffers
Ai=OPi(entries); Aj=OPj(entries); Ax=OPx(entries);
// These arrays can be HUGE, so force deallocation
OPi.Free(); OPj.Free(); OPx.Free();
// return 0-based sparse result
Ai -= 1; Aj -= 1;
//-------------------------------------------------------
// This operator is not symmetric, and will NOT be
// factorised, only used to create reference RHS's:
//
// refrhsbcPR = spOP1 * bcPR;
// refrhsbcUx = spOP2 * bcUx;
// refrhsbcUy = spOP2 * bcUy;
//
// Load ALL elements (both upper and lower triangles):
//-------------------------------------------------------
spOP.load(Np*K, Nfp*Nfaces*K, Ai,Aj,Ax, sp_All,false, 1e-15,true);
Ai.Free(); Aj.Free(); Ax.Free();
umMSG(1, " ==> {OPbc} ready.\n");
#if (1)
// check on original estimates for nnx
umMSG(1, " ==> max_OP: %12d\n", max_OP);
umMSG(1, " ==> nnz_OP: %12d\n", entries.hi());
#endif
}
void QuatOpsTest::testQuatDiv()
{
// test matrix div version against quat div version,
// make sure they all work the same.
// note: this test depends on the xforms functions working
{
const float eps = 0.0001f;
gmtl::Matrix44f q3( gmtl::makeRot<gmtl::Matrix44f>( gmtl::AxisAnglef( gmtl::Math::deg2Rad( 90.0f ), 0,1,0 ) ) ),
q4( gmtl::makeRot<gmtl::Matrix44f>( gmtl::AxisAnglef( gmtl::Math::deg2Rad( 90.0f ), 0,0,1 ) ) ), q6;
gmtl::Vec3f sx( 6,0,0 ), sy( 0,4,0 ), sz( 0,0,9 ), ex( 0,0,6 ), ey( -4,0,0 ), ez( 0,-9,0 ), tx, ty, tz;
gmtl::invert( q3 ); // there is no matrix div, so do this to simulate it.
// make sure the mult() func works
gmtl::mult( q6, q4, q3 );
tx = q6 * sx;
ty = q6 * sy;
tz = q6 * sz;
CPPUNIT_ASSERT( gmtl::isEqual( ex, tx, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ey, ty, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ez, tz, eps ) );
// make sure the operator* works too
q6 = q4 * q3;
tx = q6 * sx;
ty = q6 * sy;
tz = q6 * sz;
CPPUNIT_ASSERT( gmtl::isEqual( ex, tx, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ey, ty, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ez, tz, eps ) );
// make sure the operator*= works too
q6 = q4;
q6 *= q3;
tx = q6 * sx;
ty = q6 * sy;
tz = q6 * sz;
CPPUNIT_ASSERT( gmtl::isEqual( ex, tx, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ey, ty, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ez, tz, eps ) );
}
{
const float eps = 0.0001f;
gmtl::Quat<float> q3( gmtl::makeRot<gmtl::Quatf>( gmtl::AxisAnglef( gmtl::Math::deg2Rad( 90.0f ), 0,1,0 ) ) ),
q4( gmtl::makeRot<gmtl::Quatf>( gmtl::AxisAnglef( gmtl::Math::deg2Rad( 90.0f ), 0,0,1 ) ) ), q5, q6;
gmtl::Vec3f sx( 6,0,0 ), sy( 0,4,0 ), sz( 0,0,9 ), ex( 0,0,6 ), ey( -4,0,0 ), ez( 0,-9,0 ), tx, ty, tz;
// make sure the mult() func works
gmtl::div( q6, q4, q3 );
tx = q6 * sx;
ty = q6 * sy;
tz = q6 * sz;
CPPUNIT_ASSERT( gmtl::isEqual( ex, tx, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ey, ty, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ez, tz, eps ) );
// make sure the operator* works too
q6 = q4 / q3;
tx = q6 * sx;
ty = q6 * sy;
tz = q6 * sz;
CPPUNIT_ASSERT( gmtl::isEqual( ex, tx, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ey, ty, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ez, tz, eps ) );
// make sure the operator*= works too
q6 = q4;
q6 /= q3;
tx = q6 * sx;
ty = q6 * sy;
tz = q6 * sz;
CPPUNIT_ASSERT( gmtl::isEqual( ex, tx, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ey, ty, eps ) );
CPPUNIT_ASSERT( gmtl::isEqual( ez, tz, eps ) );
}
}
void Objecte::readObj(QString filename)
{
FILE *fp = fopen(filename.toLocal8Bit(),"rb");
if (!fp)
{
cout << "No puc obrir el fitxer " << endl;
}
else {
int vindexAct = 0;
int vindexUlt = 0;
while (true)
{
char *comment_ptr = ReadFile::fetch_line (fp);
if (comment_ptr == (char *) -1) /* end-of-file */
break;
/* did we get a comment? */
if (comment_ptr) {
//make_comment (comment_ptr);
continue;
}
/* if we get here, the line was not a comment */
int nwords = ReadFile::fetch_words();
/* skip empty lines */
if (nwords == 0)
continue;
char *first_word = ReadFile::words[0];
if (!strcmp (first_word, "v"))
{
if (nwords < 4)
{
fprintf (stderr, "Too few coordinates");//: '%s'", str_orig);
exit (-1);
}
QString sx(ReadFile::words[1]);
QString sy(ReadFile::words[2]);
QString sz(ReadFile::words[3]);
double x = sx.toDouble();
double y = sy.toDouble();
double z = sz.toDouble();
if (nwords == 5)
{
QString sw(ReadFile::words[4]);
double w = sw.toDouble();
x/=w;
y/=w;
z/=w;
}
// S'afegeix el vertex a l'objecte
vertexs.push_back(point4(x, y, z, 1));
vindexAct++;
}
else if (!strcmp (first_word, "vn")) {
}
else if (!strcmp (first_word, "vt")) {
}
else if (!strcmp (first_word, "f")) {
// S'afegeix la cara a l'objecte
construeix_cara (&ReadFile::words[1], nwords-1, this, vindexUlt);
}
// added
else if (!strcmp (first_word, "mtllib")) {
//read_mtllib (&words[1], nwords-1, matlib, filename);
}
else if (!strcmp (first_word, "usemtl")) {
//int size = strlen(words[1])-1;
//while (size && (words[1][size]=='\n' || words[1][size]=='\r') ) words[1][size--]=0;
//currentMaterial = matlib.index(words[1]);
}
// fadded
else {
//fprintf (stderr, "Do not recognize: '%s'\n", str_orig);
}
//free(words);
}
}
}
void State::enforce_outflow(const OctFace& f, const _3Vec& X) {
switch (f) {
#ifdef USE_LZ
case XU:
if (vx(X) > 0.0) {
(*this)[sy_index] = X[0] * vy(X) * rho();
(*this)[sx_index] = X[1] * vy(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
case XL:
if (vx(X) < 0.0) {
(*this)[sy_index] = X[0] * vy(X) * rho();
(*this)[sx_index] = X[1] * vy(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
case YU:
if (vy(X) > 0.0) {
(*this)[sy_index] = -X[1] * vx(X) * rho();
(*this)[sx_index] = X[0] * vx(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
case YL:
if (vy(X) < 0.0) {
(*this)[sy_index] = -X[1] * vx(X) * rho();
(*this)[sx_index] = X[0] * vx(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
#else
case XU:
if (vx() > 0.0) {
set_et(et() - 0.5 * sx() * sx() / rho());
set_sx(0.0);
}
break;
case XL:
if (vx() < 0.0) {
set_et(et() - 0.5 * sx() * sx() / rho());
set_sx(0.0);
}
break;
case YU:
if (vy() > 0.0) {
set_et(et() - 0.5 * sy() * sy() / rho());
set_sy(0.0);
}
break;
case YL:
if (vy() < 0.0) {
set_et(et() - 0.5 * sy() * sy() / rho());
set_sy(0.0);
}
break;
#endif
case ZU:
if (sz() > 0.0) {
set_et(et() - 0.5 * sz() * sz() / rho());
set_sz(0.0);
}
break;
case ZL:
if (sz() < 0.0) {
set_et(et() - 0.5 * sz() * sz() / rho());
set_sz(0.0);
}
break;
}
}
ProgressBar::ProgressBar(
Beatup* beatup, std::string front_sprite_path, std::string back_sprite_path,
std::string front_sprite_frame_path, std::string back_sprite_frame_path
)
{
this->target_percentage = 100.0f;
this->beatup = beatup;
auto get_sprite = [](std::string sprite_path, std::string frame_path)
{
Sprite* result;
if (sprite_path == "") {
if (frame_path != "")
result = Sprite::createWithSpriteFrameName(frame_path);
else
result = Sprite::create();
}
else {
result = Sprite::create(sprite_path);
};
return result;
};
Sprite* front_sprite = get_sprite(front_sprite_path, front_sprite_frame_path);
this->front_timer = cocos2d::ProgressTimer::create(front_sprite);
Sprite* slider_sprite = get_sprite("whitebar.png", "");
this->back_timer = cocos2d::ProgressTimer::create(slider_sprite);
Sprite* back_sprite = get_sprite(back_sprite_path, back_sprite_frame_path);
this->background = back_sprite;
beatup->addChild(this->background);
this->lbl = Label::createWithTTF("", DEFAULT_FONT, 40);
this->lbl->setScale(0.25f);
this->lbl->setAnchorPoint(Vec2(0.5f, 0.5f));
this->lbl->getTexture()->setAliasTexParameters();
auto front_size = this->front_timer->getContentSize();
this->lbl->setPosition(Vec2(
front_size.width/2.0f,
front_size.height/2.0f
));
this->lbl->setTextColor(Color4B::BLACK);
this->front_timer->addChild(this->lbl);
this->background->setLocalZOrder(99);
this->back_timer->setLocalZOrder(100); //prog bars on top of everything
this->front_timer->setLocalZOrder(101);
this->lbl->setLocalZOrder(102);
this->beatup->addChild(this->back_timer);
this->beatup->addChild(this->front_timer);
this->color_layer = LayerColor::create(Color4B(255, 255, 255, 25));
this->front_timer->addChild(this->color_layer);
this->color_layer->setContentSize(this->front_timer->getContentSize());
this->wait_to_clear = true;
for (ProgressTimer* timer : {this->front_timer, this->back_timer})
{
timer->setType(ProgressTimerType::BAR);
timer->setBarChangeRate(Vec2(1, 0));
timer->setAnchorPoint(Vec2(0, 0));
timer->setPosition(0, 0);
timer->setVisible(true);
timer->setPercentage(100);
auto t_sprite = timer->getSprite();
if (t_sprite)
{
auto t_tex = t_sprite->getTexture();
t_tex->setAliasTexParameters();
};
timer->setMidpoint(Vec2(0, 0));
};
this->do_finish_bump = false;
this->setScale(sx(4));
};
void PSSMLightShadowMap::setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc)
{
PROFILE_SCOPE( PSSMLightShadowMap_setShaderParameters );
if ( lsc->mTapRotationTexSC->isValid() )
GFX->setTexture( lsc->mTapRotationTexSC->getSamplerRegister(),
SHADOWMGR->getTapRotationTex() );
const ShadowMapParams *p = mLight->getExtended<ShadowMapParams>();
Point4F sx(Point4F::Zero),
sy(Point4F::Zero),
ox(Point4F::Zero),
oy(Point4F::Zero),
aXOff(Point4F::Zero),
aYOff(Point4F::Zero);
for (U32 i = 0; i < mNumSplits; i++)
{
sx[i] = mScaleProj[i].x;
sy[i] = mScaleProj[i].y;
ox[i] = mOffsetProj[i].x;
oy[i] = mOffsetProj[i].y;
}
Point2F shadowMapAtlas;
if (mNumSplits < 4)
{
shadowMapAtlas.x = 1.0f / (F32)mNumSplits;
shadowMapAtlas.y = 1.0f;
// 1xmNumSplits
for (U32 i = 0; i < mNumSplits; i++)
aXOff[i] = (F32)i * shadowMapAtlas.x;
}
else
{
shadowMapAtlas.set(0.5f, 0.5f);
// 2x2
for (U32 i = 0; i < mNumSplits; i++)
{
if (i == 1 || i == 3)
aXOff[i] = 0.5f;
if (i > 1)
aYOff[i] = 0.5f;
}
}
params->setSafe(lsc->mScaleXSC, sx);
params->setSafe(lsc->mScaleYSC, sy);
params->setSafe(lsc->mOffsetXSC, ox);
params->setSafe(lsc->mOffsetYSC, oy);
params->setSafe(lsc->mAtlasXOffsetSC, aXOff);
params->setSafe(lsc->mAtlasYOffsetSC, aYOff);
params->setSafe(lsc->mAtlasScaleSC, shadowMapAtlas);
Point4F lightParams( mLight->getRange().x, p->overDarkFactor.x, 0.0f, 0.0f );
params->setSafe( lsc->mLightParamsSC, lightParams );
params->setSafe( lsc->mFarPlaneScalePSSM, mFarPlaneScalePSSM);
Point2F fadeStartLength(p->fadeStartDist, 0.0f);
if (fadeStartLength.x == 0.0f)
{
// By default, lets fade the last half of the last split.
fadeStartLength.x = (mSplitDist[mNumSplits-1] + mSplitDist[mNumSplits]) / 2.0f;
}
fadeStartLength.y = 1.0f / (mSplitDist[mNumSplits] - fadeStartLength.x);
params->setSafe( lsc->mFadeStartLength, fadeStartLength);
params->setSafe( lsc->mOverDarkFactorPSSM, p->overDarkFactor);
// The softness is a factor of the texel size.
params->setSafe( lsc->mShadowSoftnessConst, p->shadowSoftness * ( 1.0f / mTexSize ) );
}
void Compiler::gen_switch(const JInst & jinst)
{
assert(jinst.opcode == OPCODE_LOOKUPSWITCH
|| jinst.opcode == OPCODE_TABLESWITCH);
Opnd val = vstack(0, true).as_opnd();
vpop();
rlock(val);
gen_bb_leave(NOTHING);
if (jinst.opcode == OPCODE_LOOKUPSWITCH) {
unsigned n = jinst.get_num_targets();
for (unsigned i = 0; i < n; i++) {
Opnd key(jinst.key(i));
unsigned pc = jinst.get_target(i);
alu(alu_cmp, val, key);
br(eq, pc, m_bbinfo->start);
}
runlock(val);
br(cond_none, jinst.get_def_target(), m_bbinfo->start);
return;
}
//
// TABLESWITCH
//
alu(alu_cmp, val, jinst.high());
br(gt, jinst.get_def_target(), m_bbinfo->start);
alu(alu_cmp, val, jinst.low());
br(lt, jinst.get_def_target(), m_bbinfo->start);
AR gr_tabl = valloc(jobj);
movp(gr_tabl, DATA_SWITCH_TABLE | m_curr_inst->pc, m_bbinfo->start);
#ifdef _EM64T_
// On EM64T, we operate with I_32 value in a register, but the
// register will be used as 64 bit in address form - have to extend
sx(Opnd(i64, val.reg()), Opnd(i32, val.reg()));
#endif
// Here, we need to extract 'index-=low()' - can pack this into
// complex address form:
// [table + index*sizeof(void*) - low()*sizeof(void*)],
// but only if low()*sizeof(void*) does fit into displacement ...
int tmp = -jinst.low();
const int LO_BOUND = INT_MIN/(int)sizeof(void*);
const int UP_BOUND = INT_MAX/(int)sizeof(void*);
if (LO_BOUND<=tmp && tmp<=UP_BOUND) {
ld(jobj, gr_tabl, gr_tabl, -jinst.low()*sizeof(void*),
val.reg(), sizeof(void*));
}
else {
// ... otherwise subtract explicitly, but only if the register
// is not used anywhere else
if (rrefs(val.reg()) !=0) {
Opnd vtmp(i32, valloc(i32));
mov(vtmp, val); // make a copy of val
runlock(val);
val = vtmp;
rlock(val);
}
alu(alu_sub, val, jinst.low());
ld(jobj, gr_tabl, gr_tabl, 0, val.reg(), sizeof(void*));
}
runlock(val);
br(gr_tabl);
}
uint32_xy tBlob::size()const {
return uint32_xy( sx(), sy() );
}
