std::string Ioss::Asym_Tensor_02::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XY();
case 2: return YZ();
default: return "";
}
}
std::vector<Vector3D> Polygone::getPoints3D() const
{
std::vector<Vector3D> res;
int taille = nbPoints();
res.reserve(taille);
for(int i = 0; i < taille; i++)
res.push_back(Vector3D(XY(get(i)),0));
return res;
}
// blurColumns: perform a blur1d on each column of a rectangular matrix
void blurColumns(CRGB* leds, uint8_t width, uint8_t height, fract8 blur_amount)
{
// blur columns
uint8_t keep = 255 - blur_amount;
uint8_t seep = blur_amount >> 1;
for( uint8_t col = 0; col < width; col++) {
CRGB carryover = CRGB::Black;
for( uint8_t i = 0; i < height; i++) {
CRGB cur = leds[XY(col,i)];
CRGB part = cur;
part.nscale8( seep);
cur.nscale8( keep);
cur += carryover;
if( i) leds[XY(col,i-1)] += part;
leds[XY(col,i)] = cur;
carryover = part;
}
}
}
static void show_rgb(){
for(uint8_t j = 0; j < 8; j++){
for(uint8_t i = 0; i < WIDTH; i++){
leds[XY(i,j)] = CRGB::Red;
}
}
for(uint8_t j = 8; j < 16; j++){
for(uint8_t i = 0; i < WIDTH; i++){
leds[XY(i,j)] = CRGB::Green;
}
}
for(uint8_t j = 16; j < HEIGHT; j++){
for(uint8_t i = 0; i < WIDTH; i++){
leds[XY(i,j)] = CRGB::Blue;
}
}
}
static void rtbox(double r,double theta,double wtheta,const char *label) {
coord v[4];
double htheta,hr;
htheta=wtheta/2;
hr=r*htheta;
v[0]=rt(r-hr,theta-htheta);
v[1]=rt(r+hr,theta-htheta);
v[2]=rt(r+hr,theta+htheta);
v[3]=rt(r-hr,theta+htheta);
startgroup();
printf("<path "LT" d=\"M%f %f L%f %f L%f %f L%f %f Z\"/>\n",
XY(v[0]),XY(v[1]),XY(v[2]),XY(v[3]));
crosshair(rt(r,theta),5);
text_cen(rt(r+0.8*hr,theta),theta,24,label);
endgroup();
}
/**
* TBD
*
* @param f_draw TBD
* @param f_reset_history TBD
*/
void init_new_game( const int f_draw, const int f_reset_history ) {
int k, x, y;
/*--- By default, computer has black, play has white ---*/
code_computer = CODE_WHITE;
code_human = CODE_BLACK;
color_to_play = CODE_BLACK; // Next color to play
/*--- Initialize the board ---*/
for ( k = 0; k < 9; k++ )
board[XY( 0, k )] = board[XY( k, 9 )] = board[XY( 9, 9 - k )] = board[XY( 9 - k, 0 )] = CODE_AROUND;
for ( x = 1; x <= 8; x++ )
for ( y = 1; y <= 8; y++ )
board[XY( x, y )] = CODE_EMPTY;
board[XY( 4, 4 )] = CODE_WHITE;
board[XY( 4, 5 )] = CODE_BLACK;
board[XY( 5, 4 )] = CODE_BLACK;
board[XY( 5, 5 )] = CODE_WHITE;
/*--- Cumul time played by each color ---*/
if ( f_reset_history ) {
time( &t_start ); // Time when player starts thinking
ctime_black = ctime_white = 0;
show_horo( );
}
/*--- Draw the complete board ---*/
if ( f_draw )
if ( board_drawing_area->window )
redraw_board( );
compute_nb_pawns( f_draw );
/*--- Show the possibilities of the player ---*/
if ( f_draw )
show_poss_play_cursor( code_human, code_computer );
/*--- Reset history of the game ---*/
if ( f_reset_history )
clear_hist_list( );
/*--- Reset msg ---*/
computer_infos_msg( " " );
player_infos_msg( "Choose a position and click to play." );
/*--- Disable the menu option 'Save the game' ---*/
enable_SaveGame( FALSE );
} // init_new_game
std::string Ioss::Matrix_22::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
case 2: return XY();
case 3: return YX();
case 4: return YY();
default: return "";
}
}
//-----------------------------------------------------------------------------
void StamFluidSolver::MouseDown(float _u, float _v, int button)
{
if(button > 4 || button < 0) return;
int idx = XY(_u,_v);
if(idx >= _gridCellsCount || idx < 0) {
printf("idx out of bounds:%d\n",idx);
return;
}
_touchLocations[button] = idx;
//dens[idx] = 1.0f;
}
static void makegauss(struct ctx *k, unsigned int sizeb)
{
assert(sizeb >= 1 && sizeb <= MAX_SIZEB);
memset(k, 0, sizeof(*k));
av_lfg_init(&k->avlfg, 123);
k->sizeb = sizeb;
k->size = 1 << k->sizeb;
k->size2 = k->size * k->size;
k->gauss_radius = k->size / 2 - 1;
k->gauss_middle = XY(k, k->gauss_radius, k->gauss_radius);
unsigned int gauss_size = k->gauss_radius * 2 + 1;
unsigned int gauss_size2 = gauss_size * gauss_size;
for (index_t c = 0; c < k->size2; c++)
k->gauss[c] = 0;
double sigma = -log(1.5 / UINT64_MAX * gauss_size2) / k->gauss_radius;
for (index_t gy = 0; gy <= k->gauss_radius; gy++) {
for (index_t gx = 0; gx <= gy; gx++) {
int cx = (int)gx - k->gauss_radius;
int cy = (int)gy - k->gauss_radius;
int sq = cx * cx + cy * cy;
double e = exp(-sqrt(sq) * sigma);
uint64_t v = e / gauss_size2 * UINT64_MAX;
k->gauss[XY(k, gx, gy)] =
k->gauss[XY(k, gy, gx)] =
k->gauss[XY(k, gx, gauss_size - 1 - gy)] =
k->gauss[XY(k, gy, gauss_size - 1 - gx)] =
k->gauss[XY(k, gauss_size - 1 - gx, gy)] =
k->gauss[XY(k, gauss_size - 1 - gy, gx)] =
k->gauss[XY(k, gauss_size - 1 - gx, gauss_size - 1 - gy)] =
k->gauss[XY(k, gauss_size - 1 - gy, gauss_size - 1 - gx)] = v;
}
}
uint64_t total = 0;
for (index_t c = 0; c < k->size2; c++) {
uint64_t oldtotal = total;
total += k->gauss[c];
assert(total >= oldtotal);
}
}
// out_matrix is a reactangular tsize * tsize array, where tsize = (1 << size).
void mp_make_fruit_dither_matrix(float *out_matrix, int size)
{
struct ctx *k = talloc(NULL, struct ctx);
makegauss(k, size);
makeuniform(k);
float invscale = k->size2;
for(index_t y = 0; y < k->size; y++) {
for(index_t x = 0; x < k->size; x++)
out_matrix[x + y * k->size] = k->unimat[XY(k, x, y)] / invscale;
}
talloc_free(k);
}
static void SoftkeyRender(const char* text, s3eDeviceSoftKeyPosition pos, void(*handler)())
{
// TODO: Hardocoded font width and height (boo!)
int width = 7;
int height = 30;
width *= strlen(text) * 2;
int x = 0;
int y = 0;
switch (pos)
{
case S3E_DEVICE_SOFTKEY_BOTTOM_LEFT:
y = IwGxGetScreenHeight() - height;
x = 0;
break;
case S3E_DEVICE_SOFTKEY_BOTTOM_RIGHT:
y = IwGxGetScreenHeight() - height;
x = IwGxGetScreenWidth() - width;
break;
case S3E_DEVICE_SOFTKEY_TOP_RIGHT:
y = 0;
x = IwGxGetScreenWidth() - width;
break;
case S3E_DEVICE_SOFTKEY_TOP_LEFT:
x = 0;
y = 0;
break;
}
CIwMaterial *fadeMat = IW_GX_ALLOC_MATERIAL();
fadeMat->SetAlphaMode(CIwMaterial::SUB);
IwGxSetMaterial(fadeMat);
IwGxPrintString(x + 10, y+10, text, false);
CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
memset(cols, 50, sizeof(CIwColour)*4);
if (s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_PRESSED)
{
int pointerx = s3ePointerGetX();
int pointery = s3ePointerGetY();
if (pointerx >= x && pointerx <= x+width && pointery >=y && pointery <= y+height)
{
memset(cols, 15, sizeof(CIwColour)*4);
handler();
}
}
// Draw button area
CIwSVec2 XY(x, y-2), dXY(width, height);
IwGxDrawRectScreenSpace(&XY, &dXY, cols);
}
static void print(struct ctx *k)
{
#if 0
puts("#include <stdint.h>");
printf("static const int mp_dither_size = %d;\n", k->size);
printf("static const int mp_dither_size2 = %d;\n", k->size2);
printf("static const uint16_t mp_dither_matrix[] = {\n");
for(index_t y = 0; y < k->size; y++) {
printf("\t");
for(index_t x = 0; x < k->size; x++)
printf("%4"PRIuFAST32", ", k->unimat[XY(k, x, y)]);
printf("\n");
}
puts("};");
#else
for(index_t y = 0; y < k->size; y++) {
for(index_t x = 0; x < k->size; x++)
r[XY(k, x, y)] = k->unimat[XY(k, x, y)];
}
#endif
}
void bprintf(soul_t *ptr)
{
while(buf->u == 0)
;
tools("clear", NULL);
XY(15, 0);
// printf(" THIS IS A STOP FOR THE MENU \n"); // Shows where buffer will end.
XY(0, 0);
menus(ptr, 1);
menus(ptr->o, 1);
printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
for(int n = 0; n < STRINGS; n++)
{
if(buf->s[n] != NULL)
printf(" %s \n", buf->s[n]);
}
printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
buf->u = 0;
menus(ptr, 2);
menus(ptr->o, 2);
}
glm::vec3 Material::GetImageColorInterp(const glm::vec2 &uv_coord, const QImage* const& image)
{
if(image == NULL || uv_coord.x < 0 || uv_coord.y < 0 || uv_coord.x >= 1.0f || uv_coord.y >= 1.0f)
{
return glm::vec3(1,1,1);
}
else
{
//Use bilinear interp.
float X = image->width() * uv_coord.x;
float Y = image->height() * (1.0f - uv_coord.y);
glm::vec2 floors = glm::vec2(floor(X), floor(Y));
glm::vec2 ceils = glm::vec2(ceil(X), ceil(Y));
ceils = glm::min(ceils, glm::vec2(image->width()-1, image->height()-1));
QColor qll = image->pixel(floors.x, floors.y); glm::vec3 ll(qll.red(), qll.green(), qll.blue());
QColor qlr = image->pixel(ceils.x, floors.y); glm::vec3 lr(qlr.red(), qlr.green(), qlr.blue());
QColor qul = image->pixel(floors.x, ceils.y); glm::vec3 ul(qul.red(), qul.green(), qul.blue());
QColor qur = image->pixel(ceils.x, ceils.y); glm::vec3 ur(qur.red(), qur.green(), qur.blue());
float distX = (X - floors.x);
glm::vec3 color_low = ll * (1-distX) + lr * distX;
glm::vec3 color_high = ul * (1-distX) + ur * distX;
float distY = (Y - floors.y);
glm::vec3 result = (color_low * (1 - distY) + color_high * distY)/255.0f;
return result;
glm::vec2 XY(X,Y);
//Want floor and ceil of both X and Y
//Do square interp of <X,Y>
float dist_ll = glm::distance(XY, floors);
float dist_lr = glm::distance(XY, glm::vec2(ceils.x, floors.y));
float dist_ul = glm::distance(XY, glm::vec2(floors.x, ceils.y));
float dist_ur = glm::distance(XY, ceils);
float sum = dist_ll + dist_lr + dist_ul + dist_ur;
float llc = (1 - dist_ll/sum);
float lrc = (1 - dist_lr/sum);
float ulc = (1 - dist_ul/sum);
float urc = (1 - dist_ur/sum);
float checksum = llc + lrc + ulc + urc;
glm::vec3 final_color = llc * ll + lrc * lr + ulc * ul + urc * ur;
return final_color/255.0f;
}
}
void newGame(bool doLoadGame) {
// Zero data store
memset(&s_pieces, 0, BOARD_PIECES_X * BOARD_PIECES_Y * sizeof(Piece_t));
memset(&s_score, 0, sizeof(Score_t));
if (doLoadGame == true) {
loadGame();
} else { // new game
// Init score
s_score.level = 1;
s_score.lives = 3;
s_score.pointsToNextLevel = 200;
s_score.nColoursActive = 5;
#ifdef DEBUG_MODE
s_score.nColoursActive = 3; // Allows to test long runs and interaction of special pieces with ease
#endif
}
updateLevelColour();
int offset = BOARD_SIZE_Y * SUB_PIXEL;
for (int y = BOARD_PIECES_Y-1; y >= 0; --y) {
for (int x = 0; x < BOARD_PIECES_X; ++x) {
if (doLoadGame == false) {
bool placing = true;
while (placing) {
s_pieces[ XY(x,y) ].colour = (rand() % s_score.nColoursActive) + 1;
placing = checkLocation(GPoint(x,y)); // if match found then we're still placing as we need to try again
}
}
s_pieces[ XY(x,y) ].loc.x = x * PIECE_SUB_PIXELS; // Set location
s_pieces[ XY(x,y) ].loc.y = (y * PIECE_SUB_PIXELS) - offset; // Lets pieces fall in
}
offset += PIECE_SUB_PIXELS;
}
checkTiltMode();
s_hintStatus = getHintStatus(); // Only want to read this once from store
s_scoreState = kWait;
s_gameState = kSettleBoard;
s_gameOverMessage = false;
}
void
setup(void)
{
register i, j;
register Pin *p;
pininit();
for(i = 0; i < 6; i++){
if(b.v[i].npins == 0) continue;
for(j = b.v[i].npins, p = b.v[i].pins; j > 0; j--, p++)
pinlook(XY(p->p.x, p->p.y), i+1);
}
}
std::string Ioss::Sym_Tensor_33::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
case 2: return YY();
case 3: return ZZ();
case 4: return XY();
case 5: return YZ();
case 6: return ZX();
default: return "";
}
}
Mesh PaterneQuad::remplissageBord(Vector2D &point1Batiment0, Vector2D &point2Batiment0, Vector2D &point2Batiment1, Vector2D &point3Batiment1)
{
Mesh retour;
float dExterne = distance( point1Batiment0, point3Batiment1);
float dInterne = distance( point2Batiment0, point2Batiment1);
Vector2D vecteurDirectionExt = (point3Batiment1 - point1Batiment0).normalised();
Vector2D vecteurDirectionInt = (point2Batiment1 - point2Batiment0).normalised();
if(dExterne > _par->minLargeurBatiment && dInterne > _par->minLargeurBatiment){
int nbminBat = dExterne/_par->maxLargeurBatiment;
int nbmaxBat = dExterne/_par->minLargeurBatiment;
float aleatoire = 0;
if(nbminBat != nbmaxBat){
aleatoire = nbminBat + 1 + (rand()%(nbmaxBat-nbminBat));
}
else{
aleatoire = nbminBat;
}
float largeurBatiment = dExterne / aleatoire;
for(int i=0; i < aleatoire; i++){
Vector2D p0 = point1Batiment0 + vecteurDirectionExt*i*largeurBatiment;
Vector2D p1 = point1Batiment0 + vecteurDirectionExt*(i+1)*largeurBatiment;
Vector2D p2 = point2Batiment0 + vecteurDirectionInt*distance(p1, point1Batiment0)*dInterne/dExterne;
Vector2D p3 = point2Batiment0 + vecteurDirectionInt*distance(p0, point1Batiment0)*dInterne/dExterne;
Batiment m = Batiment( Vector3D(XY(p0)), Vector3D(XY(p1)), Vector3D(XY(p2)), Vector3D(XY(p3)), _par );
retour.merge(m.generate());
}
}
return retour;
}
inline void
clip_to_rect_one_step(const Polygon& polygon, Polygon& result, const Filter& filter)
{
double sx, sy, px, py, bx, by;
bool sinside, pinside;
result.clear();
if (polygon.size() == 0)
{
return;
}
sx = polygon.back().x;
sy = polygon.back().y;
for (Polygon::const_iterator i = polygon.begin(); i != polygon.end(); ++i)
{
px = i->x;
py = i->y;
sinside = filter.is_inside(sx, sy);
pinside = filter.is_inside(px, py);
if (sinside ^ pinside)
{
filter.bisect(sx, sy, px, py, &bx, &by);
result.push_back(XY(bx, by));
}
if (pinside)
{
result.push_back(XY(px, py));
}
sx = px;
sy = py;
}
}
bool settleBoard() {
bool settled = true;
for (int x=0; x < BOARD_PIECES_X; ++x) {
for (int y=0; y < BOARD_PIECES_Y; ++y) {
int floor = y * PIECE_PIXELS * SUB_PIXEL;
if (s_pieces[XY(x,y)].loc.y < floor) { // Still needs to fall
if (s_pieces[XY(x,y)].v == 0) s_pieces[XY(x,y)].v = PIECE_PIXELS * s_currentRun; // Keep the momentum going with a increasing initial speed
s_pieces[XY(x,y)].v += GRAVITY;
s_pieces[XY(x,y)].loc.y += s_pieces[XY(x,y)].v;
settled = false;
} else if (s_pieces[XY(x,y)].v > 0) { // Has fallen too far
s_pieces[XY(x,y)].v = 0;
s_pieces[XY(x,y)].loc.y = floor;
} else { // Is in place. As we're searching top-down, everything below must also be in place too.
break; // Efficiency - break the inner loop early
}
}
}
if (settled == true) s_gameState = kFindMatches;
return true; // redraw, we're moving things
}
void PhysicsObject::Drop(void)
{
m_airborne = true;
// Set spatial stats
m_spatialKin.height = m_DropHeight;
m_spatialKin.velocity.x = m_spatialKin.velocity.y = 0;
// Compute the on-screen angle of travel
m_screenKin.angle = ComputeScreenAngle();
m_additiveScreenVelocity = XY (0, 0);
// Determine the on-screen velocities
m_screenKin.velocity.x = m_additiveScreenVelocity.x;
m_screenKin.velocity.y = m_additiveScreenVelocity.y + (m_spatialKin.velocity.y * -3/4); // Multiply by a negative as the axis for the coordinates are swapped
}
int main(void)
{
int y = 2;
printf("%.3f, %d\n", CUBE(1.2), CUBE(y + 3));
printf("%d, %d\n", NMOD_4(7.9), NMOD_4(17));
printf("%.3f\n", XY(14.0,.3f));
test_nelms_macro();
test_toupper();
test_disp();
return 0;
}
void RoomFire_Upper::Update(int delta)
{
// Drop Snowflakes
if (rand() % ASH_CHANCE == 0)
{
// Drop it above a random position within the world
XY dropAbove = XY(
rand()%int(m_Size.x-2*TILE_SIZE)+TILE_SIZE,
rand()%int(m_Size.y-5*TILE_SIZE)+4*TILE_SIZE
);
ParticleAsh* ashParticle = new ParticleAsh(x + dropAbove.x, y + dropAbove.y, 1000);
//ParticleSimple* snowParticle = new ParticleSimple(100, 100, 100);
g_game->addGameObject(ashParticle);
ashParticle->Drop();
}
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[]) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
long n=static_cast<long>(dimsX[0]);
long M=static_cast<long>(dimsX[1]);
plhs[0]=createMatrix<T>(n,M);
T* prXY=reinterpret_cast<T*>(mxGetPr(plhs[0]));
Matrix<T> X(prX,n,M);
Matrix<T> XY(prXY,n,M);
XY.copy(X);
XY.invSym();
}
void CEndGameState::Render()
{
IW_CALLSTACK("CEndGameState::Render");
IwGxClear(IW_GX_COLOUR_BUFFER_F | IW_GX_DEPTH_BUFFER_F);
GetWorld().Render();
IwGxLightingOff();
IwGxSetScreenSpaceOrg( &CIwSVec2::g_Zero );
CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
memset(cols, 255, sizeof(CIwColour) * 4 );
if (GetWorld().GetUICar()->GetPosition() == 1 )
{
CIwMaterial* mat = (CIwMaterial *)IwGetResManager()->GetGroupNamed("ui")->GetResNamed("youwin", IW_GX_RESTYPE_MATERIAL);
IwGxSetMaterial(mat);
}
else
{
CIwMaterial* mat = (CIwMaterial *)IwGetResManager()->GetGroupNamed("ui")->GetResNamed("youlose", IW_GX_RESTYPE_MATERIAL);
IwGxSetMaterial(mat);
}
const uint32 imageWidth = 128;
const uint32 imageHeight = 32;
CIwSVec2 XY( (int16)((IwGxGetScreenWidth()/2) - (imageWidth/2)), (int16)(IwGxGetScreenHeight()/4) ),
dXY( (int16)imageWidth, (int16)imageHeight );
IwGxDrawRectScreenSpace(&XY, &dXY, cols);
IwGxLightingOn();
IwGxFlush();
IwGxSwapBuffers();
#ifdef IW_DEBUG
// Reset metrics for next frame
IwGxMetricsReset();
#endif
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[]) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should not be sparse");
T* prV = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
int n=static_cast<int>(dimsX[0]);
int M=static_cast<int>(dimsX[1]);
Vector<T> X(prV,n*M);
const int offset = static_cast<int>(mxGetScalar(prhs[1]));
plhs[0]=createMatrix<T>(n*M,1);
T* prXY=reinterpret_cast<T*>(mxGetPr(plhs[0]));
Vector<T> XY(prXY,n*M);
XY.copy(X);
XY.applyBayerPattern(offset);
}
void SoRing::rayPick(SoRayPickAction * action)
{
// Is it pickable ?
if ( ! shouldRayPick(action) ) return;
// compute the picking ray in our current object space
computeObjectSpaceRay(action);
SoPickedPoint* pp;
SbVec3f intersection;
SbPlane XY(SbVec3f(0,0,1),0);
if ( XY.intersect(action->getLine(), intersection) )
{
float x, y, z;
intersection.getValue(x, y, z);
// back to the case of a disk centered at (0,0)
float Xc, Yc;
center.getValue().getValue(Xc,Yc);
x -= Xc;
y -= Yc;
// within radius ?
if ( sqrt(x*x+y*y+z*z) > outerRadius.getValue() ) return;
if ( sqrt(x*x+y*y+z*z) < innerRadius.getValue() ) return;
// within angular section ?
float theta = sweepAngle.getValue();
float angle = atan2(y,x);
if ( angle < 0. ) angle += 2*M_PI;
if ( theta != 360 &&
angle*180.F/M_PI > theta ) return;
if ( action->isBetweenPlanes(intersection) &&
(pp = action->addIntersection(intersection)) != NULL )
{
pp->setObjectNormal(normal);
pp->setObjectTextureCoords(SbVec4f(0.5f*(1+cos(angle)),
0.5f*(1+sin(angle)), 0, 1));
}
}
}
void
chkpins(Chip *c)
{
register i, j;
long bestd;
short bpin;
if(c->type->tt[0] == 0)
return;
for(i = 0; i < c->npins; i++)
if(j = pinlook(XY(c->pins[i].p.x, c->pins[i].p.y), 0))
if(c->type->tt[i] != ttnames[j-1]){
nnprep(b.v[j-1].pins, b.v[j-1].npins);
nn(c->pins[i].p, &bestd, &bpin);
if(bestd)
fprint(1, "*****check nn ERK!! get help %ld : %d\n", bestd, bpin);
fprint(1, "%s.%d (tt=%c) coincides with %s.%d at %p\n",
c->name, i+c->pmin, c->type->tt[i],
b.v[j-1].name, bpin, c->pins[i].p);
}
}
void PhysicsObject::Launch(int angleSuppression, int speedOverride)
{
m_airborne = true;
// Call any overridden OnLaunch code
OnLaunch();
// The spatial launch angle
m_spatialKin.SetAngleBySuppression(angleSuppression);
// The scalar launch speed
int speed = (speedOverride >= 0)? speedOverride : ComputeSpeedForDistance();
// Derive the velocity from the speed and angle
m_spatialKin.SetVelocityFromScalar(speed);
// Compute the on-screen angle of travel
m_screenKin.angle = ComputeScreenAngle();
/* This is hard to explain: Image this as the velocity of the object's shadow along
the ground. The x and y values are the components of the spatial horizontal velocities. */
m_additiveScreenVelocity = XY (
m_spatialKin.velocity.x * cos(m_screenKin.angle),
m_spatialKin.velocity.x * sin((m_pos.y > m_endPos.y) ? (m_screenKin.angle*-1) : m_screenKin.angle)
);
// Determine the on-screen velocities
// X is mapped directly as it is on screen
m_screenKin.velocity.x = m_additiveScreenVelocity.x;
/*
* Y is what you'd expect:
* The y component of the horiztonal spatial velocity,
* plus a fraction of the spatial vertical velocity
*/
m_screenKin.velocity.y = m_additiveScreenVelocity.y + (m_spatialKin.velocity.y * -3/4);
}
//-----------------------------------------------------------------------------
void StamFluidSolver::MouseDragged(float _u, float _v,float _lu, float _lv, int button)
{
if(button > 4 || button < 0) return;
int idx = XY(_u,_v);
if(idx >= _gridCellsCount || idx < 0) {
printf("idx out of bounds:%d\n",idx);
return;
}
_touchLocations[button] = idx;
//int i = (int)(_u * _NX);
//int j = (int)(_v * _NY);
//int li = (int)(_lu * _NX);
//int lj = (int)(_lv * _NY);
u[idx] = force * (_u-_lu);
v[idx] = force * (_v-_lv);
//DrawAntialiasedLine(dens, i, j, li, lj, 255);
}
