/*
* Copyright 1993, 1995, Silicon Graphics, Inc.
* ALL RIGHTS RESERVED
*
* This source code ("Source Code") was originally derived from a
* code base owned by Silicon Graphics, Inc. ("SGI")
*
* LICENSE: SGI grants the user ("Licensee") permission to reproduce,
* distribute, and create derivative works from this Source Code,
* provided that: (1) the user reproduces this entire notice within
* both source and binary format redistributions and any accompanying
* materials such as documentation in printed or electronic format;
* (2) the Source Code is not to be used, or ported or modified for
* use, except in conjunction with OpenGL Performer; and (3) the
* names of Silicon Graphics, Inc. and SGI may not be used in any
* advertising or publicity relating to the Source Code without the
* prior written permission of SGI. No further license or permission
* may be inferred or deemed or construed to exist with regard to the
* Source Code or the code base of which it forms a part. All rights
* not expressly granted are reserved.
*
* This Source Code is provided to Licensee AS IS, without any
* warranty of any kind, either express, implied, or statutory,
* including, but not limited to, any warranty that the Source Code
* will conform to specifications, any implied warranties of
* merchantability, fitness for a particular purpose, and freedom
* from infringement, and any warranty that the documentation will
* conform to the program, or any warranty that the Source Code will
* be error free.
*
* IN NO EVENT WILL SGI BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT
* LIMITED TO DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES,
* ARISING OUT OF, RESULTING FROM, OR IN ANY WAY CONNECTED WITH THE
* SOURCE CODE, WHETHER OR NOT BASED UPON WARRANTY, CONTRACT, TORT OR
* OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR
* PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM,
* OR AROSE OUT OF USE OR RESULTS FROM USE OF, OR LACK OF ABILITY TO
* USE, THE SOURCE CODE.
*
* Contact information: Silicon Graphics, Inc.,
* 1600 Amphitheatre Pkwy, Mountain View, CA 94043,
* or: http://www.sgi.com
*/
/*
* file: gui.c
* --------------
* $Revision: 1.1 $
* $Date: 2000/11/21 21:39:43 $
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <Performer/pf.h>
#include <Performer/pfutil.h>
#include <Performer/pfui.h>
#include <math.h>
#include "main.h"
#include "perfly.h"
#include "gui.h"
#define streq(a,b) (strcmp(a,b) == 0)
#define numberof(things) (sizeof(things)/sizeof(*(things)))
#if 1 /* CUSTOM */
#define log2(x) (log(x)*M_LOG2E)
#define round(x) floor((x)+.5)
#endif /* CUSTOM */
/*-----------------------------------------------------------*/
static pfuPanel *initPanel(void);
static pfuGUIString styleStrs[] =
{
"Points",
"Lines",
"Dashed",
"Haloed",
"Hidden",
"Filled",
"Scribed"
};
static int styleVals[] =
{
PFUSTYLE_POINTS,
PFUSTYLE_LINES,
PFUSTYLE_DASHED,
PFUSTYLE_HALOED,
PFUSTYLE_HIDDEN,
PFUSTYLE_FILLED,
PFUSTYLE_SCRIBED,
};
static pfuGUIString textureStrs[] =
{
"Off",
"Default",
};
static int textureVals[] = {
0,
1,
};
static pfuGUIString lightingStrs[] =
{
"Off",
"Eye",
"Sun",
};
static int lightingVals[] = {
LIGHTING_OFF,
LIGHTING_EYE,
LIGHTING_SUN,
};
static pfuGUIString xformerStrs[] =
{
"Trackball",
"Drive",
"Fly",
"Tether" /* option only appears if numVehicles > 0 */
};
static int xformerVals[] =
{
PFITDF_TRACKBALL,
PFITDF_DRIVE,
PFITDF_FLY,
PFITDF_TETHER
};
static pfuGUIString eskyStrs[] =
{
"Sky/Clear",
"Sky/Grnd",
"Sky",
"Clear",
"Tag"
};
static int eskyVals[] =
{
PFES_SKY_CLEAR,
PFES_SKY_GRND,
PFES_SKY,
PFES_FAST,
PFES_TAG
};
static pfuGUIString cullStrs[] =
{
"All",
"View",
"View, GSet",
"Sort",
"ignore lsources",
"View, Sort",
"View, GSet, Sort",
"View (no lsources)",
"Sort (ignore lsources)",
"View, GSet (ignore lsources)",
"View, Sort (ignore lsources)",
"View, GSet, Sort (ignore lsources)",
"None"
};
static int cullVals[] =
{
PFCULL_ALL,
PFCULL_VIEW,
PFCULL_VIEW | PFCULL_GSET,
PFCULL_SORT,
PFCULL_IGNORE_LSOURCES,
PFCULL_VIEW | PFCULL_SORT,
PFCULL_VIEW | PFCULL_GSET | PFCULL_SORT,
PFCULL_VIEW | PFCULL_IGNORE_LSOURCES,
PFCULL_SORT | PFCULL_IGNORE_LSOURCES,
PFCULL_VIEW | PFCULL_GSET | PFCULL_IGNORE_LSOURCES,
PFCULL_VIEW | PFCULL_SORT | PFCULL_IGNORE_LSOURCES,
PFCULL_VIEW | PFCULL_GSET | PFCULL_SORT | PFCULL_IGNORE_LSOURCES,
0
};
static pfuGUIString highStrs[] =
{
"Lines",
"Line BBox",
"Fill BBox",
"Normals",
"Points",
"Fill",
"Pattern",
"Texture"
};
static int highVals[] =
{
PFHL_LINES,
PFHL_BBOX_LINES | PFHL_LINES,
PFHL_BBOX_LINES | PFHL_BBOX_FILL | PFHL_LINES_R | PFHL_SKIP_BASE,
PFHL_NORMALS,
PFHL_POINTS,
PFHL_FILL | PFHL_LINES | PFHL_LINES_R | PFHL_SKIP_BASE,
PFHL_FILLPAT | PFHL_LINESPAT,
PFHL_FILLTEX
};
static pfuGUIString fogStrs[] =
{
"Off",
"Linear",
"Exp",
"Exp^2",
"Spline"
};
static int fogVals[] =
{
PFFOG_OFF,
PFFOG_PIX_LIN,
PFFOG_PIX_EXP,
PFFOG_PIX_EXP2,
PFFOG_PIX_SPLINE
};
#define NUM_STATSVALS 4
static pfuGUIString statsStrs[] =
{
"Dft",
"Gfx",
"Pipe",
"Fill"
};
static int statsVals[] =
{
PFFSTATS_ENPFTIMES,
PFFSTATS_ENPFTIMES | PFSTATS_ENGFX | PFSTATS_ENTEXLOAD | PFFSTATS_ENDB | PFFSTATS_ENCULL,
PFFSTATS_ENGFXPFTIMES,
PFSTATSHW_ENGFXPIPE_FILL | PFFSTATS_ENPFTIMES,
};
#if 1 /* CUSTOM */
#define FAKECLIP_MAX_IMAGE_SELECTIONS 50
static pfuGUIString imageStrs[FAKECLIP_MAX_IMAGE_SELECTIONS] =
{
"Hunter",
"Leo",
"S.F.",
"S.F. Gridified",
"Ed&TJ",
};
static char *imageFileNames[FAKECLIP_MAX_IMAGE_SELECTIONS] =
{
"hl.%d.r000.c000.rgb",
"leo.%d.rgb",
"sfo.%d.rgb",
};
int numImageSelections = 3;
#endif /* CUSTOM */
static pfuGUIString clipCenteringStrs[] =
{
"Fixed",
"Auto",
"Spiral",
"Mouse Drag",
};
#if 1 /* CUSTOM */
static pfuGUIString virtualSizeStrs[] =
{
"1x1",
"2x2",
"4x4",
"8x8",
"16x16",
"32x32",
"64x64",
"128x128",
"256x256",
"512x512",
"1024x1024",
"2048x2048",
"4096x4096",
"8192x8192",
"16384x16384",
"32768x32768",
"65536x65536",
};
static int virtualSizeVals[] =
{
1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
16384, 32768, 65536,
};
static pfuGUIString clipSizeStrs[] =
{
"1x1",
"2x2",
"4x4",
"8x8",
"16x16",
"32x32",
"64x64",
"128x128",
"256x256",
"512x512",
"1024x1024",
"2048x2048",
"4096x4096",
"8192x8192",
"16384x16384",
"32768x32768",
"65536x65536",
};
static int clipSizeVals[] =
{
1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
16384, 32768, 65536,
};
#define FAKECLIP_VIS_ROAM (1<<0)
#define FAKECLIP_VIS_WRAP (1<<1)
#define FAKECLIP_VIS_INLEVEL (1<<2)
#endif /* CUSTOM */
#if 0 /* PERFLY */
#define CLIP_VIS_ROAM (1<<0)
#define CLIP_VIS_WRAP (1<<1)
#define CLIP_VIS_INLEVEL (1<<2)
#endif /* PERFLY */
static pfuGUIString clipVisStrs[] =
{
"Default",
"Wrap",
"Roam in Level",
"Wrap in Level",
};
static int clipVisVals[] =
{
0,
#if 0 /* PERFLY */
CLIP_VIS_WRAP,
CLIP_VIS_ROAM|CLIP_VIS_INLEVEL,
CLIP_VIS_WRAP|CLIP_VIS_INLEVEL,
#endif /* PERFLY */
#if 1 /* CUSTOM */
FAKECLIP_VIS_WRAP,
FAKECLIP_VIS_ROAM|FAKECLIP_VIS_INLEVEL,
FAKECLIP_VIS_WRAP|FAKECLIP_VIS_INLEVEL,
#endif /* CUSTOM */
};
/* every possible filter value */
static pfuGUIString allInterpStrs[] =
{
"POINT",
"LINEAR",
"BILINEAR",
"TRILINEAR",
"QUADLINEAR",
"MIPMAP_POINT",
"MIPMAP_LINEAR",
"MIPMAP_BILINEAR",
"MIPMAP_TRILINEAR",
"MIPMAP_QUADLINEAR",
"CLIPMAP POINT",
"CLIPMAP LINEAR",
"CLIPMAP BILINEAR",
"CLIPMAP TRILINEAR",
"CLIPMAP QUADLINEAR",
"CLIPMAP MIPMAP_POINT",
"CLIPMAP MIPMAP_LINEAR",
"CLIPMAP MIPMAP_BILINEAR",
"CLIPMAP MIPMAP_TRILINEAR",
"CLIPMAP MIPMAP_QUADLINEAR",
};
static int allInterpVals[] =
{
PFTEX_POINT,
PFTEX_LINEAR,
PFTEX_BILINEAR,
PFTEX_TRILINEAR,
PFTEX_QUADLINEAR,
PFTEX_MIPMAP_POINT,
PFTEX_MIPMAP_LINEAR,
PFTEX_MIPMAP_BILINEAR,
PFTEX_MIPMAP_TRILINEAR,
PFTEX_MIPMAP_QUADLINEAR,
PFTEX_CLIPMAP|PFTEX_POINT,
PFTEX_CLIPMAP|PFTEX_LINEAR,
PFTEX_CLIPMAP|PFTEX_BILINEAR,
PFTEX_CLIPMAP|PFTEX_TRILINEAR,
PFTEX_CLIPMAP|PFTEX_QUADLINEAR,
PFTEX_CLIPMAP|PFTEX_MIPMAP_POINT,
PFTEX_CLIPMAP|PFTEX_MIPMAP_LINEAR,
PFTEX_CLIPMAP|PFTEX_MIPMAP_BILINEAR,
PFTEX_CLIPMAP|PFTEX_MIPMAP_TRILINEAR,
PFTEX_CLIPMAP|PFTEX_MIPMAP_QUADLINEAR,
};
/* more succinct/reasonable/commonly-used values-- must include the defaults */
static pfuGUIString interpStrs[] =
{
"POINT",
"BILINEAR",
"CLIPMAP_TRILINEAR",
};
static int interpVals[] =
{
PFTEX_POINT,
PFTEX_BILINEAR,
PFTEX_CLIPMAP_TRILINEAR,
};
#if 1 /* CUSTOM */
static pfuGUIString minFilterStrs[] =
{
"POINT",
"BILINEAR",
"MIPMAP_POINT",
"MIPMAP_LINEAR",
"MIPMAP_BILINEAR",
"MIPMAP_TRILINEAR",
};
static int minFilterVals[] =
{
PFTEX_POINT,
PFTEX_BILINEAR,
PFTEX_MIPMAP_POINT,
PFTEX_MIPMAP_LINEAR,
PFTEX_MIPMAP_BILINEAR,
PFTEX_MIPMAP_TRILINEAR,
};
static pfuGUIString magFilterStrs[] =
{
"POINT",
"BILINEAR",
};
static int magFilterVals[] =
{
PFTEX_POINT,
PFTEX_BILINEAR,
};
#endif
static pfuGUIString DTRmodeStrs[] =
{ /* NOTE: only choosing interesting subset of all permutations */
"None", /* no load control */
"MEMLOAD", /* valid mem tiles */
"MEM_TEX", /* valid mem tiles, tex load time */
"MEM_READSORT", /* valid mem tiles, sort read queue */
"MEM_TEX_READSORT", /* valid mem tiles, tex load time, sort read q*/
"MEM_CLIPSIZE", /* valid mem tiles, shrink effective clip size */
"MEM_TEX_CLIPSIZE", /* also check tex load time */
"MEM_TEX_READSORT_CLIPSIZE", /* also sort read queue */
};
static int DTRmodeVals[] =
{
0,
PF_DTR_MEMLOAD,
PF_DTR_MEMLOAD | PF_DTR_TEXLOAD,
PF_DTR_MEMLOAD | PF_DTR_READSORT,
PF_DTR_MEMLOAD | PF_DTR_TEXLOAD | PF_DTR_READSORT,
PF_DTR_MEMLOAD | PF_DTR_TEXSIZE,
PF_DTR_MEMLOAD | PF_DTR_TEXLOAD | PF_DTR_TEXSIZE,
PF_DTR_MEMLOAD | PF_DTR_TEXLOAD | PF_DTR_READSORT | PF_DTR_TEXSIZE
};
/*-----------------------------------------------------------*/
void
initGUI(pfChannel *masterChan)
{
float a, b, c, d;
pfuPanel *panel;
/* Set up size and position of GUI control panel */
pfGetChanViewport(masterChan, &a, &b, &c, &d);
if (ViewState->guiFormat == GUI_VERTICAL)
{
pfuGUIViewport(a, a + 0.22 * (b-a), c, d);
pfChanViewport(masterChan, a + 0.22 * (b-a), b, c, d);
}
else
{
pfuGUIViewport(a, b, c, c + 0.22 * (d-c));
pfChanViewport(masterChan, a , b, c + 0.22 * (d-c), d);
}
panel = initPanel();
pfuEnablePanel(panel);
updateGUI(ViewState->gui);
}
void
updateWidget(int widget, float val)
{
if (widget == GUI_STATS)
pfuWidgetOnOff(ViewState->guiWidgets[widget], val);
else
pfuWidgetValue(ViewState->guiWidgets[widget], val);
(*pfuGetWidgetActionFunc(ViewState->guiWidgets[widget]))
(ViewState->guiWidgets[widget]);
}
void
updateGUIViewMsg(void)
{
static char posBuf[256];
pfCoord *viewpt;
/* put in position */
viewpt = &ViewState->viewCoord;
sprintf(posBuf," X%5.1f Y%5.1f Z%5.1f H%5.1f P%5.1f R%5.1f",
viewpt->xyz[PF_X],viewpt->xyz[PF_Y],viewpt->xyz[PF_Z],
viewpt->hpr[PF_H],viewpt->hpr[PF_P],viewpt->hpr[PF_R]);
pfuWidgetLabel(ViewState->guiWidgets[GUI_MSG], posBuf);
}
/*
* updateGUI-
* This routine is called when channels are updated,
* i.e. the GUI is turned ON/OFF
*/
void
updateGUI(int guiOn)
{
float l, r, b, t;
float ca, cb, cc, cd;
if( guiOn )
{
pfuEnableGUI(TRUE);
pfuGetGUIViewport(&l, &r, &b, &t);
pfGetChanViewport(ViewState->masterChan,&ca,&cb,&cc,&cd);
if(ViewState->guiFormat == GUI_VERTICAL)
pfChanViewport(ViewState->masterChan, r, cb, cc, cd);
else
pfChanViewport(ViewState->masterChan, ca, cb, t, cd);
}
else /* turn off GUI */
{
pfuEnableGUI(FALSE);
if (Multipipe || (ViewState->numChans == 1))
pfChanViewport(ViewState->masterChan, 0.0f, 1.0f, 0.0f, 1.0f);
else if (!Multipipe && ViewState->MCO && (ViewState->numChans > 1))
pfuConfigMCO(ViewState->chan,ViewState->numChans);
else
{
pfuGetGUIViewport(&l, &r, &b, &t);
pfGetChanViewport(ViewState->masterChan,&ca,&cb,&cc,&cd);
ca = l;
cc = b;
pfChanViewport(ViewState->masterChan, ca, cb, cc, cd);
}
}
}
static void
controlPanel(pfuWidget *w)
{
switch(pfuGetWidgetId(w))
{
case GUI_COLLIDE:
xformerModel(ViewState->xformerModel,
ViewState->collideMode = (int)pfuGetWidgetValue(w));
break;
case GUI_CULL:
ViewState->cullMode = (int)pfuGetWidgetValue(w);
#if 1 /* CUSTOM */
/* HACK */
ViewState->cullMode = 0;
#endif /* CUSTOM */
break;
case GUI_ESKY:
ViewState->earthSkyMode = (int)pfuGetWidgetValue(w);
break;
case GUI_FAR:
ViewState->far = pfuGetWidgetValue(w);
pfChanNearFar(ViewState->masterChan, ViewState->near, ViewState->far);
break;
case GUI_XFORMER:
{
int newValue = (int)pfuGetWidgetValue(w);
int newSelection = (int)pfuGetWidgetSelection(w);
ViewState->xformerModel = newValue;
ViewState->rotateCenter = (newSelection == 0);
}
xformerModel(ViewState->xformerModel, ViewState->collideMode);
break;
case GUI_HIGH_STYLE:
{
pfHighlight *hlight = pfuGetGUIHlight();
int mode = (int)pfuGetWidgetValue(w);
if (hlight != NULL)
pfHlightMode(hlight, mode);
}
break;
case GUI_FOG:
ViewState->fog = pfuGetWidgetValue(w);
#if 0 /* PERFLY */
if (ViewState->fog)
{
pfuEnableWidget(ViewState->guiWidgets[GUI_NEAR_FOG_RANGE]);
pfuEnableWidget(ViewState->guiWidgets[GUI_FAR_FOG_RANGE]);
}
else
{
pfuDisableWidget(ViewState->guiWidgets[GUI_NEAR_FOG_RANGE]);
pfuDisableWidget(ViewState->guiWidgets[GUI_FAR_FOG_RANGE]);
}
#endif /* PERFLY */
break;
#if 0 /* PERFLY */
/* Update Fog Far Range according to slider value */
case GUI_FAR_FOG_RANGE:
ViewState->farFogRange = pfuGetWidgetValue(w);
if (ViewState->farFogRange < ViewState->nearFogRange)
{
ViewState->farFogRange = 1.01f * ViewState->nearFogRange;
pfuWidgetValue(ViewState->guiWidgets[GUI_FAR_FOG_RANGE],
ViewState->farFogRange);
}
break;
case GUI_NEAR_FOG_RANGE:
ViewState->nearFogRange = pfuGetWidgetValue(w);
if (ViewState->farFogRange < ViewState->nearFogRange)
{
ViewState->nearFogRange = (1.0f/1.01f) * ViewState->farFogRange;
pfuWidgetValue(ViewState->guiWidgets[GUI_NEAR_FOG_RANGE],
ViewState->nearFogRange);
}
break;
#endif /* PERFLY */
/* Update Field of View according to slider value */
case GUI_FOV:
{
int c;
float fov = pfuGetWidgetValue(w)/ViewState->numChans;
pfVec3 xyz;
pfVec3 hpr;
/* all channels share this new FOV */
if (InitFOV) { /* don't modify the fov */
pfChanFOV (ViewState->masterChan, ViewState->fov[0],
ViewState->fov[1]);
pfNotify(PFNFY_DEBUG, PFNFY_PRINT,
"Using user-supplied FOV for masterChan = %f %f\n",
ViewState->fov[0], ViewState->fov[1]);
}
else
{
pfChanFOV(ViewState->masterChan, fov, -1.0f);
ViewState->fov[0] = fov;
ViewState->fov[1] = -1.0;
ViewState->fov[2] = 0.0;
}
/* all channels have a positional offset of zero */
pfSetVec3(xyz, 0.0f, 0.0f, 0.0f);
/* set each channel's rotational offset */
for (c = 0; c < ViewState->numChans; c++)
{
if (InitFOV) {
pfSetVec3(hpr,
(((ViewState->numChans - 1)*0.5f) - c) *
ViewState->fov[2],
0.0f, 0.0f);
pfNotify(PFNFY_DEBUG, PFNFY_PRINT,
"Using user-supplied offset for channel %d %f\n",
c, hpr[0]);
} else
pfSetVec3(hpr,
(((ViewState->numChans - 1)*0.5f) - c) *
fov, 0.0f, 0.0f);
pfChanViewOffsets(ViewState->chan[ChanOrder[c]], xyz, hpr);
}
}
break;
/* Update Cull Field of View Delta according to slider value */
case GUI_FOV_CULL:
ViewState->cullDelta = pfuGetWidgetValue(w);
break;
/* Turns off GUI- F1 to turn back on */
case GUI_GUI:
ViewState->gui = 0;
ViewState->updateChannels = 1;
break;
/* Toggle Lighting */
case GUI_LIGHTING:
{
ViewState->lighting = (int)pfuGetWidgetValue(w);
#if 0 /* PERFLY */
if (ViewState->lighting == LIGHTING_OFF)
pfuDisableWidget(ViewState->guiWidgets[GUI_TOD]);
else
pfuEnableWidget(ViewState->guiWidgets[GUI_TOD]);
#endif /* PERFLY */
drawModesChanged();
}
break;
#if 0 /* PERFLY */
case GUI_AA:
{
static int prevFade = 1;
ViewState->aa = (int)pfuGetWidgetValue(w);
if (!ViewState->aa)
{
prevFade = ViewState->fade;
if (ViewState->fade)
{
ViewState->fade = 0;
pfChanLODAttr(ViewState->masterChan, PFLOD_FADE, 0.0f);
pfuWidgetValue(ViewState->guiWidgets[GUI_LOD_FADE],0.0f);
pfuDisableWidget(ViewState->guiWidgets[GUI_LOD_FADE]);
pfuDisableWidget(ViewState->guiWidgets[GUI_LOD_FADE_RANGE]);
}
}
else if (ViewState->aa && prevFade && ViewState->haveMultisample)
{
ViewState->fade = 1;
pfChanLODAttr(ViewState->masterChan, PFLOD_FADE, ViewState->fadeRange);
pfuWidgetValue(ViewState->guiWidgets[GUI_LOD_FADE],1.0f);
pfuEnableWidget(ViewState->guiWidgets[GUI_LOD_FADE]);
pfuEnableWidget(ViewState->guiWidgets[GUI_LOD_FADE_RANGE]);
}
drawModesChanged();
break;
}
/* Update LOD Fade Range according to slider value */
case GUI_LOD_FADE:
ViewState->fade = pfuGetWidgetValue(w);
if (ViewState->haveMultisample)
{
if (ViewState->fade)
{
pfChanLODAttr(ViewState->masterChan, PFLOD_FADE, ViewState->fadeRange);
pfuEnableWidget(ViewState->guiWidgets[GUI_LOD_FADE_RANGE]);
}
else
{
pfChanLODAttr(ViewState->masterChan, PFLOD_FADE, 0.0f);
pfuDisableWidget(ViewState->guiWidgets[GUI_LOD_FADE_RANGE]);
}
}
break;
case GUI_LOD_FADE_RANGE:
if (ViewState->haveMultisample)
{
if (ViewState->fade)
pfChanLODAttr(ViewState->masterChan, PFLOD_FADE,
ViewState->fadeRange = pfuGetWidgetValue(w));
else
pfChanLODAttr(ViewState->masterChan, PFLOD_FADE, 0.0f);
}
break;
/* Update LOD Scale according to slider value */
case GUI_LOD_SCALE:
ViewState->LODscale = pfuGetWidgetValue(w);
break;
#endif /* PERFLY */
/* Update Near Clip Plane according to slider value */
case GUI_NEAR:
ViewState->near = pfuGetWidgetValue(w);
pfChanNearFar(ViewState->masterChan, ViewState->near, ViewState->far);
break;
case GUI_PHASE:
pfPhase((int)pfuGetWidgetValue(w));
break;
#if 0 /* PERFLY */
case GUI_PIX_LIMIT:
pfChanLODAttr(ViewState->masterChan, PFLOD_STRESS_PIX_LIMIT,
(int)pfuGetWidgetValue(w));
break;
#endif /* PERFLY */
case GUI_REPOSITION:
if (ViewState->numInitViews > 1)
ViewState->resetPosition = (int)pfuGetWidgetValue(w);
else
ViewState->resetPosition = POS_ORIG;
break;
case GUI_TETHERVIEW:
ViewState->curTetherView = (int)pfuGetWidgetValue(w);
break;
case GUI_VEHICLE:
ViewState->curVehicle = (int)pfuGetWidgetValue(w);
break;
case GUI_CENTER:
ViewState->resetPosition = POS_CENTER;
break;
case GUI_QUIT:
ViewState->exitFlag = TRUE;
break;
case GUI_STATS:
ViewState->stats = pfuIsWidgetOn(w) ? 1 : 0;
ViewState->statsEnable = (uint) pfuGetWidgetValue(w);
break;
case GUI_STRESS:
ViewState->stress = (int)pfuGetWidgetValue(w);
#if 0 /* PERFLY */
if (ViewState->stress)
{
pfuEnableWidget(ViewState->guiWidgets[GUI_STRESS_LOW]);
pfuEnableWidget(ViewState->guiWidgets[GUI_STRESS_HIGH]);
pfuEnableWidget(ViewState->guiWidgets[GUI_STRESS_SCALE]);
pfuEnableWidget(ViewState->guiWidgets[GUI_STRESS_MAX]);
pfuEnableWidget(ViewState->guiWidgets[GUI_PIX_LIMIT]);
}
else
{
pfuDisableWidget(ViewState->guiWidgets[GUI_STRESS_LOW]);
pfuDisableWidget(ViewState->guiWidgets[GUI_STRESS_HIGH]);
pfuDisableWidget(ViewState->guiWidgets[GUI_STRESS_SCALE]);
pfuDisableWidget(ViewState->guiWidgets[GUI_STRESS_MAX]);
pfuDisableWidget(ViewState->guiWidgets[GUI_PIX_LIMIT]);
}
#endif /* PERFLY */
break;
#if 0 /* PERFLY */
case GUI_STRESS_LOW:
{
float low = pfuGetWidgetValue(w);
if (low < ViewState->highLoad)
ViewState->lowLoad = low;
else
{
ViewState->lowLoad = ViewState->highLoad -0.1f;
pfuWidgetValue(w,ViewState->lowLoad);
}
}
break;
case GUI_STRESS_HIGH:
{
float high = pfuGetWidgetValue(w);
if (high > ViewState->lowLoad)
ViewState->highLoad = high;
else
{
ViewState->highLoad = ViewState->lowLoad + 0.1f;
pfuWidgetValue(w,ViewState->highLoad);
}
}
break;
case GUI_STRESS_MAX:
ViewState->stressMax = pfuGetWidgetValue(w);
break;
case GUI_STRESS_SCALE:
ViewState->stressScale = pfuGetWidgetValue(w);
break;
#endif /* PERFLY */
case GUI_TEXTURE:
ViewState->texture = (int)pfuGetWidgetValue(w);
drawModesChanged();
break;
#if 0 /* PERFLY */
case GUI_TOD:
ViewState->timeOfDay = pfuGetWidgetValue(w);
updateTimeOfDay(ViewState->timeOfDay);
break;
#endif /* PERFLY */
case GUI_TREE:
ViewState->tree = (int) pfuGetWidgetValue(w);
if (ViewState->tree)
{
pfuEnableWidget(ViewState->guiWidgets[GUI_PANX]);
pfuEnableWidget(ViewState->guiWidgets[GUI_PANY]);
pfuEnableWidget(ViewState->guiWidgets[GUI_SCALE]);
}
else
{
pfuDisableWidget(ViewState->guiWidgets[GUI_PANX]);
pfuDisableWidget(ViewState->guiWidgets[GUI_PANY]);
pfuDisableWidget(ViewState->guiWidgets[GUI_SCALE]);
}
break;
case GUI_DEMO:
{
ViewState->demoMode = pfuGetWidgetValue(w);
}
break;
case GUI_PATH:
{
ViewState->recordPath = (pfuGetWidgetValue(w) ? 2 : 0);
}
break;
case GUI_PANX:
ViewState->panScale[0] = pfuGetWidgetValue(w);
break;
case GUI_PANY:
ViewState->panScale[1] = pfuGetWidgetValue(w);
break;
case GUI_SCALE:
ViewState->panScale[2] = pfuGetWidgetValue(w);
break;
case GUI_DRAW_STYLE:
ViewState->drawStyle = (int)pfuGetWidgetValue(w);
drawModesChanged();
break;
case GUI_SNAP:
ViewState->snapImage = 1;
break;
#if 1 /* CUSTOM */
case GUI_FAKECLIP_MIN_LOD:
FakeClipGuiState->min_lod = pfuGetWidgetValue(w);
break;
case GUI_FAKECLIP_INVALID_BORDER:
FakeClipGuiState->invalid_border = pfuGetWidgetValue(w) / FakeClipGuiState->exaggeration;
break;
case GUI_FAKECLIP_IMAGE:
FakeClipGuiState->clip_centering = pfuGetWidgetValue(w);
break;
case GUI_FAKECLIP_VIRTUAL_SIZE:
FakeClipGuiState->virtual_size = pfuGetWidgetValue(w);
/* clip size must be <= virtual size */
FakeClipGuiState->clip_size = PF_MIN2(
FakeClipGuiState->clip_size,
FakeClipGuiState->virtual_size);
pfuWidgetSelections(ViewState->guiWidgets[GUI_FAKECLIP_CLIP_SIZE],
clipSizeStrs, clipSizeVals, NULL,
(int)round(log2(FakeClipGuiState->virtual_size))+1);
pfuWidgetDefaultValue(ViewState->guiWidgets[GUI_FAKECLIP_CLIP_SIZE],
FakeClipGuiState->virtual_size/4); /* seems about right */
/* invalid border must be <= clip_size/2 */
/* XXX code duplicated below */
FakeClipGuiState->invalid_border = PF_MIN2(
FakeClipGuiState->invalid_border,
FakeClipGuiState->clip_size/2);
pfuWidgetRange(ViewState->guiWidgets[GUI_FAKECLIP_INVALID_BORDER],
0, 0.0f, FakeClipGuiState->clip_size/2*FakeClipGuiState->exaggeration,
FakeClipGuiState->invalid_border*FakeClipGuiState->exaggeration);
break;
case GUI_FAKECLIP_CLIP_SIZE:
FakeClipGuiState->clip_size = pfuGetWidgetValue(w);
/* invalid border must be <= clip_size/2 */
/* XXX code duplicated below */
FakeClipGuiState->invalid_border = PF_MIN2(
FakeClipGuiState->invalid_border,
FakeClipGuiState->clip_size/2);
pfuWidgetRange(ViewState->guiWidgets[GUI_FAKECLIP_INVALID_BORDER],
0, 0.0f, FakeClipGuiState->clip_size/2*FakeClipGuiState->exaggeration,
FakeClipGuiState->invalid_border*FakeClipGuiState->exaggeration);
break;
case GUI_FAKECLIP_CLIP_CENTERING:
FakeClipGuiState->clip_centering = pfuGetWidgetValue(w);
break;
case GUI_FAKECLIP_CLIP_VISUALIZATION:
{
int val = (int)pfuGetWidgetValue(w);
FakeClipGuiState->visualize_roam = (val&FAKECLIP_VIS_ROAM) != 0;
FakeClipGuiState->visualize_wrap = (val&FAKECLIP_VIS_WRAP) != 0;
FakeClipGuiState->visualize_inlevel = (val&FAKECLIP_VIS_INLEVEL) != 0;
}
break;
case GUI_FAKECLIP_MINFILTER:
FakeClipGuiState->minfilter = (int)pfuGetWidgetValue(w);
break;
case GUI_FAKECLIP_MAGFILTER:
FakeClipGuiState->magfilter = (int)pfuGetWidgetValue(w);
break;
#endif /* CUSTOM */
case GUI_MIP_MIN_LOD:
ViewState->mip_min_lod = pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_MIP_MAX_LOD:
ViewState->mip_max_lod = pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIP_INVALID_BORDER:
ViewState->clip_invalid_border = pfuGetWidgetValue(w);
if (getenv("PFCLIP_AUTO_BIAS")!=NULL)
{
#define log2(x) (log(x)*M_LOG2E)
#define round(x) floor((x)+.5)
ViewState->lod_biasS = -1.0f * log2((1024.0f-2.0f*(float)ViewState->clip_invalid_border)/2048.0f);
ViewState->lod_biasT = ViewState->lod_biasR = ViewState->lod_biasS;
pfuWidgetValue(ViewState->guiWidgets[GUI_MIP_LOD_BIAS], ViewState->lod_biasS);
}
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIP_CENTERING:
ViewState->clip_centering = (int)pfuGetWidgetValue(w);
break;
case GUI_CLIP_VISUALIZATION:
ViewState->clip_visualize = (int)pfuGetWidgetValue(w);
break;
case GUI_MIP_LOD_BIAS:
ViewState->lod_bias = pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_MIP_LOD_BIAS_S:
ViewState->lod_biasS = pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_MIP_LOD_BIAS_T:
ViewState->lod_biasT = pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIP_LOD_OFFSET:
ViewState->clip_lod_offset = (int)pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIP_EFFECTIVE_LEVELS:
ViewState->clip_effective_levels = (int)pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_MIP_MAGFILTER:
ViewState->mip_magfilter = (int)pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_MIP_MINFILTER:
ViewState->mip_minfilter = (int)pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIP_DTRMODE:
ViewState->clip_dtrmode = (int)pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIP_DTR_TIME:
ViewState->clip_dtr_time = (float)pfuGetWidgetValue(w);
ViewState->clip_params_dirty = 1;
break;
case GUI_CLIPTEX_SELECT:
ViewState->clip_texture_i = (int)pfuGetWidgetValue(w);
setClipTexture_i(ViewState->scene, ViewState->clip_texture_i);
break;
case GUI_CALLIGRAPHIC_DEFOCUS:
ViewState->calligDefocus = pfuGetWidgetValue(w);
ViewState->calligDirty = 1;
break;
case GUI_RASTER_DEFOCUS:
ViewState->rasterDefocus = pfuGetWidgetValue(w);
ViewState->calligDirty = 1;
break;
case GUI_FILTER_SIZEX:
ViewState->calligFilterSizeX = (int) pfuGetWidgetValue(w);
ViewState->calligDirty = 1;
break;
case GUI_FILTER_SIZEY:
ViewState->calligFilterSizeY = (int)pfuGetWidgetValue(w);
ViewState->calligDirty = 1;
break;
case GUI_ZFOOT_PRINT:
ViewState->calligZFootPrint = pfuGetWidgetValue(w);
ViewState->calligDirty = 1;
break;
default:
break;
}
}
#ifdef _PF_MULTI_VIEWSTATE
void config(pfuWidget *w)
{
int which = (int)pfuGetWidgetValue(w);
if (AllViewStates->states[which]->guiWidgets[GUI_CONFIG] == NULL)
{
/*
* ViewState has been further initialized since the
* alternate ViewState selections were cloned.
* states[0] contains a copy of before the clones,
* so for each i, apply the diffs states[0] -> ViewState
* to states[i].
* XXX nice try, but there's no way this idea can ever work bytewise
*/
int i;
for (i = 1; i < AllViewStates->nstates; ++i)
{
char *p0 = (char *)AllViewStates->states[0]; /* original */
char *p1 = (char *)ViewState; /* fork 1 */
char *p2 = (char *)AllViewStates->states[i]; /* fork 2 */
char *p3 = (char *)AllViewStates->states[i]; /* merged */
int j, n = sizeof(*AllViewStates->states[0]);
for (j = 0; j < n; ++j)
{
if (p2[j] != p0[j])
p3[j] = p2[j];
else
p3[j] = p1[j];
}
}
*AllViewStates->states[which] = *ViewState;
}
*ViewState = *AllViewStates->states[which]; /* XXX no doubt illegal to do this here */
}
#endif
/* ARGSUSED (suppress compiler warn) */
void resetAll(pfuWidget *w)
{
pfuResetGUI();
ViewState->resetPosition = POS_ORIG;
}
static pfuPanel *
initPanel(void)
{
float xo, yo, ys, xs;
int x, y;
int xSize, ySize, xSize3, fullSize;
pfuWidget *wid;
pfuPanel *panel;
/* init the GUI panel for perfly */
panel = pfuNewPanel();
pfuGetPanelOriginSize(panel, &xo, &yo, &xs, &ys);
x = (int)xo;
y = (int)ys;
y -= PFUGUI_BUTTON_YINC;
xSize = fullSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_MESSAGE_YSIZE;
/* the message bar with positions */
wid = pfuNewWidget(panel, PFUGUI_MESSAGE, 0);
pfuWidgetDim(wid, x, y, xSize, ySize);
ViewState->guiWidgets[GUI_MSG] = wid;
y -= PFUGUI_BUTTON_YINC;
xSize = xSize3 = (xSize - 2*PFUGUI_PANEL_FRAME)/3.0f;
ySize = PFUGUI_BUTTON_YSIZE;
/* a quit button */
wid = pfuNewWidget(panel, PFUGUI_BUTTON, GUI_QUIT);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Quit");
pfuWidgetActionFunc(wid, controlPanel);
x += xSize + PFUGUI_PANEL_FRAME;
/* kill the gui */
wid = pfuNewWidget(panel, PFUGUI_BUTTON, GUI_GUI);
pfuWidgetLabel(wid,"GUI Off");
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
x += xSize + PFUGUI_PANEL_FRAME;
#ifdef _PF_MULTI_VIEWSTATE /* now allow multiple configurations */
if (AllViewStates != NULL && AllViewStates->nstates > 0)
{
/* Reset to a particular configuration */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_CONFIG);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Config");
pfuWidgetActionFunc(wid, config);
/* XXX this should be dynamically changeable */
pfuWidgetSelections(wid, AllViewStates->statenames, NULL, NULL,
AllViewStates->nstates);
/* XXX configvals is wrong! */
pfuWidgetDefaultValue(wid, 0);
ViewState->guiWidgets[GUI_CONFIG] = wid;
}
else
#endif
{
/* Reset all */
wid = pfuNewWidget(panel, PFUGUI_BUTTON, GUI_RESET_ALL);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Reset All");
pfuWidgetActionFunc(wid, resetAll);
ViewState->guiWidgets[GUI_RESET_ALL] = wid;
}
xSize = xSize3;
x = xo;
y -= PFUGUI_BUTTON_YINC;
/* Snap screen */
wid = pfuNewWidget(panel, PFUGUI_BUTTON, GUI_SNAP);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Snap Screen");
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_SNAP] = wid;
x += xSize + PFUGUI_PANEL_FRAME;
/*xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;*/
/* toggle Collision */
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_COLLIDE);
pfuWidgetLabel(wid,"Collide");
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetDefaultValue(wid,ViewState->collideMode);
ViewState->guiWidgets[GUI_COLLIDE] = wid;
x += xSize + PFUGUI_PANEL_FRAME;
/* Reset to center */
wid = pfuNewWidget(panel, PFUGUI_BUTTON, GUI_CENTER);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Center");
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_CENTER] = wid;
x = xo;
y -= PFUGUI_BUTTON_YINC;
xSize = fullSize;
if (ViewState->numInitViews > 1)
{
/* Reposition menu */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_REPOSITION);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Reposition");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, ViewState->initViewNames, NULL, NULL,
ViewState->numInitViews);
pfuWidgetDefaultValue(wid, 0);
}
else
{
/* Reposition button */
wid = pfuNewWidget(panel, PFUGUI_BUTTON, GUI_REPOSITION);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, streq(ViewState->initViewNames[0], "Default") ?
"Reposition" : ViewState->initViewNames[0]);
pfuWidgetActionFunc(wid, controlPanel);
}
ViewState->guiWidgets[GUI_REPOSITION] = wid;
y -= PFUGUI_BUTTON_YINC;
/* Xformer model */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_XFORMER);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Motion");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, xformerStrs, xformerVals, NULL,
ViewState->numVehicles > 0 ? 4 : 3);
pfuWidgetDefaultValue(wid, ViewState->xformerModel);
ViewState->guiWidgets[GUI_XFORMER] = wid;
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
y -= PFUGUI_BUTTON_YINC;
if (ViewState->numVehicles > 0) {
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_TETHERVIEW);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "View");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, ViewState->tetherViewNames, NULL, NULL,
PF_MAX2(ViewState->numTetherViews, 1));
pfuWidgetDefaultValue(wid, 0);
ViewState->guiWidgets[GUI_TETHERVIEW] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_VEHICLE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Vehicle");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, ViewState->vehicleNames, NULL, NULL,
ViewState->numVehicles);
pfuWidgetDefaultValue(wid, 0);
ViewState->guiWidgets[GUI_VEHICLE] = wid;
y -= PFUGUI_BUTTON_YINC;
}
x = xo;
/* select (fancy) draw style */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_DRAW_STYLE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid,"Style");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, styleStrs, styleVals, NULL,
sizeof(styleStrs)/sizeof(styleStrs[0]));
pfuWidgetDefaultValue(wid, PFUSTYLE_FILLED);
ViewState->guiWidgets[GUI_DRAW_STYLE] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
/* select (fancy) highlight style */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_HIGH_STYLE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Hlight");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, highStrs, highVals, NULL,
sizeof(highStrs)/sizeof(highStrs[0]));
pfuWidgetDefaultValue(wid, PFHL_LINES);
ViewState->guiWidgets[GUI_HIGH_STYLE] = wid;
x = xo;
y -= PFUGUI_BUTTON_YINC;
/* toggle Texture */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_TEXTURE);
pfuWidgetLabel(wid,"Texture");
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, textureStrs, textureVals, NULL,
sizeof(textureStrs)/sizeof(textureStrs[0]));
pfuWidgetDefaultValue(wid,ViewState->texture);
ViewState->guiWidgets[GUI_TEXTURE] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
/* Earth/Sky Model*/
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_ESKY);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "BG");
pfuWidgetActionFunc(wid, controlPanel);
/* if on RE, add PFES_TAG option */
if (ViewState->haveTagClear)
pfuWidgetSelections(wid, eskyStrs, eskyVals, NULL,
sizeof(eskyStrs)/sizeof(eskyStrs[0]));
else
pfuWidgetSelections(wid, eskyStrs, eskyVals, NULL,
sizeof(eskyStrs)/sizeof(eskyStrs[0]) - 1);
pfuWidgetDefaultValue(wid, ViewState->earthSkyMode);
ViewState->guiWidgets[GUI_ESKY] = wid;
if (ViewState->guiFormat == GUI_HORIZONTAL)
{
xo += 2*PFUGUI_BUTTON_VLONG_XINC;
y = ys;
}
x = xo;
y -= PFUGUI_BUTTON_YINC;
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
/* Stats mode */
wid = pfuNewWidget(panel,
PFUGUI_RADIO_BUTTON_TOGGLE | PFUGUI_HORIZONTAL, GUI_STATS);
pfuWidgetLabel(wid, "Stats");
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, statsStrs, statsVals, NULL,
sizeof(statsStrs)/sizeof(statsStrs[0]));
ViewState->guiWidgets[GUI_STATS] = wid;
pfuWidgetDefaultValue(wid, PFFSTATS_ENPFTIMES);
x = xo;
y -= PFUGUI_BUTTON_YINC;
ySize = PFUGUI_BUTTON_YSIZE;
/* cull mode */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_CULL);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Cull Mode");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, cullStrs, cullVals, NULL,
sizeof(cullStrs)/sizeof(cullStrs[0]));
pfuWidgetDefaultValue(wid, ViewState->cullMode);
ViewState->guiWidgets[GUI_CULL] = wid;
ySize = PFUGUI_SLIDER_YSIZE;
y -= PFUGUI_SLIDER_YINC;
/* Slider for FOV */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_FOV);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Field of View");
{
float minFOV, maxFOV, curFOV;
switch (ViewState->numChans)
{
case 1:
minFOV = 10.0f;
maxFOV = 160.0f;
curFOV = 45.0f;
break;
case 2:
minFOV = 10.0f;
maxFOV = 320.0f;
curFOV = 90.0f;
break;
default:
minFOV = 10.0f;
maxFOV = 360.0f;
curFOV = PF_MIN2(ViewState->numChans * 45.0f, 360.0f);
break;
}
/* If user gave an explicit FOV, let it expand the range */
if (InitFOV)
{
minFOV = PF_MIN2(minFOV, ViewState->fov[1]);
maxFOV = PF_MAX2(maxFOV, ViewState->fov[1]);
}
pfuWidgetRange(wid, 1, minFOV, maxFOV, curFOV);
}
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_FOV] = wid;
y -= PFUGUI_SLIDER_YINC;
/* Slider to set far clip plane distance */
wid = pfuNewWidget(panel, PFUGUI_SLIDER_LOG, GUI_FAR);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Far Clip");
pfuWidgetRange(wid, 1,
0.5f * ViewState->near,
10.0f * ViewState->far,
ViewState->far);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_FAR] = wid;
y -= PFUGUI_SLIDER_YINC;
/* Slider to set near clip plane distance */
wid = pfuNewWidget(panel, PFUGUI_SLIDER_LOG, GUI_NEAR);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Near Clip");
pfuWidgetRange(wid, 1,
0.00001f * ViewState->near,
2.0f * ViewState->far,
ViewState->near);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_NEAR] = wid;
y -= PFUGUI_SLIDER_YINC;
/* Slider for cull-view FOV */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_FOV_CULL);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Cull View FOV");
pfuWidgetRange(wid, 1, 0.0f, 1.0f, 1.0f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_FOV_CULL] = wid;
if (ViewState->guiFormat == GUI_HORIZONTAL)
{
xo += 2*PFUGUI_BUTTON_VLONG_XINC;
y = ys;
}
x = xo;
y -= PFUGUI_BUTTON_YINC;
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
ySize = PFUGUI_BUTTON_YSIZE;
/* preset fogs */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FOG);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Fog");
pfuWidgetActionFunc(wid, controlPanel);
{
int haveSplineFog;
pfQueryFeature(PFQFTR_FOG_SPLINE, &haveSplineFog);
if (haveSplineFog)
pfuWidgetSelections(wid, fogStrs, fogVals, NULL,
sizeof(fogStrs)/sizeof(fogStrs[0]));
else
pfuWidgetSelections(wid, fogStrs, fogVals, NULL,
sizeof(fogStrs)/sizeof(fogStrs[0]) - 1);
}
pfuWidgetDefaultValue(wid, ViewState->fog);
ViewState->guiWidgets[GUI_FOG] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
/* toggle Lighting*/
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_LIGHTING);
pfuWidgetLabel(wid,"Lighting");
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, lightingStrs, lightingVals, NULL,
sizeof(lightingStrs)/sizeof(lightingStrs[0]));
pfuWidgetDefaultValue(wid, ViewState->lighting);
ViewState->guiWidgets[GUI_LIGHTING] = wid;
x = xo;
#if 0 /* PERFLY */
y -= PFUGUI_SLIDER_YINC;
ySize = PFUGUI_SLIDER_YSIZE;
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
/* Slider for fog near range */
wid = pfuNewWidget(panel, PFUGUI_SLIDER_LOG, GUI_NEAR_FOG_RANGE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Near Fog");
pfuWidgetRange(wid, 1, 0.0f, ViewState->far*8.0f, ViewState->nearFogRange);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_NEAR_FOG_RANGE] = wid;
if (!ViewState->fog)
pfuDisableWidget(ViewState->guiWidgets[GUI_NEAR_FOG_RANGE]);
y -= PFUGUI_SLIDER_YINC;
/* Slider for fog far range */
wid = pfuNewWidget(panel, PFUGUI_SLIDER_LOG, GUI_FAR_FOG_RANGE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Far Fog");
pfuWidgetRange(wid, 1, 0.0f, ViewState->far*8.0f, ViewState->farFogRange);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_FAR_FOG_RANGE] = wid;
if (!ViewState->fog)
pfuDisableWidget(ViewState->guiWidgets[GUI_FAR_FOG_RANGE]);
y -= PFUGUI_SLIDER_YINC;
/* Slider for Time of Day */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_TOD);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Time Of Day");
pfuWidgetRange(wid, 1, 0.0f, 1.0f, 0.8f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_TOD] = wid;
y -= PFUGUI_SLIDER_YINC;
/* Global LOD Scale Slider */
wid = pfuNewWidget(panel, PFUGUI_SLIDER_LOG, GUI_LOD_SCALE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "LOD Scale");
pfuWidgetRange(wid, 1, 0.0f, 500.0f, ViewState->LODscale);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_LOD_SCALE] = wid;
if (ViewState->haveMultisample)
{
if (ViewState->guiFormat == GUI_HORIZONTAL)
{
xo += 2*PFUGUI_BUTTON_VLONG_XINC;
y = ys;
}
x = xo;
y -= PFUGUI_BUTTON_YINC;
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
ySize = PFUGUI_BUTTON_YSIZE;
/* toggle Anti-Aliasing*/
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_AA);
pfuWidgetLabel(wid,"Anti-Alias");
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetDefaultValue(wid, ViewState->aa);
x += PFUGUI_BUTTON_VLONG_XINC;
/* LOD Fade button */
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_LOD_FADE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Fade LOD");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetDefaultValue(wid, ViewState->fade);
if (!ViewState->fade)
pfuDisableWidget(wid);
ViewState->guiWidgets[GUI_LOD_FADE] = wid;
x = xo;
y -= PFUGUI_SLIDER_YINC;
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_LOD_FADE_RANGE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "LOD Fade Scale");
pfuWidgetRange(wid, 1, 0.0f, 200.0f, ViewState->fadeRange);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_LOD_FADE_RANGE] = wid;
if (!ViewState->fade)
pfuDisableWidget(wid);
}
#endif /* PERFLY */
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
y -= PFUGUI_SLIDER_YINC;
/* Slider for Show Tree X-Pan */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_PANX);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Show Tree X Pan");
pfuWidgetRange(wid, 1, -1.0f, 1.0f, 0.0f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_PANX] = wid;
if (!ViewState->tree)
pfuDisableWidget(wid);
y -= PFUGUI_SLIDER_YINC;
/* Slider for Show Tree Y-Pan */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_PANY);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Show Tree Y Pan");
pfuWidgetRange(wid, 1, 0.0f, 1.0f, 0.0f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_PANY] = wid;
if (!ViewState->tree)
pfuDisableWidget(wid);
y -= PFUGUI_SLIDER_YINC;
/* Slider for Show Tree Scale */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_SCALE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Show Tree Scale");
pfuWidgetRange(wid, 1, 0.01f, 2.0f, 1.0f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_SCALE] = wid;
if (!ViewState->tree)
pfuDisableWidget(wid);
y -= PFUGUI_BUTTON_YINC;
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
ySize = PFUGUI_BUTTON_YSIZE;
/* Tree display */
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_TREE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Show Tree");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetDefaultValue(wid, ViewState->tree);
ViewState->guiWidgets[GUI_TREE] = wid;
#if 0 /* PERFLY */
x += PFUGUI_BUTTON_VLONG_XINC;
/* Stress button */
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_STRESS);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Stress");
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_STRESS] = wid;
y -= PFUGUI_BUTTON_YINC;
x = xo;
/* Record Path button */
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_PATH);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Path");
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_PATH] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
/* Path Follow button */
wid = pfuNewWidget(panel, PFUGUI_SWITCH, GUI_DEMO);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Demo");
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_DEMO] = wid;
if (ViewState->guiFormat == GUI_HORIZONTAL)
{
x = xo += 2*PFUGUI_BUTTON_VLONG_XINC;
y = ys;
}
y -= PFUGUI_SLIDER_YINC;
x = xo;
/* Stress Low Slider */
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_STRESS_LOW);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Stress Low");
pfuWidgetRange(wid, 1, 0.0f, 1.0f, ViewState->lowLoad);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_STRESS_LOW] = wid;
if (!ViewState->stress)
pfuDisableWidget(wid);
y -= PFUGUI_SLIDER_YINC;
/* Stress High Slider */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_STRESS_HIGH);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Stress High");
pfuWidgetRange(wid, 1, 0.0f, 1.0f, ViewState->highLoad);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_STRESS_HIGH] = wid;
if (!ViewState->stress)
pfuDisableWidget(wid);
y -= PFUGUI_SLIDER_YINC;
/* Stress Max Slider */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_STRESS_MAX);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Stress Max");
pfuWidgetRange(wid, 1, 0.0f, 500.0f, ViewState->stressMax);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_STRESS_MAX] = wid;
if (!ViewState->stress)
pfuDisableWidget(wid);
y -= PFUGUI_SLIDER_YINC;
/* Stress Scale Slider */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_STRESS_SCALE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Stress Scale");
pfuWidgetRange(wid, 1, 0.0f, 4.0f, ViewState->stressScale);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_STRESS_SCALE] = wid;
if (!ViewState->stress)
pfuDisableWidget(wid);
y -= PFUGUI_SLIDER_YINC;
/* Pixel Limit Slider */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_PIX_LIMIT);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Stress Pixel Limit");
pfuWidgetRange(wid, 1, -1.0f, 1280.0f, -1.0f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_PIX_LIMIT] = wid;
#endif /* PERFLY */
#if 1 /* CUSTOM */
/* separate the interesting widgets at the bottom */
y -= PFUGUI_BUTTON_YINC;
x = xo;
/* Min LOD Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_FAKECLIP_MIN_LOD);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Min LOD");
pfuWidgetRange(wid, 1, 0.0f, log2(FakeClipGuiState->virtual_size),
FakeClipGuiState->min_lod);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_FAKECLIP_MIN_LOD] = wid;
/* Invalid Border Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_FAKECLIP_INVALID_BORDER);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Invalid Border");
pfuWidgetRange(wid, 0, 0.0f, FakeClipGuiState->clip_size/2*FakeClipGuiState->exaggeration,
FakeClipGuiState->invalid_border*FakeClipGuiState->exaggeration);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_FAKECLIP_INVALID_BORDER] = wid;
y -= PFUGUI_BUTTON_YINC;
#ifdef NOTYET
/* Image menu */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_IMAGE);
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Image");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, imageStrs, NULL, NULL, numImageSelections);
pfuWidgetDefaultValue(wid, 0);
ViewState->guiWidgets[GUI_FAKECLIP_IMAGE] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
#endif /* NOTYET */
/* Clip Centering menu */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_CLIP_CENTERING);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
#ifdef NOTYET
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
#endif
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Center");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, clipCenteringStrs, NULL, NULL, numberof(clipCenteringStrs));
pfuWidgetDefaultValue(wid, 1);
ViewState->guiWidgets[GUI_FAKECLIP_CLIP_CENTERING] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
x = xo;
y -= PFUGUI_BUTTON_YINC;
/* Virtual Size */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_VIRTUAL_SIZE);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Virtual Size");
pfuWidgetActionFunc(wid, controlPanel);
#ifdef NOTYET
pfuWidgetSelections(wid, virtualSizeStrs, virtualSizeVals, NULL,
(int)round(log2(FakeClipGuiState->virtual_size))+1);
pfuWidgetDefaultValue(wid, FakeClipGuiState->image_size);
#else
{
int nlevels = (int)round(log2(FakeClipGuiState->virtual_size)) + 1;
pfuWidgetSelections(wid, virtualSizeStrs+nlevels-1,
virtualSizeVals+nlevels-1,
NULL, 1);
pfuWidgetDefaultValue(wid, FakeClipGuiState->virtual_size);
}
#endif
printf("SETTING VIRTUAL SIZE WIDGET VAL TO %g\n", (double)FakeClipGuiState->image_size);
ViewState->guiWidgets[GUI_FAKECLIP_VIRTUAL_SIZE] = wid;
y -= PFUGUI_BUTTON_YINC;
/* Clip Size */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_CLIP_SIZE);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Size");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, clipSizeStrs, clipSizeVals, NULL,
(int)round(log2(FakeClipGuiState->virtual_size))+1);
pfuWidgetDefaultValue(wid, FakeClipGuiState->virtual_size/4); /* seems about right */
printf("SETTING CLIP SIZE WIDGET VAL TO %g\n", (double)FakeClipGuiState->virtual_size/4);
ViewState->guiWidgets[GUI_FAKECLIP_CLIP_SIZE] = wid;
y -= PFUGUI_BUTTON_YINC;
/* Clip Visualization */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_CLIP_VISUALIZATION);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Visualization");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, clipVisStrs, clipVisVals, NULL,
numberof(clipVisStrs));
pfuWidgetDefaultValue(wid, 0);
ViewState->guiWidgets[GUI_FAKECLIP_CLIP_VISUALIZATION] = wid;
y -= PFUGUI_BUTTON_YINC;
/* Mag filter */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_MAGFILTER);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Mag Filter");
pfuWidgetActionFunc(wid, controlPanel);
if (getenv("_PERFLY_ALL_FILTERS")) /* XXX */
pfuWidgetSelections(wid, allInterpStrs, allInterpVals, NULL, numberof(allInterpStrs));
else
pfuWidgetSelections(wid, magFilterStrs, magFilterVals, NULL, numberof(magFilterStrs));
pfuWidgetDefaultValue(wid, FakeClipGuiState->magfilter);
ViewState->guiWidgets[GUI_FAKECLIP_MAGFILTER] = wid;
y -= PFUGUI_BUTTON_YINC;
/* Min filter */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_FAKECLIP_MINFILTER);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Min Filter");
pfuWidgetActionFunc(wid, controlPanel);
if (getenv("_PERFLY_ALL_FILTERS")) /* XXX */
pfuWidgetSelections(wid, allInterpStrs, allInterpVals, NULL, numberof(allInterpStrs));
else
pfuWidgetSelections(wid, minFilterStrs, minFilterVals, NULL, numberof(minFilterStrs));
pfuWidgetDefaultValue(wid, FakeClipGuiState->minfilter);
ViewState->guiWidgets[GUI_FAKECLIP_MINFILTER] = wid;
x = xo;
#endif /* CUSTOM */
/*
* If the scene contains a clip texture,
* add some more widgets to control it
*/
if (ViewState->clip_texture != NULL)
{
int virtualSize;
pfGetClipTextureVirtualSize(ViewState->clip_texture,
&virtualSize, NULL, NULL);
/* separate the interesting widgets at the bottom */
y -= PFUGUI_BUTTON_YINC/2;
x = xo;
/* cliptex select menu */
ySize = PFUGUI_BUTTON_YSIZE;
y -= PFUGUI_BUTTON_YINC;
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_CLIPTEX_SELECT);
pfuWidgetLabel(wid,"ClipTex:");
pfuWidgetDim(wid, x, y, fullSize, ySize);
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, ViewState->clipTexStrs, NULL, NULL,
ViewState->numClipTextures);
pfuWidgetDefaultValue(wid,0);
ViewState->guiWidgets[GUI_CLIPTEX_SELECT] = wid;
ySize = PFUGUI_SLIDER_YSIZE;
if ((1<<(ViewState->clip_effective_levels-1)) < virtualSize)
{
/* Clip LOD Offset Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_CLIP_LOD_OFFSET);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Virtual LOD Offset");
pfuWidgetRange(wid, 1, 0, 20,
ViewState->clip_lod_offset);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_CLIP_LOD_OFFSET] = wid;
/* Effective Levels Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_CLIP_EFFECTIVE_LEVELS);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Effective Levels");
pfuWidgetRange(wid, 1,
1, 16, ViewState->clip_effective_levels);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_CLIP_EFFECTIVE_LEVELS] = wid;
}
/* Min LOD Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_MIP_MIN_LOD);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Min (Finest) Mip LOD");
pfuWidgetRange(wid, 1, 0.0f, ViewState->mip_max_lod, 0.0f);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_MIP_MIN_LOD] = wid;
/* Max LOD Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_MIP_MAX_LOD);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Max (Coarsest) Mip LOD");
pfuWidgetRange(wid, 1, 0.0f, ViewState->mip_max_lod, ViewState->mip_max_lod);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_MIP_MAX_LOD] = wid;
/* LOD Bias Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_MIP_LOD_BIAS);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Mipmap LOD Bias");
pfuWidgetRange(wid, 0, -10.0f, 10.0f,
ViewState->lod_biasS);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_MIP_LOD_BIAS] = wid;
/* LOD Bias S Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_MIP_LOD_BIAS_S);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Mipmap LOD Bias S");
pfuWidgetRange(wid, 0, -10.0f, 10.0f,
ViewState->lod_biasS);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_MIP_LOD_BIAS_S] = wid;
/* LOD Bias T Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_MIP_LOD_BIAS_T);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Mipmap LOD Bias T");
pfuWidgetRange(wid, 0, -10.0f, 10.0f,
ViewState->lod_biasT);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_MIP_LOD_BIAS_T] = wid;
/* Invalid Border Slider */
y -= PFUGUI_SLIDER_YINC;
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_CLIP_INVALID_BORDER);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_SLIDER_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Invalid Border");
pfuWidgetRange(wid, 0, 0.0f,
pfGetClipTextureClipSize(ViewState->clip_texture),
ViewState->clip_invalid_border);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_CLIP_INVALID_BORDER] = wid;
y -= PFUGUI_BUTTON_YINC;
#ifdef NOTYET
/* Clip Centering menu */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_CLIP_CENTERING);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
#ifdef NOTYET
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
#endif
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Center");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, clipCenteringStrs, NULL, NULL, numberof(clipCenteringStrs));
pfuWidgetDefaultValue(wid, 1);
ViewState->guiWidgets[GUI_CLIP_CENTERING] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
x = xo;
y -= PFUGUI_BUTTON_YINC;
/* Clip Visualization */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_CLIP_VISUALIZATION);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Clip Visualization");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, clipVisStrs, clipVisVals, NULL,
numberof(clipVisStrs));
pfuWidgetDefaultValue(wid, 0);
ViewState->guiWidgets[GUI_CLIP_VISUALIZATION] = wid;
y -= PFUGUI_BUTTON_YINC;
#endif
/* Mag filter */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_MIP_MAGFILTER);
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Mag Filter");
pfuWidgetActionFunc(wid, controlPanel);
if (getenv("_PERFLY_ALL_FILTERS")) /* XXX */
pfuWidgetSelections(wid, allInterpStrs, allInterpVals, NULL, numberof(allInterpStrs));
else
pfuWidgetSelections(wid, interpStrs, interpVals, NULL, numberof(interpStrs));
pfuWidgetDefaultValue(wid, ViewState->mip_magfilter);
ViewState->guiWidgets[GUI_MIP_MAGFILTER] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
#ifdef NOTYET /* XXX if this gets put back, it will require rearranging */
/* Min filter */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_MIP_MINFILTER);
xSize = PFUGUI_BUTTON_VLONG_XSIZE;
ySize = PFUGUI_BUTTON_YSIZE;
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Min Filter");
pfuWidgetActionFunc(wid, controlPanel);
if (getenv("_PERFLY_ALL_FILTERS")) /* XXX */
pfuWidgetSelections(wid, allInterpStrs, allInterpVals, NULL, numberof(allInterpStrs));
else
pfuWidgetSelections(wid, interpStrs, interpVals, NULL, numberof(interpStrs));
pfuWidgetDefaultValue(wid, ViewState->mip_minfilter);
ViewState->guiWidgets[GUI_MIP_MINFILTER] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
#endif /* NOTYET */
x = xo;
y -= PFUGUI_BUTTON_YINC;
xSize = fullSize;
ySize = PFUGUI_BUTTON_YSIZE;
/* DTR mode */
wid = pfuNewWidget(panel, PFUGUI_MENU_BUTTON, GUI_CLIP_DTRMODE);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "DTR Mode");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetSelections(wid, DTRmodeStrs, DTRmodeVals, NULL,
numberof(DTRmodeVals));
pfuWidgetDefaultValue(wid, ViewState->clip_dtrmode);
ViewState->guiWidgets[GUI_CLIP_DTRMODE] = wid;
ySize = PFUGUI_SLIDER_YSIZE;
y -= PFUGUI_SLIDER_YINC;
/* DTR Time slider */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_CLIP_DTR_TIME);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetRange(wid, PFUGUI_SLIDER, 0., 1000.0f/ViewState->frameRate,
ViewState->clip_dtr_time);
pfuWidgetLabel(wid, "DTR Time");
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_CLIP_DTR_TIME] = wid;
x += PFUGUI_BUTTON_VLONG_XINC;
x = xo;
y -= PFUGUI_BUTTON_YINC;
}
/* if the calligraphic option is set */
if (ViewState->startCallig)
{
ySize = PFUGUI_SLIDER_YSIZE;
xSize = PFUGUI_BUTTON_VLONG_XSIZE + PFUGUI_BUTTON_VLONG_XINC;
x = xo;
/* raster defocus */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_RASTER_DEFOCUS);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Raster Focus");
pfuWidgetRange(wid, PFUGUI_SLIDER,0., 1., ViewState->rasterDefocus);
pfuWidgetActionFunc(wid, controlPanel);
ViewState->guiWidgets[GUI_RASTER_DEFOCUS] = wid;
y -= PFUGUI_SLIDER_YINC;
/* callig defocus */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_CALLIGRAPHIC_DEFOCUS);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Calligraphic Focus");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetRange(wid, PFUGUI_SLIDER,0., 1., ViewState->rasterDefocus);
ViewState->guiWidgets[GUI_CALLIGRAPHIC_DEFOCUS] = wid;
y -= PFUGUI_SLIDER_YINC;
/* filter Size */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_FILTER_SIZEX);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Filter SizeX");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetRange(wid, PFUGUI_SLIDER,1. , 2048., ViewState->calligFilterSizeX);
ViewState->guiWidgets[GUI_FILTER_SIZEX] = wid;
y -= PFUGUI_SLIDER_YINC;
/* same on Y */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_FILTER_SIZEY);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Filter SizeY");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetRange(wid, PFUGUI_SLIDER,1. , 2048., ViewState->calligFilterSizeY);
ViewState->guiWidgets[GUI_FILTER_SIZEY] = wid;
y -= PFUGUI_SLIDER_YINC;
/* z foot print */
wid = pfuNewWidget(panel, PFUGUI_SLIDER, GUI_ZFOOT_PRINT);
pfuWidgetDim(wid, x, y, xSize, ySize);
pfuWidgetLabel(wid, "Z foot print");
pfuWidgetActionFunc(wid, controlPanel);
pfuWidgetRange(wid, PFUGUI_SLIDER, 0.5 , 10., ViewState->calligZFootPrint);
ViewState->guiWidgets[GUI_ZFOOT_PRINT] = wid;
y -= PFUGUI_SLIDER_YINC;
if (ViewState->calligBoard)
{
pfuEnableWidget(ViewState->guiWidgets[GUI_CALLIGRAPHIC_DEFOCUS]);
pfuEnableWidget(ViewState->guiWidgets[GUI_RASTER_DEFOCUS]);
pfuEnableWidget(ViewState->guiWidgets[GUI_FILTER_SIZEX]);
pfuEnableWidget(ViewState->guiWidgets[GUI_FILTER_SIZEY]);
pfuEnableWidget(ViewState->guiWidgets[GUI_ZFOOT_PRINT]);
}
else
{
pfuDisableWidget(ViewState->guiWidgets[GUI_CALLIGRAPHIC_DEFOCUS]);
pfuDisableWidget(ViewState->guiWidgets[GUI_RASTER_DEFOCUS]);
pfuDisableWidget(ViewState->guiWidgets[GUI_FILTER_SIZEX]);
pfuDisableWidget(ViewState->guiWidgets[GUI_FILTER_SIZEY]);
pfuDisableWidget(ViewState->guiWidgets[GUI_ZFOOT_PRINT]);
}
}
/* Reset GUI so that it will come up with the specified default values */
pfuResetGUI();
#if 1 /* CUSTOM */
setGuiExageration(FakeClipGuiState->exaggeration);
#endif /* CUSTOM */
return(panel);
}
#if 1 /* CUSTOM */
extern void
setGuiExageration(int exag)
{
int i;
FakeClipGuiState->exaggeration = exag;
for (i = 0; i < numberof(virtualSizeStrs); ++i) {
sprintf(virtualSizeStrs[i], "%dx%d",
(int)FakeClipGuiState->exaggeration * (1<<i),
(int)FakeClipGuiState->exaggeration * (1<<i));
sprintf(clipSizeStrs[i], "%dx%d",
(int)FakeClipGuiState->exaggeration * (1<<i),
(int)FakeClipGuiState->exaggeration * (1<<i));
}
#ifdef NOTYET
pfuWidgetSelections(ViewState->guiWidgets[GUI_FAKECLIP_VIRTUAL_SIZE], virtualSizeStrs, virtualSizeVals, NULL,
(int)round(log2(FakeClipGuiState->virtual_size))+1);
#endif
pfuWidgetSelections(ViewState->guiWidgets[GUI_FAKECLIP_CLIP_SIZE],
clipSizeStrs, clipSizeVals, NULL,
(int)round(log2(FakeClipGuiState->virtual_size))+1);
}
#endif /* CUSTOM */
![[BACK]](/icons/back.gif){kind=icon}
Return to gui.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / performer / src / sample / C / fakeclipfly