static pointer cconv(context *ctx, int n, pointer *argv)
{
iconv_t cd;
size_t inbytesleft, outbytesleft;
char *outbufp1, *outbufp2, *instrp;
size_t ret;
pointer instr=argv[2], outstr;
size_t len=vecsize(instr);
inbytesleft=len;
outbytesleft=len*2;
outbufp1= outbufp2= malloc(outbytesleft);
instrp= &(instr->c.str.chars[0]);
/* get acceptable codings by 'iconv --list' */
/* cd=iconv_open(to_code, from_code); */
/* cd=iconv_open("Shift_JIS", "EUC-JP"); */
cd=iconv_open(argv[1]->c.str.chars, argv[0]->c.str.chars);
if (cd == (iconv_t)-1) { outstr= (pointer)makeint(errno); goto conv_end;}
ret=iconv(cd, &instrp, &inbytesleft, &outbufp2, &outbytesleft);
if (ret == -1) { outstr=makeint(-errno); goto conv_end;}
else outstr=makestring(outbufp1, len*2-outbytesleft);
conv_end:
iconv_close(cd);
cfree(outbufp1);
return(outstr);
}
int main()
{
printf("\n\n\nretfl: %f\n", retfl((float)pi));
printf("retdbl: %f\n", retdbl(pi));
printf("fl2dbl: %f\n", fl2dbl((float)pi));
printf("\nobvod: %f\n", obvod(5, M_PI));
printf("fl2i: %d, %d, %d\n", fl2i(3.14), fl2i(3.5), fl2i(3.51));
float floatnums[] = {1.1, 2.2, 3.9, -2, 1, 9, 10, 88, 9, 10, -6, 12};
printf("\navg: %f\n", prumer(floatnums, sizeof(floatnums)/sizeof(*floatnums)));
printf("\nmax: %f\n", max(floatnums, sizeof(floatnums)/sizeof(*floatnums)));
printf("\narrsum: %f\n", arrsum(floatnums, sizeof(floatnums)/sizeof(*floatnums)));
printf("\n--------------------------------\n");
printf("\nvsphere: %f\n", vsphere(5, M_PI));
printf("pytha(3, 4): %f\n", pytha(3.0, 4.0));
double veca[] = {3.0, 1.0, 5.0};
double vecb[] = {2.0, -2.0, 1.0};
int veclen = 3;
vecsum(veca, vecb, veclen);
printf("vecsum: ");
for(int i=0; i<veclen; i++)
printf("%f ", veca[i]);
printf("\nvecsize: %f\n", vecsize(veca, veclen));
}
void Iwa_TiledParticlesFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
std::vector<int> lastframe;
std::vector<TLevelP> partLevel;
TPointD p_offset;
TDimension p_size(0, 0);
/*- 参照画像ポートの取得 -*/
std::vector<TRasterFxPort *> part_ports; /*- テクスチャ素材画像のポート -*/
std::map<int, TRasterFxPort *> ctrl_ports; /*- コントロール画像のポート番号／ポート -*/
int portsCount = this->getInputPortCount();
for (int i = 0; i < portsCount; ++i) {
std::string tmpName = this->getInputPortName(i);
QString portName = QString::fromStdString(tmpName);
if (portName.startsWith("T")) {
TRasterFxPort *tmpPart = (TRasterFxPort *)this->getInputPort(tmpName);
if (tmpPart->isConnected())
part_ports.push_back((TRasterFxPort *)this->getInputPort(tmpName));
} else {
portName.replace(QString("Control"), QString(""));
TRasterFxPort *tmpCtrl = (TRasterFxPort *)this->getInputPort(tmpName);
if (tmpCtrl->isConnected())
ctrl_ports[portName.toInt()] = (TRasterFxPort *)this->getInputPort(tmpName);
}
}
/*- テクスチャ素材のバウンディングボックスを足し合わせる ←この工程、いらないかも？-*/
if (!part_ports.empty()) {
TRectD outTileBBox(tile.m_pos, TDimensionD(tile.getRaster()->getLx(), tile.getRaster()->getLy()));
TRectD bbox;
for (unsigned int i = 0; i < (int)part_ports.size(); ++i) {
const TFxTimeRegion &tr = (*part_ports[i])->getTimeRegion();
lastframe.push_back(tr.getLastFrame() + 1);
partLevel.push_back(new TLevel());
partLevel[i]->setName((*part_ports[i])->getAlias(0, ri));
// The particles offset must be calculated without considering the affine's translational
// component
TRenderSettings riZero(ri);
riZero.m_affine.a13 = riZero.m_affine.a23 = 0;
// Calculate the bboxes union
for (int t = 0; t <= tr.getLastFrame(); ++t) {
TRectD inputBox;
(*part_ports[i])->getBBox(t, inputBox, riZero);
bbox += inputBox;
}
}
if (bbox == TConsts::infiniteRectD)
bbox *= outTileBBox;
p_size.lx = (int)bbox.getLx() + 1;
p_size.ly = (int)bbox.getLy() + 1;
p_offset = TPointD(0.5 * (bbox.x0 + bbox.x1), 0.5 * (bbox.y0 + bbox.y1));
} else {
partLevel.push_back(new TLevel());
partLevel[0]->setName("particles");
TDimension vecsize(10, 10);
TOfflineGL *offlineGlContext = new TOfflineGL(vecsize);
offlineGlContext->clear(TPixel32(0, 0, 0, 0));
TStroke *stroke;
stroke = makeEllipticStroke(0.07, TPointD((vecsize.lx - 1) * .5, (vecsize.ly - 1) * .5), 2.0, 2.0);
TVectorImageP vectmp = new TVectorImage();
TPalette *plt = new TPalette();
vectmp->setPalette(plt);
vectmp->addStroke(stroke);
TVectorRenderData rd(AffI, TRect(vecsize), plt, 0, true, true);
offlineGlContext->makeCurrent();
offlineGlContext->draw(vectmp, rd);
partLevel[0]->setFrame(0, TRasterImageP(offlineGlContext->getRaster()->clone()));
p_size.lx = vecsize.lx + 1;
p_size.ly = vecsize.ly + 1;
lastframe.push_back(1);
delete offlineGlContext;
}
Iwa_Particles_Engine myEngine(this, frame);
// Retrieving the dpi multiplier from the accumulated affine (which is isotropic). That is,
// the affine will be applied *before* this effect - and we'll multiply geometrical parameters
// by this dpi mult. in order to compensate.
float dpi = sqrt(fabs(ri.m_affine.det())) * 100;
TTile tileIn;
if (TRaster32P raster32 = tile.getRaster()) {
TFlash *flash = 0;
myEngine.render_particles(flash, &tile, part_ports, ri, p_size, p_offset, ctrl_ports, partLevel,
1, (int)frame, 1, 0, 0, 0, 0, lastframe, getIdentifier());
} else if (TRaster64P raster64 = tile.getRaster()) {
TFlash *flash = 0;
myEngine.render_particles(flash, &tile, part_ports, ri, p_size, p_offset, ctrl_ports, partLevel,
1, (int)frame, 1, 0, 0, 0, 0, lastframe, getIdentifier());
} else
throw TException("ParticlesFx: unsupported Pixel Type");
}
static void vehicleSubTick(Chassis* c, float dt)
{
if (g_step==0) return;
if (g_step&1) g_step = 0;
vec3* chassisPos = &c->pose.v[3].v3;
vec3* x = &c->pose.v[0].v3;
vec3* y = &c->pose.v[1].v3;
vec3* z = &c->pose.v[2].v3;
// This bit is done by the physics engine
if(1)
{
vecaddscale(chassisPos, chassisPos, &c->vel, dt);
mtx rot;
matrixRotateByVelocity(&rot, &c->pose, &c->angVel, dt);
matrixCopy33(&c->pose, &rot);
}
// Damp
vecscale(&c->vel, &c->vel, expf(-dt*1.f));
vecscale(&c->angVel, &c->angVel, expf(-dt*1.f));
if (fabsf(c->angVel.x)<0.01f) c->angVel.x = 0.f;
if (fabsf(c->angVel.y)<0.01f) c->angVel.y = 0.f;
if (fabsf(c->angVel.z)<0.01f) c->angVel.z = 0.f;
ClampedImpulse frictionImpulse[numWheels][2];
c->steer = g_steer;
//g_steer *= expf(-dt*3.f);
//g_speed *= expf(-dt*3.f);
static float latf = 10.f;
static float angSpeed = 0.f;
if (g_handBrake>0.f)
{
g_handBrake *= expf(-4.f*dt);
g_speed *= expf(-4.f*dt);
if (g_handBrake < 0.1f)
{
g_handBrake = 0.f;
}
}
// Prepare
for (int i=0; i<numWheels; i++)
{
Suspension* s = c->suspension[i];
Wheel* w = s->wheel;
// Calculate the world position and offset of the suspension point
vec3mtx33mulvec3(&s->worldOffset, &c->pose, &s->offset);
vec3mtx43mulvec3(&s->worldDefaultPos, &c->pose, &s->offset);
w->pos = s->worldDefaultPos;
vec3 pointVel = getPointVel(c, &s->worldOffset);
vecadd(&w->vel, &w->vel, &pointVel);
float maxFriction0 = 2.0f * dt * c->mass * gravity * (1.f/(float)numWheels);
clampedImpulseInit(&frictionImpulse[i][0], maxFriction0);
float latfriction = 10.f;
float newAngSpeed = vecdot(z, &c->angVel);
float changeAngSpeed = (newAngSpeed - angSpeed)/dt;
angSpeed = newAngSpeed;
printf("changeAngSpeed = %f\n", changeAngSpeed);
float speed = fabsf(vecdot(y, &c->vel));
const float base = 0.5f;
if (g_speed>=0 && i>=2)
{
latfriction = 1.f*expf(-5.f*g_handBrake) + base;
// latfriction = 1.f*expf(-2.f*fabsf(speed*changeAngSpeed)) + base;
// if (angSpeed*g_steer < -0.1f)
// {
// latfriction = base;
// }
//if (g_steer == 0.f)
//{
// latf += (10.f - latf) * (1.f - exp(-0.1f*dt));
//}
//else
//{
// latf += (0.1f - latf) * (1.f - exp(-10.f*dt));
//}
//latfriction = latf;
}
else
{
latfriction = 10.f;
}
float maxFriction1 = latfriction * dt * c->mass * gravity * (1.f/(float)numWheels);
clampedImpulseInit(&frictionImpulse[i][1], maxFriction1);
vecset(&s->hitNorm, 0.f, 0.f, 1.f);
float steer = w->maxSteer*c->steer * (1.f + 0.3f*s->offset.x*c->steer);
vecscale(&w->wheelAxis, x, cosf(steer));
vecsubscale(&w->wheelAxis, &w->wheelAxis, y, sinf(steer));
w->frictionDir[0];
veccross(&w->frictionDir[0], z, &w->wheelAxis);
w->frictionDir[1] = w->wheelAxis;
w->angSpeed = -40.f*g_speed;
}
//=============
// VERBOSE
//=============
#define verbose false
#define dump if (verbose) printf
dump("==========================================\n");
dump("START ITERATION\n");
dump("==========================================\n");
float solverERP = numIterations>1 ? 0.1f : 1.f;
float changeSolverERP = numIterations>1 ? (1.f - solverERP)/(0.01f+ (float)(numIterations-1)) : 0.f;
for (int repeat=0; repeat<numIterations; repeat++)
{
dump(" == Start Iter == \n");
for (int i=0; i<numWheels; i++)
{
Suspension* s = c->suspension[i];
Wheel* w = s->wheel;
const bool axisError = true;
const bool friction = true;
// Friction
if (friction)
{
vec3 lateralVel;
vecaddscale(&lateralVel, &w->vel, &s->hitNorm, -vecdot(&s->hitNorm, &w->vel));
vecaddscale(&lateralVel, &lateralVel, &w->frictionDir[0], +w->angSpeed * w->radius);
{
int dir = 0;
float v = vecdot(&lateralVel, &w->frictionDir[dir]);
float denom = 1.f/w->mass + w->radius*w->radius*w->invInertia;
float impulse = clampedImpulseApply(&frictionImpulse[i][dir], - solverERP * v / denom);
vec3 impulseV;
vecscale(&impulseV, &w->frictionDir[dir], impulse);
vecaddscale(&w->vel, &w->vel, &impulseV, 1.f/w->mass);
w->angSpeed = w->angSpeed + (impulse * w->radius * w->invInertia);
}
if (1)
{
int dir=1;
float v = vecdot(&lateralVel, &w->frictionDir[dir]);
float denom = 1.f/w->mass;
float impulse = clampedImpulseApply(&frictionImpulse[i][dir], - solverERP * v / denom);
vec3 impulseV;
vecscale(&impulseV, &w->frictionDir[dir], impulse);
vecaddscale(&w->vel, &w->vel, &impulseV, 1.f/w->mass);
}
//dump("gound collision errorV = %f, vel of wheel after = %f\n", penetration, vecdot(&w->vel, &s->hitNorm));
}
if (axisError) // Axis Error
{
vec3 offset;
vecsub(&offset, &w->pos, chassisPos);
vec3 pointvel = getPointVel(c, &offset);
vec3 error;
vecsub(&error, &pointvel, &w->vel);
vecaddscale(&error, &error, z, -vecdot(&error, z));
vec3 norm;
if (vecsizesq(&error)>0.001f)
{
dump("axis error %f\n", vecsize(&error));
vecnormalise(&norm, &error);
float denom = computeDenominator(1.f/c->mass, 1.f/c->inertia, &offset, &norm) + 1.f/w->mass;
vecscale(&error, &error, -solverERP/denom);
addImpulseAtOffset(&c->vel, &c->angVel, 1.f/c->mass, 1.f/c->inertia, &offset, &error);
vecaddscale(&w->vel, &w->vel, &error, -solverERP/w->mass);
}
//dump("axis error vel of wheel after = %f, inline = %f\n", vecdot(&w->vel, &s->hitNorm), vecdot(&w->vel, &s->axis));
}
}
solverERP += changeSolverERP;
}
for (int i=0; i<numWheels; i++)
{
Suspension* s = c->suspension[i];
Wheel* w = s->wheel;
vec3 pointVel = getPointVel(c, s);
// Convert suspension wheel speed back to car space
vecsub(&w->vel, &w->vel, &pointVel);
}
}
