IoObject *IoODEMass_setSphereMass(IoODEMass *self, IoObject *locals, IoMessage *m)
{
const double totalMass = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double radius = IoMessage_locals_doubleArgAt_(m, locals, 1);
dMassSetSphereTotal(DATA(self), totalMass, radius);
return self;
}
IoObject *IoODEMass_setSphereDensity(IoODEMass *self, IoObject *locals, IoMessage *m)
{
const double density = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double radius = IoMessage_locals_doubleArgAt_(m, locals, 1);
dMassSetSphere(DATA(self), density, radius);
return self;
}
IoObject *IoCairoSVGSurface_create(IoCairoSVGSurface *self, IoObject *locals, IoMessage *m)
{
char *filename = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0));
double w = IoMessage_locals_doubleArgAt_(m, locals, 1);
double h = IoMessage_locals_doubleArgAt_(m, locals, 2);
return IoCairoSurface_newWithRawSurface_(IOSTATE, m, cairo_svg_surface_create(filename, w, h));
}
IoObject *IoCairoSurface_setFallbackResolution(IoCairoSurface *self, IoObject *locals, IoMessage *m)
{
double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
cairo_surface_set_fallback_resolution(SURFACE(self), x, y);
CHECK_STATUS(self);
return self;
}
IoObject *IoCairoLinearGradient_create(IoCairoLinearGradient *self, IoObject *locals, IoMessage *m)
{
double x0 = IoMessage_locals_doubleArgAt_(m, locals, 0);
double y0 = IoMessage_locals_doubleArgAt_(m, locals, 1);
double x1 = IoMessage_locals_doubleArgAt_(m, locals, 2);
double y1 = IoMessage_locals_doubleArgAt_(m, locals, 3);
return IoCairoPattern_newWithRawPattern_(IOSTATE, m, cairo_pattern_create_linear(x0, y0, x1, y1));
}
IoObject *IoCairoPDFSurface_setSize(IoCairoPDFSurface *self, IoObject *locals, IoMessage *m)
{
double w = IoMessage_locals_doubleArgAt_(m, locals, 0);
double h = IoMessage_locals_doubleArgAt_(m, locals, 1);
cairo_pdf_surface_set_size(SURFACE(self), w, h);
CHECK_STATUS(self);
return self;
}
IoObject *IoODEBox_pointDepth(IoODEBox *self, IoObject *locals, IoMessage *m)
{
dReal lx = IoMessage_locals_doubleArgAt_(m, locals, 0);
dReal ly = IoMessage_locals_doubleArgAt_(m, locals, 1);
dReal lz = IoMessage_locals_doubleArgAt_(m, locals, 2);
IoODEBox_assertHasBoxId(self, locals, m);
return IONUMBER(dGeomBoxPointDepth(GEOMID, lx, ly, lz));
}
IoObject *IoODEJoint_setReal2(IoODEJoint *self, IoObject *locals, IoMessage *m, IoODEJointSetReal2 func)
{
dReal value1 = IoMessage_locals_doubleArgAt_(m, locals, 0);
dReal value2 = IoMessage_locals_doubleArgAt_(m, locals, 1);
IoODEJoint_assertValidJoint(self, locals, m);
func(JOINTID, value1, value2);
return self;
}
IoObject *IoCairoSurface_setDeviceOffset(IoCairoSurface *self, IoObject *locals, IoMessage *m)
{
double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
cairo_surface_set_device_offset(SURFACE(self), x, y);
CHECK_STATUS(self);
return self;
}
IoObject *IoODEBox_setLengths(IoODEBox *self, IoObject *locals, IoMessage *m)
{
dReal lx = IoMessage_locals_doubleArgAt_(m, locals, 0);
dReal ly = IoMessage_locals_doubleArgAt_(m, locals, 1);
dReal lz = IoMessage_locals_doubleArgAt_(m, locals, 2);
IoODEBox_assertHasBoxId(self, locals, m);
dGeomBoxSetLengths(GEOMID, lx, ly, lz);
return self;
}
IoObject *IoCairoContext_setSourceSurface(IoCairoContext *self, IoObject *locals, IoMessage *m)
{
IoCairoSurface *surface = IoMessage_locals_valueArgAt_(m, locals, 0);
double x = IoMessage_locals_doubleArgAt_(m, locals, 1);
double y = IoMessage_locals_doubleArgAt_(m, locals, 2);
cairo_set_source_surface(CONTEXT(self), IoCairoSurface_rawSurface(surface), x, y);
CHECK_STATUS(self);
return self;
}
IoObject *IoODEBody_addRelTorque(IoODEBody *self, IoObject *locals, IoMessage *m)
{
const double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
const double z = IoMessage_locals_doubleArgAt_(m, locals, 2);
IoODEBody_assertValidBody(self, locals, m);
dBodyAddRelTorque(BODYID, x, y, z);
return self;
}
IoObject *IoODEMass_setBoxDensity(IoODEMass *self, IoObject *locals, IoMessage *m)
{
const double density = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double lx = IoMessage_locals_doubleArgAt_(m, locals, 1);
const double ly = IoMessage_locals_doubleArgAt_(m, locals, 2);
const double lz = IoMessage_locals_doubleArgAt_(m, locals, 3);
dMassSetBox(DATA(self), density, lx, ly, lz);
return self;
}
IoObject *IoODEBody_setLinearVelocity(IoODEBody *self, IoObject *locals, IoMessage *m)
{
const double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
const double z = IoMessage_locals_doubleArgAt_(m, locals, 2);
IoODEBody_assertValidBody(self, locals, m);
dBodySetLinearVel(BODYID, x, y, z);
return self;
}
IoObject *IoODEJoint_setVector3(IoODEJoint *self, IoObject *locals, IoMessage *m, IoODEJointSetVector3Func func)
{
dReal x = IoMessage_locals_doubleArgAt_(m, locals, 0);
dReal y = IoMessage_locals_doubleArgAt_(m, locals, 1);
dReal z = IoMessage_locals_doubleArgAt_(m, locals, 2);
IoODEJoint_assertValidJoint(self, locals, m);
func(JOINTID, x, y, z);
return self;
}
IoObject *IoCairoContext_setSourceRGB(IoCairoContext *self, IoObject *locals, IoMessage *m)
{
double r = IoMessage_locals_doubleArgAt_(m, locals, 0);
double g = IoMessage_locals_doubleArgAt_(m, locals, 1);
double b = IoMessage_locals_doubleArgAt_(m, locals, 2);
cairo_set_source_rgb(CONTEXT(self), r, g, b);
CHECK_STATUS(self);
return self;
}
IoObject *IoODEMass_setBoxMass(IoODEMass *self, IoObject *locals, IoMessage *m)
{
const double totalMass = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double lx = IoMessage_locals_doubleArgAt_(m, locals, 1);
const double ly = IoMessage_locals_doubleArgAt_(m, locals, 2);
const double lz = IoMessage_locals_doubleArgAt_(m, locals, 3);
dMassSetBoxTotal(DATA(self), totalMass, lx, ly, lz);
return self;
}
IoObject *IoODEMass_setCappedCylinderMass(IoODEMass *self, IoObject *locals, IoMessage *m)
{
const double totalMass = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double direction = IoMessage_locals_doubleArgAt_(m, locals, 1);
const double radius = IoMessage_locals_doubleArgAt_(m, locals, 2);
const double length = IoMessage_locals_doubleArgAt_(m, locals, 3);
dMassSetCappedCylinderTotal(DATA(self), totalMass, direction, radius, length);
return self;
}
IoObject *IoODEPlane_setParams(IoODEPlane *self, IoObject *locals, IoMessage *m)
{
dReal a = IoMessage_locals_doubleArgAt_(m, locals, 0);
dReal b = IoMessage_locals_doubleArgAt_(m, locals, 1);
dReal c = IoMessage_locals_doubleArgAt_(m, locals, 2);
dReal d = IoMessage_locals_doubleArgAt_(m, locals, 3);
IoODEPlane_assertHasPlaneId(self, locals, m);
dGeomPlaneSetParams(GEOMID, a, b, c, d);
return self;
}
IoObject *IoODEMass_setCenterOfGravity(IoODEMass *self, IoObject *locals, IoMessage *m)
{
const double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
const double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
const double z = IoMessage_locals_doubleArgAt_(m, locals, 2);
DATA(self)->c[0] = x;
DATA(self)->c[1] = y;
DATA(self)->c[2] = z;
return self;
}
IoObject *IoCairoSurface_markDirtyRectangle(IoCairoSurface *self, IoObject *locals, IoMessage *m)
{
double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
double w = IoMessage_locals_doubleArgAt_(m, locals, 2);
double h = IoMessage_locals_doubleArgAt_(m, locals, 3);
cairo_surface_mark_dirty_rectangle(SURFACE(self), x, y, w, h);
CHECK_STATUS(self);
return self;
}
IoObject *IoRandom_value(IoObject *self, IoObject *locals, IoMessage *m)
{
/*doc Random value(optionalArg1, optionalArg2)
If called with:
<ul>
<li> no arguments, it returns a floating point
random Number between 0 and 1.
<li> one argument, it returns a floating point random
Number between 0 and optionalArg1.
<li> two arguments, it returns a floating point random
Number between optionalArg1 and optionalArg2.
</ul>
*/
double f = RandomGen_randomDouble(DATA(self));
double result = 0;
if (IoMessage_argCount(m) > 0)
{
double a = IoMessage_locals_doubleArgAt_(m, locals, 0);
if (IoMessage_argCount(m) > 1)
{
double b = IoMessage_locals_doubleArgAt_(m, locals, 1);
if (a == b )
{
result = a;
}
else
{
result = a + (b - a) * f;
}
}
else
{
if (a == 0)
{
result = 0;
}
else
{
result = a * f;
}
}
}
else
{
result = f;
}
return IONUMBER(result);
}
IO_METHOD(IoNumber, between)
{
/*doc Number between(aNumber1, aNumber2)
Returns the true if the receiver's value is between or
equal to aNumber1 and aNumber2, otherwise returns false.
*/
double a = IoMessage_locals_doubleArgAt_(m, locals, 0);
double b = IoMessage_locals_doubleArgAt_(m, locals, 1);
double n = DATA(self);
return IOBOOL(self, ((n >= a) && (n <= b)) || (n <= a && (n >= b)));
}
IoObject *IoSeq_drawQuadTo(IoSeq *self, IoObject *locals, IoMessage *m)
{
IoSeq_assertIsVector(self, locals, m);
{
IoSeq *other = IoMessage_locals_pointArgAt_(m, locals, 0);
vec2f p = IoSeq_vec2f(self);
vec2f p2 = IoSeq_vec2f(other);
double x1, y1, x2, y2;
double s = 0;
if (IoMessage_argCount(m) > 1)
{
s = IoMessage_locals_doubleArgAt_(m, locals, 1);
}
x1 = (p.x) + s;
y1 = (p.y) + s;
x2 = (p2.x) - s;
y2 = (p2.y) - s;
glBegin(GL_QUADS);
glVertex2d(x1, y1);
glVertex2d(x2, y1);
glVertex2d(x2, y2);
glVertex2d(x1, y2);
glEnd();
}
return self;
}
IoObject *IoSeq_drawLineLoopi(IoSeq *self, IoObject *locals, IoMessage *m)
{
IoSeq_assertIsVector(self, locals, m);
{
vec2f p = IoSeq_vec2f(self);
GLint x = (p.x);
GLint y = (p.y);
GLint s = 0;
if (IoMessage_argCount(m))
{
s = (GLint)IoMessage_locals_doubleArgAt_(m, locals, 0);
}
glBegin(GL_LINES);
glVertex2i(x-s, y-s);
glVertex2i(s, y-s);
glVertex2i(s, y-s);
glVertex2i(s, s);
glVertex2i(s, s);
glVertex2i(x-s, s);
glVertex2i(x-s, s);
glVertex2i(x-s, y-s);
glEnd();
}
return self;
}
IoObject *IoEventManager_setListenTimeout(IoEventManager *self, IoObject *locals, IoMessage *m)
{
double timeout = IoMessage_locals_doubleArgAt_(m, locals, 0);
struct timeval tv = timevalFromDouble(timeout);
event_loopexit(&tv);
return self;
}
IoObject *IoSeq_drawQuad(IoSeq *self, IoObject *locals, IoMessage *m)
{
IoSeq_assertIsVector(self, locals, m);
{
vec2f p = IoSeq_vec2f(self);
double x, y, w, h;
double s = 0;
if (IoMessage_argCount(m) > 1)
{
s = -IoMessage_locals_doubleArgAt_(m, locals, 1);
}
x = s;
y = s;
w = (p.x) - (s*2);
h = (p.y) - (s*2);
glBegin(GL_QUADS);
glVertex2d(w, h);
glVertex2d(x, h);
glVertex2d(x, y);
glVertex2d(w, y);
glEnd();
}
return self;
}
IOIMAGE_API IoObject *IoImage_filterGauss(IoImage *self, IoObject *locals, IoMessage *m)
{
/*doc Image filterGauss(sigma)
Returns new image as a result of applying filter. Implements Gauss smoothing filtering with parameter sigma.
*/
double sigma = IoMessage_locals_doubleArgAt_(m, locals, 0);
int filterSize = round(sigma * 2.5) * 2 + 1;
UArray* filter = UArray_new();
UArray_setItemType_(filter, CTYPE_int8_t);
UArray_setEncoding_(filter, CENCODING_NUMBER);
UArray_setSize_(filter, filterSize * filterSize);
int8_t *filterBytes = UArray_mutableBytes(filter);
int x, y, x1, y1;
for(y = 0; y < filterSize; y++)
{
y1 = y - filterSize / 2;
for(x = 0; x < filterSize; x++)
{
x1 = x - filterSize / 2;
filterBytes[x + y * filterSize] = exp(-(x1*x1 + y1*y1)/2/sigma) * filterSize * filterSize * 2;
}
}
IoImage* toReturn = IoImage_newWithImage_(IOSTATE, Image_applyLinearFilter(DATA(self)->image, filterSize, filterSize, filter));
UArray_free(filter);
return toReturn;
}
IoObject *IoODEJoint_setParam(IoODEJoint *self, IoObject *locals, IoMessage *m, int parameter, IoODEJointSetParamFunc func)
{
dReal value = IoMessage_locals_doubleArgAt_(m, locals, 0);
IoODEJoint_assertValidJoint(self, locals, m);
func(JOINTID, parameter, value);
return self;
}
IO_METHOD(IoNumber, clip)
{
/*doc Number clip(aNumber1, aNumber2)
Returns self if the receiver is between aNumber1 and aNumber2.
Returns aNumber1 if it is less than aNumber1. Returns aNumber2 if it is greater than aNumber2.
*/
double a = IoMessage_locals_doubleArgAt_(m, locals, 0);
double b = IoMessage_locals_doubleArgAt_(m, locals, 1);
double n = DATA(self);
if (n < a) n = a;
if (n > b) n = b;
return IONUMBER(n);
}
