//-*****************************************************************************
void init( void )
{
{
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
GLfloat mat_front_emission[] = {0.0, 0.0, 0.0, 0.0 };
GLfloat mat_back_emission[] = {1.0f, 0.0, 0.0, 1.0f };
glClearColor( 0.0, 0.0, 0.0, 0.0 );
glMaterialfv( GL_FRONT, GL_EMISSION, mat_front_emission );
glMaterialfv( GL_FRONT, GL_SPECULAR, mat_specular );
glMaterialfv( GL_FRONT, GL_SHININESS, mat_shininess );
glMaterialfv( GL_BACK, GL_EMISSION, mat_back_emission );
glMaterialfv( GL_BACK, GL_SPECULAR, mat_specular );
glMaterialfv( GL_BACK, GL_SHININESS, mat_shininess );
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
}
glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glDisable(GL_CULL_FACE);
glShadeModel( GL_SMOOTH );
g_state.scene.cam.setSize( 800, 600 );
g_state.scene.cam.lookAt( V3d( 24, 18, 24 ), V3d( 0.0 ) );
g_state.bMask = 0;
g_state.showHelp = false;
g_state.playback = kStopped;
g_state.scene.pointSize = 3.0f;
glPointSize( 3.0f );
init_surface();
setMaterials( 1.0, false );
g_state.scene.cam.frame( g_transport->getBounds() );
std::ostringstream titleStream;
titleStream << "Archive = "
<< g_transport->getFileName()
<< " | Frame = "
<< g_transport->getCurrentFrame();
glutSetWindowTitle( titleStream.str().c_str() );
}
static void fuzz_drawLine(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkScalar a, b, c, d;
fuzz->next(&a, &b, &c, &d);
surface->getCanvas()->drawLine(a, b, c, d, p);
}
ExampleSimpleNURBS() : showPoints(1)
{
gl_modes.push_back(GL_LIGHTING);
gl_modes.push_back(GL_LIGHT0);
gl_modes.push_back(GL_AUTO_NORMAL);
gl_modes.push_back(GL_NORMALIZE);
Orientation[0] = 90.0;
init_surface();
}
static void fuzz_drawBitmap(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkBitmap bmp;
init_bitmap(fuzz, &bmp);
SkScalar a, b;
fuzz->next(&a, &b);
surface->getCanvas()->drawBitmap(bmp, a, b, &p);
}
static void fuzz_drawText(Fuzz* fuzz, sk_sp<SkTypeface> font) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
char text[kTxtLen];
init_string(fuzz, text, kTxtLen);
SkScalar x, y;
fuzz->next(&x, &y);
// populate pts array
SkPoint pts[kPtsLen];
for (uint8_t i = 0; i < kPtsLen; ++i) {
pts[i].set(x, y);
x += p.getTextSize();
}
p.setTypeface(font);
// set text related attributes
bool b;
fuzz->next(&b);
p.setAutohinted(b);
fuzz->next(&b);
p.setDevKernText(b);
fuzz->next(&b);
p.setEmbeddedBitmapText(b);
fuzz->next(&b);
p.setFakeBoldText(b);
fuzz->next(&b);
p.setLCDRenderText(b);
fuzz->next(&b);
p.setLinearText(b);
fuzz->next(&b);
p.setSubpixelText(b);
fuzz->next(&x);
p.setTextScaleX(x);
fuzz->next(&x);
p.setTextSkewX(x);
fuzz->next(&x);
p.setTextSize(x);
fuzz->next(&b);
p.setVerticalText(b);
SkCanvas* cnv = surface->getCanvas();
cnv->drawPosText(text, (kTxtLen-1), pts, p);
fuzz->next(&x);
fuzz->next(&y);
cnv->drawText(text, (kTxtLen-1), x, y, p);
}
static void fuzz_drawPath(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
// TODO(kjlubick): put the ability to fuzz a path in shared file, with
// other common things (e.g. rects, lines)
uint8_t i, j;
fuzz->nextRange(&i, 0, 10); // set i to number of operations to perform
SkPath path;
SkScalar a, b, c, d, e, f;
for (int k = 0; k < i; ++k) {
fuzz->nextRange(&j, 0, 5); // set j to choose operation to perform
switch (j) {
case 0:
fuzz->next(&a, &b);
path.moveTo(a, b);
break;
case 1:
fuzz->next(&a, &b);
path.lineTo(a, b);
break;
case 2:
fuzz->next(&a, &b, &c, &d);
path.quadTo(a, b, c, d);
break;
case 3:
fuzz->next(&a, &b, &c, &d, &e);
path.conicTo(a, b, c, d, e);
break;
case 4:
fuzz->next(&a, &b, &c, &d, &e, &f);
path.cubicTo(a, b, c, d, e, f);
break;
case 5:
fuzz->next(&a, &b, &c, &d, &e);
path.arcTo(a, b, c, d, e);
break;
}
}
path.close();
SkCanvas* cnv = surface->getCanvas();
cnv->drawPath(path, p);
bool bl;
fuzz->next(&bl);
cnv->clipPath(path, kIntersect_SkClipOp, bl);
}
static void fuzz_drawText(Fuzz* fuzz, sk_sp<SkTypeface> typeface) {
SkFont font(typeface);
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
char text[kTxtLen];
init_string(fuzz, text, kTxtLen);
SkScalar x, y;
fuzz->next(&x, &y);
// populate pts array
SkPoint pts[kPtsLen];
for (uint8_t i = 0; i < kPtsLen; ++i) {
pts[i].set(x, y);
x += font.getSize();
}
bool b;
fuzz->next(&b);
font.setForceAutoHinting(b);
fuzz->next(&b);
font.setEmbeddedBitmaps(b);
fuzz->next(&b);
font.setEmbolden(b);
fuzz->next(&b);
font.setEdging(b ? SkFont::Edging::kAntiAlias : SkFont::Edging::kSubpixelAntiAlias);
fuzz->next(&b);
font.setLinearMetrics(b);
fuzz->next(&b);
font.setSubpixel(b);
fuzz->next(&x);
font.setScaleX(x);
fuzz->next(&x);
font.setSkewX(x);
fuzz->next(&x);
font.setSize(x);
SkCanvas* cnv = surface->getCanvas();
fuzz->next(&x);
fuzz->next(&y);
cnv->drawTextBlob(SkTextBlob::MakeFromPosText(text, kTxtLen-1, pts, font), x, y, p);
}
void init(void)
{
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glClearColor(0.0, 0.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
init_surface();
theNurb = gluNewNurbsRenderer();
gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
gluNurbsCallback(theNurb, GLU_ERROR, nurbsError);
}
static void fuzz_drawRect(Fuzz* fuzz) {
SkPaint p;
init_paint(fuzz, &p);
sk_sp<SkSurface> surface;
init_surface(fuzz, &surface);
SkScalar a, b, c, d;
fuzz->next(&a, &b, &c, &d);
SkRect r;
r = SkRect::MakeXYWH(a, b, c, d);
SkCanvas* cnv = surface->getCanvas();
cnv->drawRect(r, p);
bool bl;
fuzz->next(&bl);
fuzz->next(&a, &b, &c, &d);
r = SkRect::MakeXYWH(a, b, c, d);
cnv->clipRect(r, kIntersect_SkClipOp, bl);
}
ACSurface *read_surface(FILE *f, ACSurface *s, ACObject *ob)
{
char t[20];
init_surface(s);
while (!feof(f))
{
read_line(f);
sscanf(buff, "%s", t);
if (streq(t, "SURF"))
{
int flgs;
if (get_tokens(buff, &tokc, tokv) != 2)
{
printf("SURF should be followed by one flags argument\n");
}
else
{
flgs = strtol(tokv[1], NULL, 0);
s->flags = flgs;
}
}
else
if (streq(t, "mat"))
{
int mindx;
sscanf(buff, "%s %d", t, &mindx);
s->mat = mindx+startmatindex;
}
else
if (streq(t, "refs"))
{
int num, n;
int ind;
float tx, ty;
sscanf(buff, "%s %d", t, &num);
s->num_vertref = num;
s->vertref = (int *)malloc( num * sizeof(int));
s->uvs = (ACUV *)malloc( num * sizeof(ACUV));
for (n = 0; n < num; n++)
{
fscanf(f, "%d %f %f\n", &ind, &tx, &ty); line++;
s->vertref[n] = ind;
s->uvs[n].u = tx;
s->uvs[n].v = ty;
}
/** calc surface normal **/
if (s->num_vertref >= 3)
tri_calc_normal((ACPoint *)&ob->vertices[s->vertref[0]],
(ACPoint *)&ob->vertices[s->vertref[1]],
(ACPoint *)&ob->vertices[s->vertref[2]], (ACPoint *)&s->normal);
return(s);
}
else
printf("ignoring %s\n", t);
}
return(NULL);
}
