/*! \todo Finish function documentation!!!
* \brief
* \par Function Description
*
*/
SCM g_rc_paper_sizes(SCM scm_papername, SCM scm_width, SCM scm_height)
#define FUNC_NAME "paper-sizes"
{
int width;
int height;
char *papername;
SCM ret;
SCM_ASSERT (scm_is_string (scm_papername), scm_papername,
SCM_ARG1, FUNC_NAME);
SCM_ASSERT (SCM_NIMP (scm_width) && SCM_REALP (scm_width), scm_width,
SCM_ARG2, FUNC_NAME);
SCM_ASSERT (SCM_NIMP (scm_height) && SCM_REALP (scm_height), scm_height,
SCM_ARG3, FUNC_NAME);
papername = SCM_STRING_CHARS (scm_papername);
width = (int) (scm_to_double (scm_width) * MILS_PER_INCH);
height = (int) (scm_to_double (scm_height) * MILS_PER_INCH);
if (!s_papersizes_uniq(papername)) {
ret = SCM_BOOL_F;
} else {
s_papersizes_add_entry(papername, width, height);
ret = SCM_BOOL_T;
}
return ret;
}
static SCM
thit_new_model(SCM s_max_rows, SCM s_bds_disc, SCM s_n_cont, SCM s_dp_weight,
SCM s_init_crosstab, SCM s_lambda_a, SCM s_lambda_b)
{
int max_rows = scm_to_int(s_max_rows);
int n_cont = scm_to_int(s_n_cont);
double dp_weight = scm_to_double(s_dp_weight);
double init_crosstab = scm_to_double(s_init_crosstab);
double lambda_a = scm_to_double(s_lambda_a);
double lambda_b = scm_to_double(s_lambda_b);
int n_disc = scm_to_int(scm_length(s_bds_disc));
gsl_vector_int *bds_disc = gsl_vector_int_alloc(n_disc);
int i, b;
for (i = 0; i < n_disc; i++) {
b = scm_to_int(scm_list_ref(s_bds_disc, scm_from_int(i)));
gsl_vector_int_set(bds_disc, i, b);
}
banmi_model_t *model = new_banmi_model(max_rows, bds_disc, n_cont, dp_weight,
init_crosstab, lambda_a, lambda_b);
SCM smob;
SCM_NEWSMOB(smob, thit_model_tag, model);
return smob;
}
/*! \todo Finish function description!!!
* \brief
* \par Function Description
*
* \param [in] width
* \param [in] height
* \param [in] border
* \return SCM_BOOL_T always.
*/
SCM g_rc_world_size(SCM width, SCM height, SCM border)
#define FUNC_NAME "world-size"
{
int i_width, i_height, i_border;
int init_right, init_bottom;
SCM_ASSERT (SCM_NIMP (width) && SCM_REALP (width), width,
SCM_ARG1, FUNC_NAME);
SCM_ASSERT (SCM_NIMP (height) && SCM_REALP (height), height,
SCM_ARG2, FUNC_NAME);
SCM_ASSERT (SCM_NIMP (border) && SCM_REALP (border), border,
SCM_ARG3, FUNC_NAME);
/* yes this is legit, we are casing the resulting double to an int */
i_width = (int) (scm_to_double (width) * MILS_PER_INCH);
i_height = (int) (scm_to_double (height) * MILS_PER_INCH);
i_border = (int) (scm_to_double (border) * MILS_PER_INCH);
PAPERSIZEtoWORLD(i_width, i_height, i_border,
&init_right, &init_bottom);
#if DEBUG
printf("%d %d\n", i_width, i_height);
printf("%d %d\n", init_right, init_bottom);
#endif
default_init_right = init_right;
default_init_bottom = init_bottom;
return SCM_BOOL_T;
}
SCM script_ogre_set_position(SCM s_obj, SCM s_x, SCM s_y, SCM s_z)
{
void *obj = (void*)scm_to_uint64(s_obj);
float x = scm_to_double(s_x), y = scm_to_double(s_y), z = scm_to_double(s_z);
ogre_set_position(obj, x, y, z);
return scm_from_int32(1);
}
SCM __api_make_projectile(SCM name, SCM x, SCM y, SCM rotation, SCM spawned_by)
{
char *s = scm_to_locale_string(name);
item *sb = (item *) SCM_SMOB_DATA(spawned_by);
projectile *p = make_projectile(s, scm_to_double(x), scm_to_double(y), scm_to_double(rotation), sb);
free(s);
SCM ret = scm_new_smob(__api_projectile_tag, (unsigned long) p);
scm_gc_protect_object(ret);
return ret;
}
SCM __api_make_fx(SCM type, SCM col, SCM x, SCM y, SCM dim, SCM radius, SCM speed)
{
color c = *((color *) SCM_SMOB_DATA(col));
SCM ret = scm_new_smob(__api_effect_tag,
(unsigned long) make_fx(scm_to_int(type), c,
scm_to_double(x), scm_to_double(y), scm_to_int(dim),
scm_to_int(radius), scm_to_double(speed)));
scm_gc_protect_object(ret);
return ret;
}
/*! \todo Finish function documentation!!!
* \brief
* \par Function Description
*
*/
SCM g_rc_paper_size(SCM width, SCM height)
#define FUNC_NAME "paper-size"
{
SCM_ASSERT (SCM_NIMP (width) && SCM_REALP (width), width,
SCM_ARG1, FUNC_NAME);
SCM_ASSERT (SCM_NIMP (height) && SCM_REALP (height), height,
SCM_ARG2, FUNC_NAME);
/* yes this is legit, we are casting the resulting double to an int */
default_paper_width = (int) (scm_to_double (width) * MILS_PER_INCH);
default_paper_height = (int) (scm_to_double (height) * MILS_PER_INCH);
return SCM_BOOL_T;
}
static SCM
play_sample (SCM sample_smob, SCM s_gain, SCM s_pan, SCM s_speed)
{
Sample *sample = check_sample (sample_smob);
float gain = scm_to_double (s_gain);
float pan = scm_to_double (s_pan);
float speed = scm_to_double (s_speed);
if (sample->sample) {
al_play_sample (sample->sample, gain, pan, speed, ALLEGRO_PLAYMODE_ONCE, NULL);
}
return SCM_UNSPECIFIED;
}
static SCM tortoise_turn(SCM degrees)
{
const double value = scm_to_double(degrees);
direction += M_PI / 180.0 * value;
return scm_from_double(direction * 180.0 / M_PI);
}
SCM tf_set_attr_float(SCM scm_description, SCM scm_name, SCM scm_value)
{
struct tf_description_t *self = get_tf_description(scm_description);
char *name = scm_to_locale_string(scm_name);
TF_SetAttrFloat(self->description, name, (float)scm_to_double(scm_value));
free(name);
return SCM_UNDEFINED;
}
SCM __api_build_projectile_prototype(SCM name, SCM speed, SCM w, SCM h, SCM longevity, SCM dmg)
{
char *s = scm_to_locale_string(name);
projectile *p = build_projectile_prototype(s, scm_to_double(speed), scm_to_int(w), scm_to_int(h), scm_to_int(longevity), scm_to_int(dmg));
free(s);
SCM ret = scm_new_smob(__api_projectile_tag, (unsigned long) p);
scm_gc_protect_object(ret);
return ret;
}
SCM ambient_light_range(SCM lower_bound, SCM upper_bound)
{
io_connect_t ioPort;
int leftLight, rightLight;
io_service_t serviceObject = IOServiceGetMatchingService(kIOMasterPortDefault, IOServiceMatching("AppleLMUController"));
if (serviceObject)
{
IOServiceOpen(serviceObject, mach_task_self(), 0, &ioPort);
IOObjectRelease(serviceObject);
}
IOConnectMethodScalarIScalarO(ioPort, 0, 0, 2, &leftLight, &rightLight);
return scm_from_int(((leftLight+rightLight)/4096.0 > scm_to_double(lower_bound)) &&
((leftLight+rightLight)/4096.0 < scm_to_double(upper_bound)));
}
SCM make_Segment2_line(SCM X1, SCM Y1, SCM X2, SCM Y2)
{
SCM smob;
Segment2 * seg;
DB_PRINTF("make_Segment2_line\n");
seg = malloc(sizeof(Segment2));
seg->type = LINE;
seg->s.line.start.x = scm_to_double(X1);
seg->s.line.start.y = scm_to_double(Y1);
seg->s.line.end.x = scm_to_double(X2);
seg->s.line.end.y = scm_to_double(Y2);
SCM_NEWSMOB( smob, tag_Segment2, seg);
return smob;
}
bool updateTimer(guihckContext* ctx, guihckElementId id, void* data)
{
(void) data;
bool running = scm_is_true(guihckElementGetProperty(ctx, id, "running"));
if(running)
{
double nextTimeout = scm_to_double(guihckElementGetProperty(ctx, id, "next-timeout"));
double current = guihckContextGetTime(ctx);
if(nextTimeout < 0)
{
double interval = scm_to_double(guihckElementGetProperty(ctx, id, "interval"));
guihckElementProperty(ctx, id, "next-timeout", scm_from_double(current + interval));
guihckElementProperty(ctx, id, "cycle", scm_from_int32(0));
}
else if(current >= nextTimeout)
{
int repeat = scm_to_int32(guihckElementGetProperty(ctx, id, "repeat"));
int cycle = scm_to_int32(guihckElementGetProperty(ctx, id, "cycle"));
cycle += 1;
if(repeat < 0 || repeat > cycle)
{
double interval = scm_to_double(guihckElementGetProperty(ctx, id, "interval"));
guihckElementProperty(ctx, id, "next-timeout", scm_from_double(nextTimeout + interval));
}
else
{
running = false;
guihckElementProperty(ctx, id, "next-timeout", scm_from_double(-1));
guihckElementProperty(ctx, id, "running", SCM_BOOL_F);
}
guihckElementProperty(ctx, id, "cycle", scm_from_int32(cycle));
SCM onTimeout = guihckElementGetProperty(ctx, id, "on-timeout");
guihckStackPushElement(ctx, id);
SCM expression = scm_list_2(onTimeout, scm_from_int32(cycle));
guihckContextExecuteExpression(ctx, expression);
guihckStackPopElement(ctx);
}
}
return running;
}
SCM make_Segment2_arc(SCM ROT, SCM X, SCM Y, SCM Radius, SCM startTheta, SCM endTheta)
{
SCM smob;
Segment2 * seg;
DB_PRINTF("make_Segment2_arc\n");
seg = malloc(sizeof(Segment2));
seg->type = ARC;
seg->s.arc.angle.rot = scm_to_int16 (ROT );
seg->s.arc.angle.start = scm_to_double(startTheta);
seg->s.arc.angle.end = scm_to_double(endTheta );
seg->s.arc.radius = scm_to_double(Radius );
seg->s.arc.center.x = scm_to_double(X );
seg->s.arc.center.y = scm_to_double(Y );
SCM_NEWSMOB( smob, tag_Segment2, seg);
return smob;
}
SCM tortoise_turn(SCM s_degrees)
{
int prevValue = (int)currentDirection;
double degrees;
SCM_ASSERT(SCM_NUMBERP(s_degrees), s_degrees, SCM_ARG1, "tortoise-turn");
//degrees = SCM_NUM2DOUBLE(s_degrees);
degrees = scm_to_double(s_degrees);
currentDirection += degrees;
return SCM_MAKINUM(prevValue);
}
bool updateMouseArea(guihckContext* ctx, guihckElementId id, void* data)
{
SCM x = guihckElementGetProperty(ctx, id, "absolute-x");
SCM y = guihckElementGetProperty(ctx, id, "absolute-y");
SCM w = guihckElementGetProperty(ctx, id, "width");
SCM h = guihckElementGetProperty(ctx, id, "height");
float px, py, pw, ph;
guihckMouseAreaGetRect(ctx, *((guihckMouseAreaId*) data), &px, &py, &pw, &ph);
if(scm_to_bool(scm_real_p(x))) px = scm_to_double(x);
if(scm_to_bool(scm_real_p(y))) py = scm_to_double(y);
if(scm_to_bool(scm_real_p(w))) pw = scm_to_double(w);
if(scm_to_bool(scm_real_p(h))) ph = scm_to_double(h);
guihckMouseAreaRect(ctx, *((guihckMouseAreaId*) data), px, py, pw, ph);
return false;
}
SCM ffmpeg_seek(SCM scm_self, SCM scm_position)
{
struct ffmpeg_t *self = get_self(scm_self);
if (!is_input_context(self))
scm_misc_error("ffmpeg-seek", "Attempt to seek in FFmpeg output video", SCM_EOL);
int64_t position = (int64_t)(scm_to_double(scm_position) * AV_TIME_BASE);
av_seek_frame(self->fmt_ctx, -1, position, AVSEEK_FLAG_ANY);// TODO: check error
return scm_position;
}
KvpValue *
gnc_scm_to_kvp_value_ptr(SCM val)
{
if (scm_is_rational(val))
{
if (scm_is_exact(val) &&
(scm_is_signed_integer(val, INT64_MIN, INT64_MAX) ||
scm_is_unsigned_integer(val, INT64_MIN, INT64_MAX)))
{
return new KvpValue{scm_to_int64(val)};
}
else if (scm_is_exact(val) &&
(scm_is_signed_integer(scm_numerator(val),
INT64_MIN, INT64_MAX) ||
scm_is_unsigned_integer(scm_numerator(val),
INT64_MIN, INT64_MAX)) &&
(scm_is_signed_integer(scm_denominator(val),
INT64_MIN, INT64_MAX) ||
(scm_is_unsigned_integer(scm_denominator(val),
INT64_MIN, INT64_MAX))))
{
return new KvpValue{gnc_scm_to_numeric(val)};
}
else
{
return new KvpValue{scm_to_double(val)};
}
}
else if (gnc_guid_p(val))
{
auto guid = gnc_scm2guid(val);
auto tmpguid = guid_copy(&guid);
return new KvpValue{tmpguid};
}
else if (gnc_timepair_p(val))
{
Timespec ts = gnc_timepair2timespec(val);
return new KvpValue{ts};
}
else if (scm_is_string(val))
{
return new KvpValue{gnc_scm_to_utf8_string(val)};
}
else if (SWIG_IsPointerOfType(val, SWIG_TypeQuery("_p_KvpFrame")))
{
#define FUNC_NAME G_STRFUNC
auto vp_frame = SWIG_MustGetPtr(val,
SWIG_TypeQuery("_p_KvpFrame"), 1, 0);
KvpFrame *frame = static_cast<KvpFrame*>(vp_frame);
#undef FUNC_NAME
return new KvpValue{frame};
}
/* FIXME: add list handler here */
return NULL;
}
SCM calculate_context(SCM c)
{
float prob = 1.0;
int i = 0.0;
for(; i < scm_to_int(scm_length(c)); i++)
prob *= 1.0 - scm_to_double(scm_list_ref(c, scm_from_int(i)));
prob = 1 - prob;
return scm_from_double(prob);
}
SCM tf_set_attr_float_list(SCM scm_description, SCM scm_name, SCM scm_values)
{
struct tf_description_t *self = get_tf_description(scm_description);
int num_values = scm_ilength(scm_values);
float *values = scm_gc_malloc(sizeof(float) * num_values, "tf-set-attr-float-list");
for (int i=0; i<num_values; i++) {
values[i] = (float)scm_to_double(scm_car(scm_values));
scm_values = scm_cdr(scm_values);
};
char *name = scm_to_locale_string(scm_name);
TF_SetAttrFloatList(self->description, name, values, num_values);
free(name);
return SCM_UNDEFINED;
}
static SCM tortoise_move(SCM length)
{
const double value = scm_to_double(length);
double newX, newY;
newX = x + value * cos(direction);
newY = y + value * sin(direction);
if(pendown)
draw_line(global_output, x, y, newX, newY);
x = newX;
y = newY;
return scm_list_2(scm_from_double(x), scm_from_double(y));
}
KvpValue *
gnc_scm_to_kvp_value_ptr(SCM val)
{
if (scm_is_number(val))
{
/* in guile 1.8 (exact? ) only works on numbers */
if (scm_is_exact (val) && gnc_gh_gint64_p(val))
{
return new KvpValue{scm_to_int64(val)};
}
else
{
return new KvpValue{scm_to_double(val)};
}
}
else if (gnc_numeric_p(val))
{
return new KvpValue{gnc_scm_to_numeric(val)};
}
else if (gnc_guid_p(val))
{
auto guid = gnc_scm2guid(val);
auto tmpguid = guid_copy(&guid);
return new KvpValue{tmpguid};
}
else if (gnc_timepair_p(val))
{
Timespec ts = gnc_timepair2timespec(val);
return new KvpValue{ts};
}
else if (scm_is_string(val))
{
return new KvpValue{gnc_scm_to_utf8_string(val)};
}
else if (SWIG_IsPointerOfType(val, SWIG_TypeQuery("_p_KvpFrame")))
{
#define FUNC_NAME G_STRFUNC
auto vp_frame = SWIG_MustGetPtr(val,
SWIG_TypeQuery("_p_KvpFrame"), 1, 0);
KvpFrame *frame = static_cast<KvpFrame*>(vp_frame);
#undef FUNC_NAME
return new KvpValue{frame};
}
/* FIXME: add list handler here */
return NULL;
}
static SCM
_wrap_My_variable(SCM s_0)
{
#define FUNC_NAME "My-variable"
SCM gswig_result;
if (s_0 != SCM_UNDEFINED) {
{
My_variable = (double) scm_to_double(s_0);
}
}
{
gswig_result = scm_from_double(My_variable);
}
return gswig_result;
#undef FUNC_NAME
}
VISIBLE void
scm_c_view_t1font_dict_set_x (SCM view, const char *key, const char *value)
{
const char *who = "scm_c_view_t1font_dict_set_x";
SplineFont *sf = (SplineFont *) scm_c_view_to_SplineFont (view);
switch (t1font_key (who, key))
{
case _t1font_FontName:
free (sf->fontname);
sf->fontname = xstrdup (value);
break;
case _t1font_PaintType:
sf->strokedfont = (scm_to_int (scm_c_postscript_to_number (value)) == 2);
break;
case _t1font_StrokeWidth:
sf->strokewidth = scm_to_double (scm_c_postscript_to_number (value));
break;
}
}
GshmupPlayer *
gshmup_create_player (GshmupAnimation *anim)
{
GshmupPlayer *player = (GshmupPlayer *) scm_gc_malloc (sizeof (GshmupPlayer),
"player");
player->entity = gshmup_create_entity ("Player");
player->shooting = false;
player->lives = scm_to_int (scm_variable_ref (s_lives_per_credit)) - 1;
player->credits = gshmup_get_initial_player_credits () - 1;
player->speed = scm_to_double (scm_variable_ref (s_player_speed));
player->score = 0;
player->on_shoot = scm_variable_ref (s_player_on_shoot);
player->on_game_over = NULL;
gshmup_player_stop (player);
player->entity.sprite = gshmup_create_sprite_animated (anim);
gshmup_sprite_play_animation (&player->entity.sprite);
return player;
}
SCM pip_color_distance (SCM cR, SCM cG, SCM cB, SCM cR2, SCM cG2, SCM cB2)
{
double R = scm_to_double (cR);
double G = scm_to_double (cG);
double B = scm_to_double (cB);
double R2 = scm_to_double (cR2);
double G2 = scm_to_double (cG2);
double B2 = scm_to_double (cB2);
R /= 255.0;
G /= 255.0;
B /= 255.0;
R2 /= 255.0;
G2 /= 255.0;
B2 /= 255.0;
R = transform1 (R);
G = transform1 (G);
B = transform1 (B);
R2 = transform1 (R2);
G2 = transform1 (G2);
B2 = transform1 (B2);
double X = R * 0.4124 + G * 0.3576 + B * 0.1805;
double Y = R * 0.2126 + G * 0.7152 + B * 0.0722;
double Z = R * 0.0193 + G * 0.1192 + B * 0.9505;
double X2 = R2 * 0.4124 + G2 * 0.3576 + B2 * 0.1805;
double Y2 = R2 * 0.2126 + G2 * 0.7152 + B2 * 0.0722;
double Z2 = R2 * 0.0193 + G2 * 0.1192 + B2 * 0.9505;
Y /= REFY;
Z /= REFZ;
X /= REFX;
Y2 /= REFY;
Z2 /= REFZ;
X2 /= REFX;
double LL = 116.0 * transform2(Y) - 16.0;
double AA = 500.0 * (transform2(X) - transform2 (Y));
double BB = 200.0 * (transform2(Y) - transform2 (Z));
double LL2 = 116.0 * transform2(Y2) - 16.0;
double AA2 = 500.0 * (transform2(X2) - transform2 (Y2));
double BB2 = 200.0 * (transform2(Y2) - transform2 (Z2));
double dL = LL - LL2;
double dA = AA - AA2;
double dB = BB - BB2;
return scm_from_double (sqrt (dL * dL + dA * dA + dB * dB));
}
SCM tortoise_move(SCM s_steps)
{
double oldX = currentX;
double oldY = currentY;
double newX, newY;
double steps;
SCM_ASSERT(SCM_NUMBERP(s_steps), s_steps, SCM_ARG1, "tortoise-move");
//steps = SCM_NUM2DOUBLE(s_steps);
steps = scm_to_double(s_steps);
/* first work out the new endpoint */
newX = currentX + sin(currentDirection*DEGREES_TO_RADIANS) * steps;
newY = currentY - cos(currentDirection*DEGREES_TO_RADIANS) * steps;
/* if the pen is down, draw a line */
if (penDown)
XDrawLine(theDisplay, theWindow, theGC,
(int)currentX, (int)currentY,
(int)newX, (int)newY);
/* in either case, move the tortoise */
currentX = newX;
currentY = newY;
return gh_cons(gh_double2scm(oldX), gh_cons(gh_double2scm(oldY), SCM_EOL));
}
static LLVMValueRef scm_to_llvm_value(int type, SCM scm_value)
{
switch (type) {
case SCM_FOREIGN_TYPE_FLOAT:
case SCM_FOREIGN_TYPE_DOUBLE:
return LLVMConstReal(llvm_type(type), scm_to_double(scm_value));
case SCM_FOREIGN_TYPE_BOOL:
return LLVMConstInt(llvm_type(type), scm_is_true(scm_value), 0);
case SCM_FOREIGN_TYPE_UINT8:
case SCM_FOREIGN_TYPE_UINT16:
case SCM_FOREIGN_TYPE_UINT32:
case SCM_FOREIGN_TYPE_UINT64:
return LLVMConstInt(llvm_type(type), scm_to_uint64(scm_value), 0);
case SCM_FOREIGN_TYPE_INT8:
case SCM_FOREIGN_TYPE_INT16:
case SCM_FOREIGN_TYPE_INT32:
case SCM_FOREIGN_TYPE_INT64:
return LLVMConstInt(llvm_type(type), scm_to_int64(scm_value), 1);
default:
return NULL;
};
}
// Load one of data into the model. The vararg should be a list of values with
// length equal to the number of discrete columns plus the number of continuous
// columns. The first values in the vararg are taken to be discrete, followed
// by the continuous values.
//
SCM
thit_load_row_x(SCM s_model, SCM s_varargs) {
scm_assert_smob_type(thit_model_tag, s_model);
banmi_model_t *model = (banmi_model_t*)SCM_SMOB_DATA(s_model);
int n_col = model->n_disc + model->n_cont;
int n_args = scm_to_int(scm_length(s_varargs));
if (model->n_rows == model->disc->size1)
scm_error_scm(thit_error,
scm_from_locale_string("load-row!"),
scm_from_locale_string("The model is full, can't add more rows."),
scm_list_2(scm_from_int(n_col), scm_from_int(n_args)),
SCM_BOOL_F);
if (n_args != n_col)
scm_error_scm(thit_error,
scm_from_locale_string("load-row!"),
scm_from_locale_string("Expected ~A values, got ~A."),
scm_list_2(scm_from_int(n_col), scm_from_int(n_args)),
SCM_BOOL_F);
int j, ival;
for (j = 0; j < model->n_disc; j++) {
ival = scm_to_int(scm_list_ref(s_varargs, scm_from_int(j)));
gsl_matrix_int_set(model->disc, model->n_rows, j, ival);
}
double dval;
for (j = 0; j < model->n_cont; j++) {
dval = scm_to_double(scm_list_ref(s_varargs, scm_from_int(j + model->n_disc)));
gsl_matrix_set(model->cont, model->n_rows, j, dval);
}
model->n_rows++;
return SCM_BOOL_T;
}
