int internal_eqvp(CELL obj1, CELL obj2)
{
if (AS_LITERAL(obj1) == AS_LITERAL(obj2)) {
return 1;
}
if (! (IS_POINTER(obj1) && IS_POINTER(obj2)) ) {
return 0;
}
TYPEID t = GET_POINTER_TYPE(obj1);
if (t != GET_POINTER_TYPE(obj2)) {
return 0;
}
switch(t) {
case T_FLOAT:
return GET_FLOAT(obj1) == GET_FLOAT(obj2);
case T_BIGINT:
return GET_BIGINT(obj1) == GET_BIGINT(obj2);
default:
return 0;
}
//FIXME - does not implement equality correctly for LAMBDAs
//principally because LAMBDAs are not implemented correctly
//yet either (i.e. as closures).
}
static VALUE
execute(VALUE self, VALUE a, VALUE b, VALUE n)
{
GET_FLOAT(a);
GET_FLOAT(b);
GET_FLOAT(n);
int i;
double s1=0.0, s2=0.0, d;
double x, y[n+1];
d=(b-a)/(double)n;
for(i=0; i<=n; i++)
{
x=(double)i*d+a;
y[i]=func(x);
}
for(i=1; i<=n-1; i+=2)
{
s1+=y[i];
}
for(i=2; i<=n-2; i+=2)
{
s2+=y[i];
}
double s=(y[0]+4.0*s1+2.0*s2+y[n])*d/3.0;
return DBL2NUM(s);
}
static void ctl_get( void )
{
int i;
GET_STR( ctl[ 0 ], sequence, sizeof( sequence ));
GET_INT( ctl[ 1 ], atom_type );
GET_INT( ctl[ 2 ], atom_nsides );
GET_INT( ctl[ 3 ], atom_nsegments );
for ( i = 0; i < 5; i++ )
GET_FLOAT( ctl[ i + 5 ], atom_radius[ i ] );
GET_INT( ctl[ 10 ], bond_type );
GET_INT( ctl[ 11 ], bond_nsides );
GET_INT( ctl[ 12 ], bond_nsegments );
GET_FLOAT( ctl[ 13 ], bond_radius );
GET_INT( ctl[ 14 ], do_plates );
}
CELL make_float(FLOAT f)
{
// FIXME pick better more consistent names for types.
// Tension between FLOAT and BOXED_FLOAT caused an allocation bug.
CELL v = gc_alloc_extra(FLOAT, sizeof(TYPEID));
GET_FLOAT(v) = f;
return v;
}
vogleditor_stateTreeLightItem::vogleditor_stateTreeLightItem(QString name, unsigned int lightIndex, vogleditor_stateTreeItem* parent, const vogl_state_vector* pState)
: vogleditor_stateTreeItem(name, "", parent),
m_lightIndex(lightIndex),
m_pState(pState),
m_pDiffBaseState(NULL)
{
float fVals[4];
#define GET_FLOAT(name, num) if (pState->get<float>(name, 0, fVals, num)) { vogleditor_stateTreeStateVecFloatItem* pItem = new vogleditor_stateTreeStateVecFloatItem(#name, name, 0, *pState, fVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); }
GET_FLOAT(GL_CONSTANT_ATTENUATION, 1);
GET_FLOAT(GL_LINEAR_ATTENUATION, 1);
GET_FLOAT(GL_QUADRATIC_ATTENUATION, 1);
GET_FLOAT(GL_SPOT_EXPONENT, 1);
GET_FLOAT(GL_SPOT_CUTOFF, 1);
GET_FLOAT(GL_AMBIENT, 4);
GET_FLOAT(GL_DIFFUSE, 4);
GET_FLOAT(GL_SPECULAR, 4);
GET_FLOAT(GL_POSITION, 4);
GET_FLOAT(GL_SPOT_DIRECTION, 3);
#undef GET_FLOAT
}
void C_THISCLASS::load_config(unsigned char *data, int len) // read configuration of max length "len" from data.
{
int pos=0;
if (len-pos >= 4) { enabled=GET_INT(); pos+=4; }
if (len-pos >= 4) { nPoints=GET_INT(); pos+=4; }
if (len-pos >= 4) { rotation=GET_INT(); pos+=4; }
if (len-pos >= 4) { distance=GET_INT(); pos+=4; }
if (len-pos >= 4) { alpha=GET_INT(); pos+=4; }
if (len-pos >= 4) { rotationinc=GET_INT(); pos+=4; }
if (len-pos >= 4) { blend=GET_INT(); pos+=4; }
if (len-pos >= 4) { blendavg=GET_INT(); pos+=4; }
if (len-pos >= 4) { distance2=GET_INT(); pos+=4; }
if (len-pos >= 4) { alpha2=GET_INT(); pos+=4; }
if (len-pos >= 4) { rotationinc2=GET_INT(); pos+=4; }
if (len-pos >= 4) { rgb=GET_INT(); pos+=4; }
if (len-pos >= 4) { onbeat=GET_INT(); pos+=4; }
if (len-pos >= 4) { speed=GET_FLOAT(data, pos); pos+=4; }
a=(float)rotation/255*(float)PI*2;
status=(float)PI;
}
bool vogl_material_state::snapshot(const vogl_context_info &context_info)
{
VOGL_FUNC_TRACER
VOGL_NOTE_UNUSED(context_info);
clear();
VOGL_CHECK_GL_ERROR;
bool any_gl_errors = false;
#define GET_FLOAT(side, pname) \
do \
{ \
float values[4] = { 0, 0, 0, 0 }; \
GL_ENTRYPOINT(glGetMaterialfv)(get_face(side), pname, values); \
if (vogl_check_gl_error()) \
any_gl_errors = true; \
m_params[side].insert(pname, 0, values, sizeof(values[0])); \
} while (0)
for (uint s = 0; s < cTotalSides; s++)
{
GET_FLOAT(s, GL_AMBIENT);
GET_FLOAT(s, GL_DIFFUSE);
GET_FLOAT(s, GL_SPECULAR);
GET_FLOAT(s, GL_EMISSION);
GET_FLOAT(s, GL_SHININESS);
GET_FLOAT(s, GL_COLOR_INDEXES);
}
#undef GET_FLOAT
if (any_gl_errors)
{
clear();
vogl_error_printf("%s: GL error while enumerating material params\n", VOGL_METHOD_NAME);
return false;
}
m_valid = true;
return true;
}
int internal_equalp(CELL obj1, CELL obj2)
{
while(1) {
if (AS_LITERAL(obj1) == AS_LITERAL(obj2)) {
return 1;
}
if (! (IS_POINTER(obj1) && IS_POINTER(obj2)) ) {
return 0;
}
if (GET_POINTER_TYPE(obj1) != GET_POINTER_TYPE(obj2)) {
return 0;
}
switch(GET_POINTER_TYPE(obj1)) {
case T_CONS:
// FIXME - unbounded recursion!
if (!internal_equalp(CAR(obj1), CAR(obj2))) {
return 0;
}
obj1 = CDR(obj1);
obj2 = CDR(obj2);
break;
case T_VECTOR:
case T_RECORD:
{
VECTOR * const vec1 = GET_VECTOR(obj1);
VECTOR * const vec2 = GET_VECTOR(obj2);
if (vec1->len != vec2->len) {
return 0;
}
int i;
for(i = 0; i < vec1->len; ++i) {
// FIXME - unbounded recursion!
if (!internal_equalp(vec1->data[i], vec2->data[i])) {
return 0;
}
}
return 1;
}
case T_STRING:
{
STRING * const p1 = GET_STRING(obj1);
STRING * const p2 = GET_STRING(obj2);
return p1->len == p2->len && 0 == memcmp(p1->data, p2->data, p1->len);
}
case T_FLOAT:
return GET_FLOAT(obj1) == GET_FLOAT(obj2);
case T_BIGINT:
return GET_BIGINT(obj1) == GET_BIGINT(obj2);
default:
return 0;
}
}
}
vogleditor_stateTreeTexEnvItem::vogleditor_stateTreeTexEnvItem(QString name, vogleditor_stateTreeItem *parent, vogl_texenv_state &state, const vogl_context_info &info)
: vogleditor_stateTreeItem(name, "", parent),
m_pState(&state),
m_pDiffBaseState(NULL),
m_pDiffBaseInfo(NULL)
{
QString tmp;
for (uint texcoord_index = 0; texcoord_index < info.get_max_texture_coords(); texcoord_index++)
{
vogleditor_stateTreeItem *pTexNode = new vogleditor_stateTreeItem(tmp.sprintf("GL_TEXTURE%u", texcoord_index), "", this);
this->appendChild(pTexNode);
int iVals[4] = { 0, 0, 0, 0 };
float fVals[4] = { 0, 0, 0, 0 };
#define GET_ENUM(target, idx, name, num) \
if (m_pState->get_state(target).get<int>(name, idx, iVals, num)) \
{ \
vogleditor_stateTreeTexEnvStateVecEnumItem *pItem = new vogleditor_stateTreeTexEnvStateVecEnumItem(target, #name, name, idx, iVals, num, pTexNode, *m_pState); \
m_diffableItems.push_back(pItem); \
pTexNode->appendChild(pItem); \
}
#define GET_FLOAT(target, idx, name, num) \
if (m_pState->get_state(target).get<float>(name, idx, fVals, num)) \
{ \
vogleditor_stateTreeTexEnvStateVecFloatItem *pItem = new vogleditor_stateTreeTexEnvStateVecFloatItem(target, #name, name, idx, fVals, num, pTexNode, *m_pState); \
m_diffableItems.push_back(pItem); \
pTexNode->appendChild(pItem); \
}
GET_FLOAT(GL_TEXTURE_FILTER_CONTROL, texcoord_index, GL_TEXTURE_LOD_BIAS, 1);
GET_ENUM(GL_POINT_SPRITE, texcoord_index, GL_COORD_REPLACE, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_TEXTURE_ENV_MODE, 1);
GET_FLOAT(GL_TEXTURE_ENV, texcoord_index, GL_TEXTURE_ENV_COLOR, 4);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_COMBINE_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_COMBINE_ALPHA, 1);
GET_FLOAT(GL_TEXTURE_ENV, texcoord_index, GL_RGB_SCALE, 1);
GET_FLOAT(GL_TEXTURE_ENV, texcoord_index, GL_ALPHA_SCALE, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_SRC0_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_SRC1_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_SRC2_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_SRC0_ALPHA, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_SRC1_ALPHA, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_SRC2_ALPHA, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_OPERAND0_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_OPERAND1_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_OPERAND2_RGB, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_OPERAND0_ALPHA, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_OPERAND1_ALPHA, 1);
GET_ENUM(GL_TEXTURE_ENV, texcoord_index, GL_OPERAND2_ALPHA, 1);
// TODO:
//{ "glGetTexEnv", 'E', 1, "GL_SOURCE3_RGB_NV", 0x8583},
//{ "glGetTexEnv", 'E', 1, "GL_SOURCE3_ALPHA_NV", 0x858B},
//{ "glGetTexEnv", 'E', 1, "GL_OPERAND3_RGB_NV", 0x8593},
//{ "glGetTexEnv", 'E', 1, "GL_OPERAND3_ALPHA_NV", 0x859B},
//{ "glGetTexEnv", 'E', 1, "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV", 0x86D9},
//{ "glGetTexEnv", 'E', 1, "GL_SHADER_OPERATION_NV", 0x86DF},
//{ "glGetTexEnv", 'E', 4, "GL_CULL_MODES_NV", 0x86E0},
//{ "glGetTexEnv", 'F', 4, "GL_OFFSET_TEXTURE_MATRIX_NV", 0x86E1},
//{ "glGetTexEnv", 'F', 1, "GL_OFFSET_TEXTURE_SCALE_NV", 0x86E2},
//{ "glGetTexEnv", 'F', 1, "GL_OFFSET_TEXTURE_BIAS_NV", 0x86E3},
//{ "glGetTexEnv", 'E', 1, "GL_PREVIOUS_TEXTURE_INPUT_NV", 0x86E4},
//{ "glGetTexEnv", 'F', 3, "GL_CONST_EYE_NV", 0x86E5},
//{ "glGetTexEnv", 'E', 1, "GL_BUMP_TARGET_ATI", 0x877C},
#undef GET_FLOAT
#undef GET_ENUM
#define GET_ENUM(target, idx, name, num) \
if (m_pState->get_state(target).get<int>(name, idx, iVals, num)) \
{ \
vogleditor_stateTreeTexEnvStateVecEnumItem *pItem = new vogleditor_stateTreeTexEnvStateVecEnumItem(target, #target " " #name, name, idx, iVals, num, pTexNode, *m_pState); \
m_diffableItems.push_back(pItem); \
pTexNode->appendChild(pItem); \
}
#define GET_FLOAT(target, idx, name, num) \
if (m_pState->get_state(target).get<float>(name, idx, fVals, num)) \
{ \
vogleditor_stateTreeTexEnvStateVecFloatItem *pItem = new vogleditor_stateTreeTexEnvStateVecFloatItem(target, #target " " #name, name, idx, fVals, num, pTexNode, *m_pState); \
m_diffableItems.push_back(pItem); \
pTexNode->appendChild(pItem); \
}
GET_ENUM(GL_S, texcoord_index, GL_TEXTURE_GEN_MODE, 1);
GET_FLOAT(GL_S, texcoord_index, GL_OBJECT_PLANE, 4);
GET_FLOAT(GL_S, texcoord_index, GL_EYE_PLANE, 4);
GET_ENUM(GL_T, texcoord_index, GL_TEXTURE_GEN_MODE, 1);
GET_FLOAT(GL_T, texcoord_index, GL_OBJECT_PLANE, 4);
GET_FLOAT(GL_T, texcoord_index, GL_EYE_PLANE, 4);
GET_ENUM(GL_R, texcoord_index, GL_TEXTURE_GEN_MODE, 1);
GET_FLOAT(GL_R, texcoord_index, GL_OBJECT_PLANE, 4);
GET_FLOAT(GL_R, texcoord_index, GL_EYE_PLANE, 4);
GET_ENUM(GL_Q, texcoord_index, GL_TEXTURE_GEN_MODE, 1);
GET_FLOAT(GL_Q, texcoord_index, GL_OBJECT_PLANE, 4);
GET_FLOAT(GL_Q, texcoord_index, GL_EYE_PLANE, 4);
#undef GET_FLOAT
#undef GET_ENUM
}
}
static VALUE
rb_func(VALUE self, VALUE x)
{
GET_FLOAT(x);
return(DBL2NUM((x * x)/2));
}
int open_sliderpan( LWPanelFuncs *panf )
{
LWPanControlDesc desc;
LWValue
ival = { LWT_INTEGER },
fval = { LWT_FLOAT };
LWPanelID panel;
LWControl *ctl[ 10 ];
int n, w, ok;
if( !( panel = PAN_CREATE( panf, "Slider" )))
return 0;
panf->set( panel, PAN_USERDATA, panf );
panf->set( panel, PAN_MOUSEBUTTON, mevent );
panf->set( panel, PAN_MOUSEMOVE, mevent );
ctl[ 0 ] = SLIDER_CTL( panf, panel, "Slider", 100, -20, 100 );
ctl[ 1 ] = VSLIDER_CTL( panf, panel, "Vertical Slider", 60, 0, 100 );
ctl[ 2 ] = HSLIDER_CTL( panf, panel, "Horizontal Slider", 100, -20, 100 );
ctl[ 3 ] = UNSLIDER_CTL( panf, panel, "Unbounded Slider", 100, -20, 100 );
ctl[ 4 ] = MINISLIDER_CTL( panf, panel, "Minislider", 100, -20, 100 );
ctl[ 5 ] = PERCENT_CTL( panf, panel, "Percent" );
ctl[ 6 ] = ANGLE_CTL( panf, panel, "Angle" );
ctl[ 7 ] = DRAGBUT_CTL( panf, panel, "Drag Button", 40, 40 );
ctl[ 8 ] = VDRAGBUT_CTL( panf, panel, "Vertical Drag Button" );
ctl[ 9 ] = HDRAGBUT_CTL( panf, panel, "Horizontal Drag Button" );
CON_SETEVENT( ctl[ 1 ], sevent, NULL );
CON_SETEVENT( ctl[ 2 ], sevent, NULL );
CON_SETEVENT( ctl[ 7 ], devent, NULL );
CON_SETEVENT( ctl[ 8 ], devent, NULL );
CON_SETEVENT( ctl[ 9 ], devent, NULL );
/* align */
for ( n = 0; n < 10; n++ ) {
w = CON_LW( ctl[ n ] );
ival.intv.value = 100 - w;
ctl[ n ]->set( ctl[ n ], CTL_X, &ival );
}
for ( n = 0; n < 5; n++ )
SET_INT( ctl[ n ], slideval[ n ] );
SET_FLOAT( ctl[ 5 ], pct );
SET_FLOAT( ctl[ 6 ], angle );
ok = panf->open( panel, PANF_BLOCKING | PANF_CANCEL | PANF_MOUSETRAP );
if ( ok ) {
for ( n = 0; n < 5; n++ )
GET_INT( ctl[ n ], slideval[ n ] );
GET_FLOAT( ctl[ 5 ], pct );
GET_FLOAT( ctl[ 6 ], angle );
}
PAN_KILL( panf, panel );
return 1;
}
XCALL_(int)BlotchInterface (
long version,
GlobalFunc *global,
Blotch *inst,
void *serverData)
{
LWPanelFuncs *panl;
LWPanelID panID;
LWControl *col,*cen,*sof,*rad;
MessageFuncs *message;
int x=200,y=0,w=400,h=300;
XCALL_INIT;
if (version != 1)
return AFUNC_BADVERSION;
message = (*global) ("Info Messages", GFUSE_TRANSIENT);
if (!message )
return AFUNC_BADGLOBAL;
panl = (*global) (PANEL_SERVICES_NAME, GFUSE_TRANSIENT);
if(!panl)
{
(*message->error)("Unable to activate global "PANEL_SERVICES_NAME, " please add plugin lwpanels.p" );
return AFUNC_BADGLOBAL;
}
if( panID=PAN_CREATE(panl,"Blotch") )
{
LWValue val = {LWT_INTEGER};
int lw;
#ifdef RGB
int rgb[3];
if(!(col = MINIRGB_CTL(panl,panID,"Color")))
goto controlError;
#else
if(!(col = MINIHSV_CTL(panl,panID,"Color")))
goto controlError;
#endif
if(!(cen = FVEC_CTL(panl,panID,"Center")))
goto controlError;
if(!(rad = FLOAT_CTL(panl,panID,"Radius")))
goto controlError;
if(!(sof = FLOAT_CTL(panl,panID,"Softness")))
goto controlError;
lw = maxLabel(panl,panID);
ctlVAlign(lw,col);
ctlVAlign(lw,cen);
ctlVAlign(lw,rad);
ctlOneLine(rad,sof,NULL,NULL,NULL,NULL);
#ifdef RGB
rgb[0] = (int)(255.0*inst->color[0]);
rgb[1] = (int)(255.0*inst->color[1]);
rgb[2] = (int)(255.0*inst->color[2]);
SETV_IVEC(col,rgb);
#else
SETV_FVEC(col,inst->color);
#endif
SETV_FVEC(cen,inst->center);
SET_FLOAT(rad,inst->radius);
SET_FLOAT(sof,inst->softness);
if(PAN_POST(panl,panID))
{
#ifdef RGB
GETV_IVEC(col,rgb);
inst->color[0] = ((double)rgb[0])/255.0;
inst->color[1] = ((double)rgb[1])/255.0;
inst->color[2] = ((double)rgb[2])/255.0;
#else
GETV_FVEC(col,inst->color);
#endif
GETV_FVEC(cen,inst->center);
GET_FLOAT(rad,inst->radius);
GET_FLOAT(sof,inst->softness);
}
PAN_KILL(panl,panID);
return (AFUNC_OK);
controlError:
PAN_KILL(panl,panID);
(*message->error)("Duoooh!:","Unable to create panel");
}
else
{
(*message->error)("Duoooh!:","Unable to create panel");
}
return AFUNC_BADGLOBAL;
}
bool vogl_sampler_state::snapshot(const vogl_context_info &context_info, vogl_handle_remapper &remapper, GLuint64 handle, GLenum target)
{
VOGL_FUNC_TRACER
VOGL_NOTE_UNUSED(remapper);
VOGL_CHECK_GL_ERROR;
(void)target;
clear();
VOGL_ASSERT(handle <= cUINT32_MAX);
m_snapshot_handle = static_cast<uint32>(handle);
bool any_gl_errors = false;
#define GET_INT(pname) \
do \
{ \
int values[4] = { 0, 0, 0, 0 }; \
GL_ENTRYPOINT(glGetSamplerParameteriv)(m_snapshot_handle, pname, values); \
if (vogl_check_gl_error()) \
any_gl_errors = true; \
m_params.insert(pname, 0, values, sizeof(values[0])); \
} while (0)
#define GET_FLOAT(pname) \
do \
{ \
float values[4] = { 0, 0, 0, 0 }; \
GL_ENTRYPOINT(glGetSamplerParameterfv)(m_snapshot_handle, pname, values); \
if (vogl_check_gl_error()) \
any_gl_errors = true; \
m_params.insert(pname, 0, values, sizeof(values[0])); \
} while (0)
GET_INT(GL_TEXTURE_MAG_FILTER);
GET_INT(GL_TEXTURE_MIN_FILTER);
GET_FLOAT(GL_TEXTURE_MIN_LOD);
GET_FLOAT(GL_TEXTURE_MAX_LOD);
GET_INT(GL_TEXTURE_WRAP_S);
GET_INT(GL_TEXTURE_WRAP_T);
GET_INT(GL_TEXTURE_WRAP_R);
GET_FLOAT(GL_TEXTURE_BORDER_COLOR);
GET_INT(GL_TEXTURE_COMPARE_MODE);
GET_INT(GL_TEXTURE_COMPARE_FUNC);
if (context_info.supports_extension("GL_EXT_texture_filter_anisotropic"))
{
GET_FLOAT(GL_TEXTURE_MAX_ANISOTROPY_EXT);
}
if (context_info.supports_extension("GL_EXT_texture_sRGB_decode"))
{
GET_INT(GL_TEXTURE_SRGB_DECODE_EXT);
}
#undef GET_INT
#undef GET_FLOAT
if (any_gl_errors)
{
clear();
vogl_error_printf("%s: GL error while enumerating sampler %" PRIu64 "'s' params\n", VOGL_METHOD_NAME, (uint64_t)handle);
return false;
}
m_is_valid = true;
return true;
}
void internal_generic_output(FILE* fp, CELL cell, int strict, int tab)
{
switch(GET_TYPE(cell)) {
case T_VOID:
fputs("#<void>", fp);
break;
case T_NULL:
fputs("()", fp);
break;
case T_UNDEFINED:
fputs("#<undefined>", fp);
break;
case T_EMPTY:
fputs("#<empty>", fp);
break;
case T_BOOL:
fputs(GET_BOOL(cell) ? "#t" : "#f", fp);
break;
case T_CHAR:
{
CHAR ch = GET_CHAR(cell);
if (strict) {
switch(ch) {
case ' ': fputs("#\\space", fp); break;
case 0: fputs("#\\nul", fp); break;
case 27: fputs("#\\escape", fp); break;
case 127: fputs("#\\rubout", fp); break;
case '\a': fputs("#\\alarm", fp); break;
case '\b': fputs("#\\backspace", fp); break;
case '\f': fputs("#\\page", fp); break;
case '\n': fputs("#\\newline", fp); break;
case '\r': fputs("#\\return", fp); break;
case '\t': fputs("#\\tab", fp); break;
case '\v': fputs("#\\vtab", fp); break;
default: fprintf(fp, "#\\%c", ch); break;
}
}
else {
fputc(ch, fp);
}
}
break;
case T_INT:
fprintf(fp, "%d", GET_INT(cell));
break;
case T_BIGINT:
fprintf(fp, "%lld", GET_BIGINT(cell));
break;
case T_FLOAT:
fprintf(fp, "%f", GET_FLOAT(cell));
break;
case T_STRING:
{
STRING* p = GET_STRING(cell);
size_t len = p->len;
char* data = p->data;
if (strict) {
// FIXME -- make this more efficient, and escape other special chars?
fputc('"', fp);
while(len--) {
char ch = *data++;
if (ch == '"' || ch == '\\') {
fputc('\\', fp);
}
fputc(ch, fp);
}
fputc('"', fp);
}
else {
fwrite(data, 1, len, fp);
}
}
break;
case T_NAME:
{
NAME* p = GET_NAME(cell);
if (p->gensym) {
fprintf(fp, "#_%d", p->gensym);
}
else {
fwrite(GET_NAME(cell)->data, 1, GET_NAME(cell)->len, fp);
}
}
break;
case T_KEYWORD:
{
KEYWORD* p = GET_KEYWORD(cell);
fwrite(p->data, 1, p->len, fp);
fputc(':', fp);
}
break;
case T_SLOT:
fprintf(fp, "#<slot:%d>", GET_SLOT(cell));
break;
// FIXME - arbitrary recursion
case T_CONS:
fputc('(', fp);
if (tab) ++tab;
int did = 0;
while(1) {
int pair = CONSP(CAR(cell));
if (!did && tab && pair && !CONSP(CAR(CAR(cell)))) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
internal_generic_output(fp, CAR(cell), strict, tab);
cell = CDR(cell);
if (NULLP(cell)) {
break;
}
did = (tab && pair);
if (did) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
else fputc(' ', fp);
if (!CONSP(cell)) {
fputs(". ", fp);
internal_generic_output(fp, cell, strict, tab);
break;
}
}
fputc(')', fp);
break;
// FIXME - arbitrary recursion
case T_VECTOR:
{
VECTOR *vec = GET_VECTOR(cell);
fputs("#(", fp);
if (vec->len > 0) {
int i = 0;
internal_generic_output(fp, vec->data[i++], strict, tab);
while(i < vec->len) {
fputc(' ', fp);
internal_generic_output(fp, vec->data[i++], strict, tab);
}
}
fputc(')', fp);
break;
}
case T_FUNC:
fprintf(fp, "#<primitive:%s>", GET_FUNC(cell)->name);
break;
case T_COMPILED_LAMBDA:
fprintf(fp, "#<compiled-lambda:0x%08x>", AS_LITERAL(cell));
break;
{
if (tab) ++tab;
COMPILED_LAMBDA *l = GET_COMPILED_LAMBDA(cell);
fprintf(fp, "#<%s %d%s:%d/%d",
l->is_macro ? "macro" : "lambda",
l->argc, l->rest ? "+" : "",
l->depth,
l->max_slot);
if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
else { fputc(' ', fp); }
internal_generic_output(fp, l->body, strict, tab);
fputc('>', fp);
}
break;
case T_CLOSURE:
fprintf(fp, "#<closure:0x%08x>", AS_LITERAL(cell));
break;
{
if (tab) ++tab;
CLOSURE *c = GET_CLOSURE(cell);
fprintf(fp, "#<closure ");
if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
internal_print_env(fp, c->env);
if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
fputc(' ', fp);
internal_generic_output(fp, c->compiled_lambda, strict, tab);
fputc('>', fp);
}
break;
case T_EXCEPTION:
fputs("#<exception:", fp);
fwrite(GET_EXCEPTION(cell)->data, 1, GET_EXCEPTION(cell)->len, fp);
fputc('>', fp);
break;
case T_REIFIED_CONTINUATION:
fprintf(fp, "#<continuation:0x%08x>", (int)GET_REIFIED_CONTINUATION(cell)->cont);
break;
case T_STACK_FRAME:
{
STACK_FRAME* p = GET_STACK_FRAME(cell);
fputs("#<stack-frame [", fp);
int i;
for(i = 0; i < p->len; ++i) {
if (i) fputc(' ', fp);
fprintf(fp, "0x%08x", (int)p->cells[i]);
}
fputs("]>", fp);
}
break;
case T_ENV:
fprintf(fp, "#<env:count=%d>", GET_ENV(cell)->count);
break;
case T_RELOC:
fprintf(fp, "#<reloc:0x%08x>", (int)GET_RELOC(cell));
break;
case T_PORT:
fprintf(fp, "#<port:%s>", GET_PORT(cell)->data);
break;
case T_DB_CONNECTION:
fprintf(fp, "#<db-connection>");
break;
case T_DB_RESULT:
fprintf(fp, "#<db-result>");
break;
case T_RECORD:
fprintf(fp, "#<record>");
break;
default:
fprintf(fp, "#<%s-%02x:%08x>",
IS_LITERAL(cell) ? "literal" : "pointer",
GET_TYPE(cell),
AS_LITERAL(cell)
);
break;
}
}
vogleditor_stateTreeTextureItem::vogleditor_stateTreeTextureItem(QString name, QString value, vogleditor_stateTreeItem* parentNode, vogl_texture_state* pState, const vogl_context_info& info)
: vogleditor_stateTreeItem(name, value, parentNode),
m_pTexture(pState),
m_pDiffBaseState(NULL)
{
QString tmp;
float fVals[16];
int iVals[16];
#define STR_INT1(val) tmp.sprintf("%d", val[0])
#define GET_INT(name, num) if (m_pTexture->get_params().get<int>(name, 0, iVals, num)) { vogleditor_stateTreeStateVecIntItem* pItem = new vogleditor_stateTreeStateVecIntItem(#name, name, 0, m_pTexture->get_params(), iVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); }
#define GET_ENUM(name, num) if (m_pTexture->get_params().get<int>(name, 0, iVals, num)) { vogleditor_stateTreeStateVecEnumItem* pItem = new vogleditor_stateTreeStateVecEnumItem(#name, name, 0, m_pTexture->get_params(), iVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); }
#define GET_FLOAT(name, num) if (m_pTexture->get_params().get<float>(name, 0, fVals, num)) { vogleditor_stateTreeStateVecFloatItem* pItem = new vogleditor_stateTreeStateVecFloatItem(#name, name, 0, m_pTexture->get_params(), fVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); }
GET_INT(GL_TEXTURE_BASE_LEVEL, 1);
int base_level = iVals[0];
GET_INT(GL_TEXTURE_MAX_LEVEL, 1);
GET_FLOAT(GL_TEXTURE_BORDER_COLOR, 4);
GET_ENUM(GL_TEXTURE_COMPARE_MODE, 1);
GET_ENUM(GL_TEXTURE_COMPARE_FUNC, 1);
GET_FLOAT(GL_TEXTURE_LOD_BIAS, 1);
GET_ENUM(GL_TEXTURE_MIN_FILTER, 1);
GET_ENUM(GL_TEXTURE_MAG_FILTER, 1);
GET_FLOAT(GL_TEXTURE_MIN_LOD, 1);
GET_FLOAT(GL_TEXTURE_MAX_LOD, 1);
GET_ENUM(GL_TEXTURE_SWIZZLE_R, 1);
GET_ENUM(GL_TEXTURE_SWIZZLE_G, 1);
GET_ENUM(GL_TEXTURE_SWIZZLE_B, 1);
GET_ENUM(GL_TEXTURE_SWIZZLE_A, 1);
GET_ENUM(GL_TEXTURE_SWIZZLE_RGBA, 4);
GET_ENUM(GL_TEXTURE_WRAP_S, 1);
GET_ENUM(GL_TEXTURE_WRAP_T, 1);
GET_ENUM(GL_TEXTURE_WRAP_R, 1);
if (!info.is_core_profile())
{
GET_ENUM(GL_GENERATE_MIPMAP, 1);
}
GET_INT(GL_TEXTURE_IMMUTABLE_FORMAT, 1);
if (info.supports_extension("GL_EXT_texture_filter_anisotropic"))
{
GET_FLOAT(GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
}
if (info.supports_extension("GL_EXT_texture_sRGB_decode"))
{
GET_ENUM(GL_TEXTURE_SRGB_DECODE_EXT, 1);
}
if (!info.is_core_profile() && info.supports_extension("GL_ARB_shadow_ambient"))
{
GET_FLOAT(GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, 1);
}
if (!info.is_core_profile())
{
GET_ENUM(GL_DEPTH_TEXTURE_MODE, 1);
// TODO
//GL_TEXTURE_PRIORITY
//GL_TEXTURE_RESIDENT
}
int num_actual_levels = m_pTexture->get_num_levels();
uint num_faces = (m_pTexture->get_target() == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
for (uint face = 0; face < num_faces; face++)
{
GLenum face_target_to_query = m_pTexture->get_target();
if (m_pTexture->get_target() == GL_TEXTURE_CUBE_MAP)
face_target_to_query = GL_TEXTURE_CUBE_MAP_POSITIVE_X + face;
vogleditor_stateTreeItem* pFaceNode = this;
if (m_pTexture->get_target() == GL_TEXTURE_CUBE_MAP)
{
pFaceNode = new vogleditor_stateTreeItem(enum_to_string(face_target_to_query), "", this);
this->appendChild(pFaceNode);
}
for (int level = base_level; level < num_actual_levels; level++)
{
vogleditor_stateTreeItem* pLevelNode = new vogleditor_stateTreeItem(tmp.sprintf("Mip level %d", level), "", pFaceNode);
pFaceNode->appendChild(pLevelNode);
const vogl_state_vector& level_params = m_pTexture->get_level_params(face, level);
// TODO: Check for core vs. compat profiles and not query the old stuff
#undef GET_INT
#undef GET_ENUM
#define GET_INT(name, num) if (level_params.get<int>(name, 0, iVals, num)) { pLevelNode->appendChild(new vogleditor_stateTreeStateVecIntItem(#name, name, 0, level_params, iVals, num, false, pLevelNode)); }
#define GET_ENUM(name, num) if (level_params.get<int>(name, 0, iVals, num)) { pLevelNode->appendChild(new vogleditor_stateTreeStateVecEnumItem(#name, name, 0, level_params, iVals, num, false, pLevelNode)); }
GET_INT(GL_TEXTURE_WIDTH, 1);
GET_INT(GL_TEXTURE_HEIGHT, 1);
GET_INT(GL_TEXTURE_DEPTH, 1);
GET_ENUM(GL_TEXTURE_INTERNAL_FORMAT, 1);
GET_INT(GL_TEXTURE_SAMPLES, 1);
GET_ENUM(GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, 1);
GET_INT(GL_TEXTURE_RED_SIZE, 1);
GET_INT(GL_TEXTURE_GREEN_SIZE, 1);
GET_INT(GL_TEXTURE_BLUE_SIZE, 1);
GET_INT(GL_TEXTURE_ALPHA_SIZE, 1);
GET_INT(GL_TEXTURE_DEPTH_SIZE, 1);
GET_INT(GL_TEXTURE_STENCIL_SIZE, 1);
GET_INT(GL_TEXTURE_LUMINANCE_SIZE, 1);
GET_INT(GL_TEXTURE_INTENSITY_SIZE, 1);
GET_INT(GL_TEXTURE_SHARED_SIZE, 1);
GET_INT(GL_TEXTURE_COMPRESSED, 1);
bool is_compressed = (bool)iVals[0];
if (info.supports_extension("GL_ARB_depth_texture"))
{
GET_INT(GL_TEXTURE_DEPTH_SIZE, 1);
GET_INT(GL_TEXTURE_DEPTH_TYPE, 1);
}
if (info.supports_extension("GL_EXT_packed_depth_stencil"))
GET_INT(GL_TEXTURE_STENCIL_SIZE_EXT, 1);
if (m_pTexture->get_target() == GL_TEXTURE_BUFFER)
{
GET_INT(GL_TEXTURE_BUFFER_DATA_STORE_BINDING, 1);
GET_INT(GL_TEXTURE_BUFFER_OFFSET, 1);
GET_INT(GL_TEXTURE_BUFFER_SIZE, 1);
}
if (is_compressed)
{
GET_INT(GL_TEXTURE_COMPRESSED_IMAGE_SIZE, 1);
}
}
}
#undef GET_FLOAT
#undef GET_ENUM
#undef GET_INT
}
