Logo Search packages:      
Sourcecode: bb version File versions  Download package

scene7.c

/* This file was taken from XaoS-the fast portable realtime interactive 
   fractal zoomer. but it is simplified for BB. You may get complette
   sources at XaoS homepage (http://www.paru.cas.cz/~hubicka/XaoS
 */
/* 
 *     XaoS, a fast portable realtime fractal zoomer 
 *                  Copyright (C) 1996 by
 *
 *      Jan Hubicka          (hubicka@paru.cas.cz)
 *      Thomas Marsh         (tmarsh@austin.ibm.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#ifdef _plan9_
#include <u.h>
#include <stdio.h>
#include <libc.h>
#else
#ifdef __DJGPP__
#include "aconfig.dos"
#else
#include "aconfig.h"
#endif
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <signal.h>
#endif
#include "config.h"
#ifndef _plan9_
#include <assert.h>
#endif
#include "bb.h"
#include "zoom.h"
#include "autopilo.h"
#include "complex.h"
#include "ui.h"
#include "timers.h"
#define ETIME1 (25*1000000+150000)
#define ETIME2 (2*1000000)


#define VBUFF (zcontext->stereogram?zcontext->svbuff:zcontext->vbuff)
#define BACK (zcontext->stereogram?zcontext->sback:zcontext->back)
#define SIZE 1024
#define add_buffer(char) if(((end+1)%SIZE)!=begin) {keybuffer[end]=char;end=(end+1)%SIZE;}
#define INTERRUPTIBLE 0
#define ANIMATION 1
#define NEW_IMAGE 2
#define UNINTERRUPTIBLE 3
#define xstoc(x)        (((number_t) (zcontext->s.nc + (x) * ((zcontext->s.mc - zcontext->s.nc) \
                                / (number_t) zcontext->width))))
#define ystoc(y)        (((number_t) (zcontext->s.ni + (y) * ((zcontext->s.mi - zcontext->s.ni) \
                                / (number_t) zcontext->height))))

#define FRAMETIME (1000000/FRAMERATE)

#define FORMULA 0
#define HELP 1
#define DRIVER 2
#define MENU 3


static tl_timer *maintimer /*, *rotatetimer */ ;
static void ui_do_fractal(int);
static int displayed;
static int ui_autopilot(void);
static int incalculation;
static int fastmode = 2;
static int interruptiblemode;
static int autopilot = 0;
static double maxstep = MAXSTEP, speedup = STEP;
static zoom_context *zcontext;
static double mul;
static int drawingtime, tbreak = 0;

static void ui_display(void)
{
    displayed = 1;
    aa_render(context, params, 0, 0, aa_imgwidth(context), aa_imgheight(context));
    aa_flush(context);

#if 0
    if (numbertype != FORMULA)
      rotate_continue();
#endif
}

static int waitcount;
static int waitcount1;
static int starttime1;
static int endtime1;
static int maxtime = 1000000 / 10;
#define WAITTIME  200000
#define WAITTIME1 2000000
static void ui_waitfunc(void)
{
    int l;
    bbupdate();
    tl_process_group(syncgroup, NULL);
    l = tl_lookup_timer(maintimer);
    if (interruptiblemode) {
      if (zcontext->incalculation && !starttime1)
          starttime1 = l;
      else if (starttime1 && !zcontext->incalculation && !endtime1)
          endtime1 = l;
      if (maxtime && l > maxtime && zcontext->readyforinterrupt)
          zcontext->interrupt = 1, endtime1 = l;
    }
}
static float get_pixelwidth(int width)
{
    return (aa_mmwidth(context));
}
static float get_pixelheight(int height)
{
    return (aa_mmheight(context));
}
#ifdef _RED_
static void rotate_off(void)
{
    if (rotate) {
      tl_free_timer(rotatetimer);
      rotate = 0;
    }
}
static void rotate_stop(void)
{
    if (rotate && !stopped) {
      tl_remove_timer(rotatetimer);
      stopped = 1;
    }
}
static void rotate_continue(void)
{
    if (rotate && stopped) {
      stopped = 0;
      if (driver->flags & ASYNC_PALETTE) {
          tl_add_timer(asyncgroup, rotatetimer);
      }
      else
          tl_add_timer(syncgroup, rotatetimer);
    }
}
static void rotatehandler(int n)
{
    int direct;
    direct = direction * n;
    if (direction > 0)
      direction %= zcontext->num_colors - 1;
    else
      direction = -((-direction) % (zcontext->num_colors - 1));
    if (!direction)
      return;
    rotated = 1;
    rotate_palette(zcontext, direction * n);
    driver->rotate_palette(direction * n);
    if (ministatus && (driver->flags & PALETTE_REDISPLAYS)) {
      driver->print(0, 0, statustext);
    }
}
static void rotate_update(void)
{
    if (rotationspeed < 0)
      direction = -1;
    else
      direction = 1;
    tl_set_interval(rotatetimer, 1000000 / rotationspeed * direction);
}
static void rotate_on(void)
{
    if (driver->rotate_palette != NULL && (driver->flags & PALETTE_ROTATION)) {
      rotate = 1;
      rotatetimer = tl_create_timer();
      rotate_update();
      tl_set_multihandler(rotatetimer, rotatehandler);
      if (driver->flags & ASYNC_PALETTE) {
          tl_add_timer(asyncgroup, rotatetimer);
      }
      else
          tl_add_timer(syncgroup, rotatetimer);
    }
    else {
      driver->print(0, 0, "Rotating of palette not supported by this configuration");
    }
}
#endif
static char zoomed[256];
static void updatestatus(void)
{
    double times = (zcontext->currentformula->v.mc - zcontext->currentformula->v.nc) / (zcontext->s.mc - zcontext->s.nc);
    ui_display();
    sprintf(zoomed, "%.2f", times);

    tl_process_group(syncgroup, NULL);
    bbupdate();
    drawingtime = tl_lookup_timer(maintimer);
    tl_reset_timer(maintimer);
    if (drawingtime > 200000)
      drawingtime = 200000;
    mul = (double) drawingtime / FRAMETIME;
    incalculation = 0;
}
static void ui_do_julia(double xx, double yy)
{
    int oldw = zcontext->width, oldh = zcontext->height;
    float size;

    unsigned char *vold = zcontext->vbuff;
    incalculation = 1;
    zcontext->pre = xx, zcontext->pim = yy;
    if (zcontext->windowwidth > zcontext->windowheight)
      size = zcontext->windowheight;
    else
      size = zcontext->windowwidth;
    zcontext->width = zcontext->width * size / zcontext->windowwidth - 1;
    zcontext->height = zcontext->height * size / zcontext->windowheight - 1;
    if (!dual)
      zcontext->vbuff += (oldw - zcontext->width) / 2;
    else
      zcontext->vbuff += (oldw / 2 - zcontext->width) / 2;
    do_julia(zcontext,
           zcontext->pre,
           zcontext->pim);
    if (dual) {
      zcontext->currentformula = formulas + 1;
      zcontext->vbuff += aa_imgwidth(context) / 2;
      do_julia(zcontext,
             zcontext->pre,
             zcontext->pim);
      zcontext->currentformula = formulas;
    }
    zcontext->width = oldw;
    zcontext->height = oldh;
    zcontext->vbuff = vold;
    ui_display();
}
static void ui_do_fractal(int mode)
{
    int time, time1;
    if (mode < fastmode + 1)
      interruptiblemode = 1;
    else
      interruptiblemode = 0;
    if (tbreak)
      tl_reset_timer(maintimer);
    incalculation = 1;
    starttime1 = 0;
    endtime1 = 0;
    set_view(zcontext, &zcontext->s);
    waitcount = tl_lookup_timer(maintimer) / WAITTIME + 2;
    waitcount1 = tl_lookup_timer(maintimer) / WAITTIME1 + 1;
    do_fractal(zcontext, interruptiblemode);
    bbupdate();
    if (interruptiblemode) {
      bbupdate();
      time1 = time = tl_lookup_timer(maintimer);
      time -= endtime1 - starttime1;
      maxtime = time * 5;
      if (maxtime > 1000000 / 10)
          maxtime = time * 3;
      if (maxtime < 1000000 / 30)
          maxtime = 1000000 / 30;
      maxtime -= time1 - endtime1;
    }
    updatestatus();
}
static double step = 0;

void ui_tbreak(void)
{
    tbreak = 2;
}


static int ui_autopilot(void)
{
    clean_autopilot();
    return (autopilot ^= 1);
}
static void ui_changed(void)
{
    ui_tbreak();
}

static int ui_mouse()
{
    int mousex = 0;
    int mousey = 0;
    int mousebuttons = 0;
    int inmovement = 0, slowdown = 1;
    static double autopilot_counter = 0;
    static number_t oldx = 0, oldy = 0;
    static int dirty = 0;
    static int pressed;


    if (tbreak)
      mul = 1.0;
    if (dirty)
      ui_do_fractal(NEW_IMAGE), ui_tbreak(), dirty = 0;
    if (autopilot) {
      static int mousex1, mousey1, mousebuttons1;
      autopilot_counter += mul;
      while (autopilot_counter > 1) {
          do_autopilot(zcontext, &mousex1, &mousey1, &mousebuttons1, ui_changed);
          autopilot_counter--;
      }
      mousex = mousex1, mousey = mousey1, mousebuttons = mousebuttons1;
    }
    if (tbreak)
      mul = 1;
    if (mul == 0)
      mul = 0.001;
    if (mousebuttons > 0) {
      switch (mousebuttons) {
      case BUTTON1:           /* button 1 */
          step -= speedup * 2 * mul, slowdown = 0;
          inmovement = 1;
          break;
      case BUTTON3:           /* button 3 */
          step += speedup * 2 * mul, slowdown = 0;
          inmovement = 1;
          break;
      case BUTTON2:           /* button 2 */
          {
            number_t x = xstoc(mousex), y = ystoc(mousey);
            if (pressed && (oldx != x || oldy != y)) {
                zcontext->s.nc -= x - oldx;
                zcontext->s.mc -= x - oldx;
                zcontext->s.ni -= y - oldy;
                zcontext->s.mi -= y - oldy;
                if (!step) {
                  ui_do_fractal(ANIMATION), ui_tbreak();
                }
            }
            pressed = 1;
            oldx = xstoc(mousex), oldy = ystoc(mousey);
          }
          break;
      default:
          break;
      }
    }
    if (!(mousebuttons & BUTTON2))
      pressed = 0;
    if (slowdown) {
      if (step > 0) {
          if (step < speedup * mul)
            step = 0;
          else
            step -= speedup * mul;
      }
      else if (step < 0) {
          if (step > -speedup * mul)
            step = 0;
          else
            step += speedup * mul;
      }
    }
    if (step > maxstep)
      step = maxstep;
    else if (step < -maxstep)
      step = -maxstep;
    if (step) {
      number_t x = xstoc(mousex);
      number_t y = ystoc(mousey);
      number_t mmul = pow((double) (1 + step), (double) mul);
      zcontext->s.mc = x + (zcontext->s.mc - x) * (mmul);
      zcontext->s.nc = x + (zcontext->s.nc - x) * (mmul);
      zcontext->s.mi = y + (zcontext->s.mi - y) * (mmul);
      zcontext->s.ni = y + (zcontext->s.ni - y) * (mmul);
      inmovement = 1;
      ui_do_fractal(ANIMATION);
      if (tbreak)
          tbreak--;
    }
    if (!inmovement)
      ui_tbreak();
    return (1);
}
#define BTIME 200000
#define BTIME1 1000000
static void main_loop(void)
{
    int inmovement = 1;
    while (TIME < endtime && !finish_stuff) {
      if (TIME < starttime + BTIME) {
          params->bright = 255 - (TIME - starttime) * 255 / BTIME;
      }
      else
          params->bright = 0;
      if (TIME > endtime - BTIME1) {
          params->bright = -255 + (endtime - TIME) * 255 / BTIME1;
      }
      if (zcontext->uncomplette) {
          inmovement = 1;
          if (!displayed)
            ui_do_fractal(ANIMATION);
      }
      displayed = 0;
      inmovement = ui_mouse();
    }
}
static void flip_buffers(void)
{
    context->imagebuffer = zcontext->back;
}
static int sef, eef;
static double is, ie, rs, re;
static void juliov(void)
{
    double time = (TIME - starttime) / (double) (endtime - starttime);
    if (sef) {
      if (TIME < starttime + BTIME) {
          params->bright = 255 - (TIME - starttime) * 255 / BTIME;
      }
      else
          params->bright = 0;
    }
    if (eef) {
      if (TIME > endtime - BTIME) {
          params->bright = -255 + (endtime - TIME) * 255 / BTIME;
      }
    }
    ui_do_julia(rs + (re - rs) * time, is + (ie - is) * time);
}
static void mydraw()
{
    clrscr();
    dvojprujezd(starttime, zoomed, "Times");
}
static void mydraw1()
{
    clrscr();
    drawlepic("Zoomed");
}


void scene6(void)
{
    int width, height, scanline;
    int i, formula = 0;
    char *buffer1, *buffer2;
    displayed = 0;
    incalculation = 0;
    fastmode = 2;
    interruptiblemode = 0;
    autopilot = 0;
    maxstep = MAXSTEP;
    speedup = STEP;
    step = 0;
    tbreak = 0;
    maintimer = tl_create_timer();
    signal(SIGFPE, SIG_IGN);
    width = aa_imgwidth(context);
    height = aa_imgheight(context);
    scanline = width;
    buffer1 = context->imagebuffer;
    buffer2 = malloc(width * height);
    endtime = starttime + ETIME1;
    params->bright = -255;

    zcontext = make_context(width, height, scanline, 0, 1, flip_buffers, ui_waitfunc, buffer1, buffer2, get_pixelwidth(width), get_pixelheight(height));
    if (!zcontext) {
      exit(-1);
    }
    set_formula(zcontext, formula);
    for (i = 0; i < 255; i++) {
      /*zcontext->colors[i] = (i * 15) % 255 + 1; */
      zcontext->colors[i] = (i * 8) % 255 + 1;
    }
    zcontext->colors[0] = 0;
    zcontext->num_colors = 255;
    tbreak = 2;
    zcontext->maxiter = 150;
    fastmode--;
    zcontext->range = 8;
    zcontext->incoloringmode = 0;
    zcontext->coloringmode = 0;
    zcontext->plane = 0;
    ui_do_fractal(NEW_IMAGE);
    ui_autopilot();
    speedup = 1 * STEP;
    maxstep *= 5;
    step = -maxstep;
    tl_process_group(syncgroup, NULL);
    bbupdate();
    tl_reset_timer(maintimer);
    main_loop();
    starttime = endtime;
    context->imagebuffer = buffer1;
    free(buffer2);
    tl_free_timer(maintimer);
    params->bright = 0;
    params->randomval = 0;
    initlepic();
    drawptr = mydraw1;
    timestuff(-60, ctrllepic, draw, 2000000);
    drawptr = mydraw;
    /*timestuff(60, NULL, draw, 4 * 1000000); */
    /*timestuff(20, blur, draw, 4 * 1000000); */
    timestuff(60, NULL, draw, 3 * 1000000);

}
void scene7(void)
{
    int width, height, scanline;
    int i, formula = 0;
    char *buffer1;
    signal(SIGFPE, SIG_IGN);
    width = aa_imgwidth(context);
    height = aa_imgheight(context);
    scanline = width;
    buffer1 = context->imagebuffer;
    params->bright = -255;
    params->dither = AA_NONE;

    zcontext = make_context(width, height, scanline, 0, 1, flip_buffers, ui_waitfunc, buffer1, buffer1, get_pixelwidth(width), get_pixelheight(height));
    if (!zcontext) {
      exit(-1);
    }
    set_formula(zcontext, formula);
    for (i = 0; i < 255; i++) {
      zcontext->colors[i] = (i * 15) % 255 + 1;
    }
    zcontext->colors[0] = 0;
    zcontext->num_colors = 255;
    tbreak = 2;
    zcontext->maxiter = 255;
    fastmode--;
    zcontext->range = 8;
    zcontext->incoloringmode = 0;
    zcontext->coloringmode = 0;
    zcontext->plane = 0;
    starttime = endtime;
    sef = 1;
    eef = 0;
    is = -2;
    rs = -2;
    ie = 2;
    re = 2;
    timestuff(0, NULL, juliov, ETIME2);
    sef = 0;
    eef = 0;
    is = 2;
    rs = 2;
    ie = 0;
    re = -2;
    timestuff(0, NULL, juliov, ETIME2);
    sef = 0;
    eef = 0;
    is = 0;
    rs = -2;
    ie = 0;
    re = 2;
    timestuff(0, NULL, juliov, ETIME2);
    sef = 0;
    eef = 1;
    is = 0;
    rs = 2;
    ie = -1;
    re = -5.0;
    timestuff(0, NULL, juliov, ETIME2);
    context->imagebuffer = buffer1;
    params->bright = 0;
    params->dither = AA_FLOYD_S;
}
#if 0
void scene9(void)
{
    int width, height, scanline;
    int i, formula = 1;
    char *buffer1;
    signal(SIGFPE, SIG_IGN);
    width = aa_imgwidth(context);
    height = aa_imgheight(context);
    scanline = width;
    buffer1 = context->imagebuffer;
    params->bright = -255;
    params->dither = AA_NONE;

    zcontext = make_context(width, height, scanline, 0, 1, flip_buffers, ui_waitfunc, buffer1, buffer1, get_pixelwidth(width), get_pixelheight(height));
    if (!zcontext) {
      exit(-1);
    }
    set_formula(zcontext, formula);
    for (i = 0; i < 255; i++) {
      zcontext->colors[i] = (i * 15) % 255 + 1;
    }
    zcontext->colors[0] = 0;
    zcontext->num_colors = 255;
    tbreak = 2;
    zcontext->maxiter = 255;
    fastmode--;
    zcontext->range = 8;
    zcontext->incoloringmode = 0;
    zcontext->coloringmode = 0;
    zcontext->plane = 0;
    starttime = endtime;
    sef = 1;
    eef = 0;
    is = -1;
    rs = -1;
    ie = 2;
    re = -2;
    timestuff(0, NULL, juliov, ETIME2);
    sef = 0;
    eef = 0;
    is = ie, rs = re;
    ie = 2;
    re = 2;
    timestuff(0, NULL, juliov, ETIME2);
    sef = 0;
    eef = 0;
    is = ie, rs = re;
    ie = -2;
    re = 2;
    timestuff(0, NULL, juliov, ETIME2);
    sef = 0;
    eef = 1;
    is = ie, rs = re;
    ie = 2;
    re = -2;
    timestuff(0, NULL, juliov, ETIME2);
    context->imagebuffer = buffer1;
    params->bright = 0;
    params->dither = AA_FLOYD_S;
}
#endif

Generated by  Doxygen 1.6.0   Back to index