ATTRACTEURS DE FAMILLES DE CONTRACTIONS EN ÉCRAN DE VEILLE

#define USE_COS_TABLE
#define USE_TEXTURE
#define USE_MULTIPLE_TEXTURES
//#define SCREENSAVER

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include "glut_import.h"
#include "menu.h"

/*********************************************************************
 * CONSTANTS                                                         *
 *********************************************************************/

#define FPS_COUNTER_TRIGGER 15
#define FPS_COUNTER_SMOOTH 0.3

#define PROXY_SIZE 32
#define PROXY_QUALITY 5

#define MIN_COLOR (10./256.)
#define MIN_POINT_COUNT 300

#define INI_FILENAME "AFC.ini"

#ifdef USE_MULTIPLE_TEXTURES
#  ifndef USE_TEXTURE
#    error You cannot specify USE_MULTIPLE_TEXTURES without specifying USE_TEXTURE
#  endif
#  define INVALID_TEXTURE_INDEX 0xFFFFFFFF
#endif

/*********************************************************************
 * PLATFORM                                                          *
 *********************************************************************/

#ifdef __WIN32__
#  ifdef SCREENSAVER
#    define SCREENSAVER_MODE_SHOW 0x1
#    define SCREENSAVER_MODE_CONFIGURE 0x2
#    define SCREENSAVER_MODE_PREVIEW 0x4
#    define MAX_SCREENSAVER_MOUSE_OFFSET 10
#  endif
#  include <windows.h>
#  define SLEEP(_DELAY) Sleep(_DELAY)
#  define TIME_GRANULARITY 12
#else
#  ifdef SCREENSAVER
#    error Usage of SCREENSAVER reserved for Windows
#  endif
#  include <unistd.h>
#  define SLEEP(_DELAY) usleep(1000*_DELAY)
#  define TIME_GRANULARITY 6
#endif

/*********************************************************************
 * COSINE TABLE SUPPORT                                              *
 *********************************************************************/

#ifdef USE_COS_TABLE
#  define COS_TABLE_QUALITY 0x1000
  float CosTable[COS_TABLE_QUALITY];
  void initCos(void){
    int i;
    for (i=0;i<COS_TABLE_QUALITY;i++)
      CosTable[i]=cos(PI*i/COS_TABLE_QUALITY);
  }
  float cosTable(float x){
    int n;
    if (x<0)
      x=-x;
    n=((int) roundf(COS_TABLE_QUALITY*x/PI)) % (2*COS_TABLE_QUALITY);
    if (n<COS_TABLE_QUALITY)
      return CosTable[n];
    else
      return CosTable[2*COS_TABLE_QUALITY-1-n];
  }
#  define COS(_X) cosTable((_X))
#  define SIN(_X) cosTable((_X)-0.5*PI)
#else
#  define COS(_X) cos((_X))
#  define SIN(_X) sin((_X))
#endif

/*********************************************************************
 * MACROS                                                            *
 *********************************************************************/

#define ASSERT(_X,_S) if (!(_X)) {printf("%s\n",_S);exit(-1);}
#define MEMCHECK(_X) if (!(_X)) {printf("Memory allocation failed\n");exit(-1);}

/*********************************************************************
 * TYPES                                                             *
 *********************************************************************/

typedef struct{
  int Count,Degree;
  float *Matrix;
} transformation;

#ifdef USE_TEXTURE
typedef struct{
#  ifdef USE_MULTIPLE_TEXTURES
  unsigned int Index;
#  endif
  int ImageWidth,ImageHeight,Width,Height;
} texture;
#endif

#pragma pack(push,1)
  #pragma pack(1)
  typedef struct{
    unsigned char R,G,B,A;
    float X,Y,Z;
  } point;
#pragma pack(pop)

/*********************************************************************
 * APPLICATION DATA                                                  *
 *********************************************************************/

struct {
  struct {
    int Index,Width,Height,FullScreen,DesiredFullScreen,DoubleBuffered,DesiredDoubleBuffered,MultiSample,DesiredMultiSample,ChangeMode;
#ifdef SCREENSAVER
    int ScreenSaverMode,MouseX,MouseY;
#endif
#ifdef USE_TEXTURE
    texture TextureMotion;
#  ifdef USE_MULTIPLE_TEXTURES
    texture TextureAccum;
#  endif
#endif
  } Window;
  struct {
    int Tick,PeriodStart,PeriodLength,TickTime;
    float Elasticity,Map,FPS,DesiredFPS;
  } Time;
  struct {
    transformation T1,T2;
    int MinDegree,MaxDegree;
  } Transformations;
  struct {
    int Count,DesiredCount,Rounded;
    float Size;
    point *Data;
  } Points;
  struct {
    float Alpha,SpaceFrequency,TimeFrequency;
  } ColorMap;
  struct {
    int BlendMethod,LimitCPUUsage,MotionBlur,Accumulation;
    float Luminance,Sharpness,Attenuation;
  } Display;
  struct {
    float Density;
    char sFrame[64],sTime[64],sFPS[64],sPointCount[64],sDensity[64],sPointSize[64],sAlpha[64],sCycle[64],sAttractor1[64],sAttractor2[64];
  } Statistics;
  menu *MainMenu;
} ApplicationData={
  {-1,1,1,0,0,1,1,0,0,0
#ifdef SCREENSAVER
    ,0,-1,-1
#endif
#ifdef USE_TEXTURE
#  ifdef USE_MULTIPLE_TEXTURES
    ,{INVALID_TEXTURE_INDEX,0,0,0,0},{INVALID_TEXTURE_INDEX,0,0,0,0}
#  else
    ,{0,0,0,0}
#  endif
#endif
  },
  {0,0,5000,0,5,0,50,40},
  {{0,0,NULL},{0,0,NULL},0,20},
  {0,2*MIN_POINT_COUNT,1,1,NULL},
  {0,1,1},
  {0,0,0,0,1,1,0.1},
  {0,"","","","","","","","","",""}
};

/*********************************************************************
 * FUNCTIONS                                                         *
 *********************************************************************/

void evolveWindow(void);
void evolveAlloc(void);
void evolveTime(void);
void evolvePoints(void);
void evolveProxy(void);
void evolveColorMap(void);
void evolve(void);

void displayFunc(void);
void reshapeFunc(int,int);
void idleFunc(void);
void keyboardFunc(unsigned char,int,int);
void specialFunc(int,int,int);
void mouseFunc(int,int,int,int);
#ifdef SCREENSAVER
void passiveMotionFunc(int,int);
#endif

void readIniFile(void);
void writeIniFile(void);

void fullScreenChange(int);
void fullScreenParamChange(int);
void doubleBufferedChange(int);
void multiSampleChange(int);
#ifdef USE_TEXTURE
void motionBlurChange(int);
#endif
void desiredFPSChange(int);
void limitCPUUsageChange(int);
void resetExecute(void);
void saveExecute(void);
void quitExecute(void);

void roundedPointsChange(int);
void blendMethodChange(int);
void luminanceChange(float);
void sharpnessChange(float);
void attenuationChange(float);
void spaceFrequencyChange(float);
void timeFrequencyChange(float);

void periodChange(float);
void elasticityChange(float);
void minDegreeChange(int);
void maxDegreeChange(int);

/*********************************************************************
 * MENU DESIGN                                                     *
 *********************************************************************/

SEPARATOR(Separator);

CHECKBOX(CheckBoxFullScreen,"Fullscreen (F)",0,fullScreenChange);
static char *ListBoxResolution_Items[6]={"default","320x240","640x480","800x600","1024x768","1280x1024"};
LISTBOX(ListBoxResolution,"Fullscreen resolution :",0,ListBoxResolution_Items,fullScreenParamChange);
static char *ListBoxBPP_Items[4]={"default","16","24","32"};
LISTBOX(ListBoxBPP,"Fullscreen color depth (BPP) :",0,ListBoxBPP_Items,fullScreenParamChange);
static char *ListBoxFrequency_Items[11]={"default","50","60","65","70","72","75","80","85","90","100"};
LISTBOX(ListBoxFrequency,"Fullscreen refresh rate (Hz) :",0,ListBoxFrequency_Items,fullScreenParamChange);
CHECKBOX(CheckBoxDoubleBuffered,"Double buffered (D)",1,doubleBufferedChange);
CHECKBOX(CheckBoxMultiSample,"Multi sample (M)",0,multiSampleChange);
#ifdef USE_TEXTURE
#  ifdef USE_MULTIPLE_TEXTURES
static char *ListBoxMotionBlur_Items[7]={"Single buffer","Double buffer","Triple buffer (2x filter)",
                                         "Triple buffer (3x filter)","Triple buffer (4x filter)","Triple buffer (5x filter)",
                                         "Triple buffer (6x filter)"};
LISTBOX(ListBoxMotionBlur,"Motion blur",1,ListBoxMotionBlur_Items,motionBlurChange);
#  else
CHECKBOX(CheckBoxMotionBlur,"High quality motion blur",1,motionBlurChange);
#  endif
#endif
ITRACKBAR(FTrackBarDesiredFPS,"Requested frame rate: %d",5,120,40,1,desiredFPSChange);
CHECKBOX(CheckBoxLimitCPUUsage,"Limit CPU usage",0,limitCPUUsageChange);
#ifdef SCREENSAVER
STATICTEXT(StaticTextReset,"Reset settings (R)",1,resetExecute);
STATICTEXT(StaticTextSave,"Save settings and exit (S)",1,saveExecute);
STATICTEXT(StaticTextQuit,"Cancel (Q)",1,quitExecute);
#  ifdef USE_TEXTURE
static menuitem *MenuPageAFC_Items[14]={
#  else
static menuitem *MenuPageAFC_Items[13]={
#  endif
#else
STATICTEXT(StaticTextSave,"Save settings (S)",1,saveExecute);
STATICTEXT(StaticTextReset,"Reset settings",1,resetExecute);
STATICTEXT(StaticTextQuit,"Quit (Q)",1,quitExecute);
#  ifdef USE_TEXTURE
static menuitem *MenuPageAFC_Items[15]={
#  else
static menuitem *MenuPageAFC_Items[14]={
#  endif
#endif
  &CheckBoxFullScreen,
  &ListBoxResolution,
  &ListBoxBPP,
  &ListBoxFrequency,
  &Separator,
  &CheckBoxDoubleBuffered,
  &CheckBoxMultiSample,
#ifdef USE_TEXTURE
#  ifdef USE_MULTIPLE_TEXTURES
  &ListBoxMotionBlur,
#  else
  &CheckBoxMotionBlur,
#  endif
#endif
  &FTrackBarDesiredFPS,
  &CheckBoxLimitCPUUsage,
  &Separator,
#ifdef SCREENSAVER
  &StaticTextReset,
  &StaticTextSave,
  &StaticTextQuit
#else
  &StaticTextSave,
  &StaticTextReset,
  &Separator,
  &StaticTextQuit
#endif
};
MENUPAGE(MenuPageAFC,"AFC Version 1.0",MenuPageAFC_Items);

CHECKBOX(CheckBoxRoundedPoints,"Rounded points",1,roundedPointsChange);
static char *ListBoxBlendMethod_Items[3]={"Logarithmic","Linear","Maximum"};
LISTBOX(ListBoxBlendMethod,"Blend color method :",0,ListBoxBlendMethod_Items,blendMethodChange);
FTRACKBAR(FTrackBarLuminance,"Luminance : %.0f%%",0,200,100,1,luminanceChange);
FTRACKBAR(FTrackBarSharpness,"Sharpness : %.0f%%",0,200,100,1,sharpnessChange);
FTRACKBAR(FTrackBarAttenuation,"Attenuation : %.1f%%",0.1,100,10,0.1,attenuationChange);
FTRACKBAR(FTrackBarSpaceFrequency,"Colormap space frequency : %.2f",0,50,1,0.02,spaceFrequencyChange);
FTRACKBAR(FTrackBarTimeFrequency,"Colormap time frequency : %.2f",0,20,1,0.02,timeFrequencyChange);
static menuitem *MenuPageDisplay_Items[9]={
  &CheckBoxRoundedPoints,
  &ListBoxBlendMethod,
  &Separator,
  &FTrackBarLuminance,
  &FTrackBarSharpness,
  &FTrackBarAttenuation,
  &Separator,
  &FTrackBarSpaceFrequency,
  &FTrackBarTimeFrequency
};
MENUPAGE(MenuPageDisplay,"DISPLAY",MenuPageDisplay_Items);

FTRACKBAR(FTrackBarPeriod,"Cycle length : %.1f sec",0.5,20,5,0.1,periodChange);
FTRACKBAR(FTrackBarElasticity,"Cycle elasticity : %.1f",0.1,30,5,0.1,elasticityChange);
ITRACKBAR(ITrackBarMinDegree,"Min attractor degree : %d",3,15,6,1,minDegreeChange);
ITRACKBAR(ITrackBarMaxDegree,"Max attractor degree : %d",3,15,6,1,maxDegreeChange);
static menuitem *MenuPageAttractor_Items[4]={&FTrackBarPeriod,&FTrackBarElasticity,&ITrackBarMinDegree,&ITrackBarMaxDegree};
MENUPAGE(MenuPageAttractor,"ATTRACTOR",MenuPageAttractor_Items);

STATICTEXT(StaticTextFrame,ApplicationData.Statistics.sFrame,0,NULL);
STATICTEXT(StaticTextTime,ApplicationData.Statistics.sTime,0,NULL);
STATICTEXT(StaticTextFPS,ApplicationData.Statistics.sFPS,0,NULL);
STATICTEXT(StaticTextPointCount,ApplicationData.Statistics.sPointCount,0,NULL);
STATICTEXT(StaticTextDensity,ApplicationData.Statistics.sDensity,0,NULL);
STATICTEXT(StaticTextPointSize,ApplicationData.Statistics.sPointSize,0,NULL);
STATICTEXT(StaticTextAlpha,ApplicationData.Statistics.sAlpha,0,NULL);
STATICTEXT(StaticTextCycle,ApplicationData.Statistics.sCycle,0,NULL);
STATICTEXT(StaticTextAttractor1,ApplicationData.Statistics.sAttractor1,0,NULL);
STATICTEXT(StaticTextAttractor2,ApplicationData.Statistics.sAttractor2,0,NULL);
static menuitem *MenuPageStatistics_Items[12]={
  &StaticTextFrame,
  &StaticTextTime,
  &StaticTextFPS,
  &Separator,
  &StaticTextPointCount,
  &StaticTextDensity,
  &StaticTextPointSize,
  &StaticTextAlpha,
  &Separator,
  &StaticTextCycle,
  &StaticTextAttractor1,
  &StaticTextAttractor2
};
MENUPAGE(MenuPageStatistics,"      STATISTICS      ",MenuPageStatistics_