예제 #1
0
static Errcode play_macro(int repeats)
{
Errcode err;

	close_macro();
	if((err = ffopen(macro_name,&Mcb.fp,rb_str)) < Success)
		goto error;

	if((err = ffread(Mcb.fp,&Mcb.mh,sizeof(Mcb.mh))) < Success)
		goto error;

	if(Mcb.mh.id.type != MAC_MAGIC || Mcb.mh.id.size < sizeof(Machead))
	{
		err = Err_bad_magic;
		goto error;
	}

	/* pre-fetch next record header flags */

	if((err = ffread(Mcb.fp,&Mcb.next,sizeof(Twobytes))) < Success)
		goto error;

	Mcb.sizeleft = Mcb.mh.id.size - (sizeof(Machead)+sizeof(USHORT));

	Mcb.lastmouse = *((Short_xy *)&icb.sx);
	icb.macro_mode = USE_MACRO;
	icb.macro_clocked = Mcb.mh.realtime;
	Mcb.repeats = repeats;
	return(Success);
error:
	close_macro();
	return(err);
}
예제 #2
0
파일: main.c 프로젝트: Godzil/quickdev16
// *****************************************************************************************************************
void beispiele(void){

  char datei[12]="TEST    TXT";		// hier muss platz für 11 zeichen sein (8.3), da fat_str diesen string benutzt !!
  fat_str(datei);						// wandelt "test.txt" in das fat format 8.3 der form: "TEST    TXT" muss immer dieses Format haben, auch ordner !!

  // 0.) ______________löschen von dateien/ordnern (ordner rekursiv)____________________________________________
  ffrm( datei );								// löschen der datei/ordner falls vorhanden

  // 1.) ______________anlegen und schreiben____________________________________________________________________
  // 	öffnet datei, wenn nicht vorhanden, legt ffopen datei an (rückgabewert = 1 datei existiert, also nur öffnen, 2 = angelegt).   
  ffopen( datei );						

  // schreibt string 
  ffwrites((char*)"Hallo Datei :)");
  // neue zeile in der datei
  ffwrite(0x0D);
  ffwrite(0x0A);

  // schließt datei
  ffclose();

  // 2.)________________ändern von vorhandenen daten in dateien__________________________________________________
  ffopen( datei );		// siehe oben...
  ffseek(12);				// spult in datei auf position 12 vor (fängt immer bei 0 an zu zählen !)
  ffwrite(';');			// schreibt dann ab position 12 (überschreibt daten der datei, hier nur 1 zeichen)
  ffclose();				// schließt datei  

  // 3.)________________lesen von dateien_________________________________________________________________________
  ffopen( datei );							// siehe oben...
  unsigned long int seek=file.length;	// eine variable setzen und runterzählen bis 0 geht am schnellsten !
  do{
	 uputc(ffread());							// liest ein zeichen und gibt es über uart aus !
	 }while(--seek);							// liest solange bytes da sind (von datei länge bis 0)
  ffclose();									// schließt datei

  uputc('\n');	// neue zeile weil neue unteraufgabe

  // 4.)________________anhängen von daten an datei_______________________________________________________________
  ffopen( datei);				// siehe oben...
  ffseek(file.length);			// spult in datei ans ende
  ffwrites((char*)"Dies ist ein Test...");	  // siehe oben
  // neue zeile in der datei
  ffwrite(0x0D);
  ffwrite(0x0A);
  ffclose();						// schließt datei  

  // 3.)________________lesen von dateien_________________________________________________________________________
  ffopen( datei );		// siehe oben...
  seek=file.length;		// eine variable setzen und runterzählen bis 0 geht am schnellsten !
  do{
	 uputc(ffread());		// liest ein zeichen und gibt es über uart aus !
	 }while(--seek);		// liest solange bytes da sind (von datei länge bis 0)
  ffclose();				// schließt datei
  
}
예제 #3
0
void nahraj_texturu_fc(FFILE f, EDIT_MATERIAL * p_mat, EDIT_TEXT * p_text,
  int max, int cislo_text, int save)
{
  OLD_MULTITEXT_FLAG mt;
  char string[100];
  int t;

  if (lo_je_tag(f, TEXT_TAG)) {
    str_read(string, f);
    strlwr(string);
    if (!strcmp(string, S_NIC)) {
      p_mat->p_text[cislo_text] = NULL;
      p_mat->textfile[cislo_text][0] = 0;
    }
    else {
      if (save) {
        if ((t = lo_najdi_texturu(p_text, max, string, FALSE)) == K_CHYBA) {
          if ((t = lo_najdi_volnou_texturu(p_text, max)) == K_CHYBA)
            chyba("Textury");
          strcpy(p_text[t].jmeno, string);
        }
        p_mat->p_text[cislo_text] = p_text + t;
        strcpy(p_mat->textfile[cislo_text], string);
      }
    }
  }
  if (lo_je_tag(f, MULTI_TAG))
    ffread(&mt, sizeof(mt), 1, f);
}
예제 #4
0
static Errcode read_abort_rec()
{
Errcode err;
int readsize;

	Mcb.ar.flags = Mcb.next.b[0];
	if(0 != (readsize = Mcb.ar.flags & AR_ABORTLEVEL))
	{
		((UBYTE *)(&Mcb.ar))[1] = Mcb.next.b[1];

		/* readsize = num levels counts - one byte + sizeof next */

		Mcb.mab_level = (readsize /= ABORTLEVEL_1) - 1;
		readsize = (readsize * sizeof(USHORT)) - 1 + sizeof(USHORT);

		if((err = ffread(Mcb.fp,OPTR(Mcb.ar.counts,1),readsize)) < Success)
			return(macro_write_error(err));

		Mcb.sizeleft -= readsize;
		Mcb.next.flags = *((USHORT *)(OPTR(&Mcb.ar,readsize)));

	}
	else /* one byte non abort poll end record move last byte
		  * to first and fetch next byte in file */
	{
		Mcb.next.b[0] = Mcb.next.b[1];
		Mcb.next.b[1] = ffgetc(Mcb.fp);
		--Mcb.sizeleft; 
	}
	return(Success);
}
예제 #5
0
int main(int argc,char**argv) {
   int cm,x,y,fx,fy,j,k,l,m,n,psfType=0;
   FILE *fpsf;
   char str[161];
   float **psf;

   if (argc<7) usage(*argv);
   for (j=7;j<argc;j++) {
      if (!strcasecmp(argv[j],"-anderson")) psfType=1;
      else usage(*argv);
   }
   cm=atoi(argv[2]);
   if (cm<0 || cm>2) {
      printf("Chip must be 0-2\n");
      return -1;
   }
   x=atoi(argv[3]);
   if (x<0 || x>=wfc3_nxpsfpos[cm]) {
      printf("X position must be 0-%d\n",wfc3_nxpsfpos[cm]-1);
      return -1;
   }
   y=atoi(argv[4]);
   if (y<0 || y>=wfc3_nypsfpos[cm]) {
      printf("Y position must be 0-%d\n",wfc3_nypsfpos[cm]-1);
      return -1;
   }
   fx=atoi(argv[5]);
   fy=atoi(argv[6]);
   if (fx<-wfc3_n2psf[cm] || fx>wfc3_n2psf[cm] || fy<-wfc3_n2psf[cm] || fy>wfc3_n2psf[cm]) {
      printf("dX and dY must be -%d to %d\n",wfc3_n2psf[cm],wfc3_n2psf[cm]);
      return -1;
   }
   if (psfType==0) sprintf(str,"%s/wfc3/data/%s.%s.psf",BASEDIR,argv[1],wfc3_cn[cm]);
   else sprintf(str,"%s/wfc3/data/%s_anderson.%s.psf",BASEDIR,argv[1],wfc3_cn[cm]);
   if ((fpsf=fopen(str,"rb"))==NULL) {
      printf("Cannot open %s\n",str);
      return -1;
   }
   psf=(float**)calloc(sizeof(float*),wfc3_rpsf[cm]*2+1);
   if (!psf) merr();
   psf+=wfc3_rpsf[cm];
   for (j=-wfc3_rpsf[cm];j<=wfc3_rpsf[cm];j++) {
      psf[j]=(float*)calloc(sizeof(float),wfc3_rpsf[cm]*2+1);
      if (!psf[j]) merr();
      psf[j]+=wfc3_rpsf[cm];
   }
   for (j=0;j<y;j++) for (k=0;k<wfc3_nxpsfpos[cm];k++) for (l=-wfc3_n2psf[cm];l<=wfc3_n2psf[cm];l++) for (m=-wfc3_n2psf[cm];m<=wfc3_n2psf[cm];m++) for (n=-wfc3_rpsf[cm];n<=wfc3_rpsf[cm];n++) fread(psf[n]-wfc3_rpsf[cm],4,2*wfc3_rpsf[cm]+1,fpsf);
   for (k=0;k<x;k++) for (l=-wfc3_n2psf[cm];l<=wfc3_n2psf[cm];l++) for (m=-wfc3_n2psf[cm];m<=wfc3_n2psf[cm];m++) for (n=-wfc3_rpsf[cm];n<=wfc3_rpsf[cm];n++) fread(psf[n]-wfc3_rpsf[cm],4,2*wfc3_rpsf[cm]+1,fpsf);
   for (l=-wfc3_n2psf[cm];l<fy;l++) for (m=-wfc3_n2psf[cm];m<=wfc3_n2psf[cm];m++) for (n=-wfc3_rpsf[cm];n<=wfc3_rpsf[cm];n++) fread(psf[n]-wfc3_rpsf[cm],4,2*wfc3_rpsf[cm]+1,fpsf);
   for (m=-wfc3_n2psf[cm];m<fx;m++) for (n=-wfc3_rpsf[cm];n<=wfc3_rpsf[cm];n++) fread(psf[n]-wfc3_rpsf[cm],4,2*wfc3_rpsf[cm]+1,fpsf);
   for (n=-wfc3_rpsf[cm];n<=wfc3_rpsf[cm];n++) ffread(psf[n]-wfc3_rpsf[cm],4,2*wfc3_rpsf[cm]+1,fpsf);
   k=wfc3_rpsf[cm];
   if (k>6) k=6;
   for (n=k;n>=-k;n--) {
      for (j=-k;j<=k;j++) printf("%5d ",(int)(psf[n][j]*100000+0.5));
      printf("\n");
   }
   fclose(fpsf);
   return 0;
}
예제 #6
0
int lo_nacti_vertexlist_out(FFILE f, OBJEKT_BOD ** p_vert)
{
  GENERIC_HEAD head;
  long t = fftell(f);
  float v[3];
  int i;

  if (*p_vert != NULL) {
    return ((int) NULL);
  }

  if (!ffread(&head, sizeof(head), 1, f)) {
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  if ((head.h[0] != 'V') ||
    (head.h[1] != 'V') || (head.h[2] != 'V') || (head.h[3] != 'V')) {
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  if ((*p_vert =
      (OBJEKT_BOD *) mmalloc(sizeof(OBJEKT_BOD) * head.pocet)) == NULL) {
    chyba("Nedostatek pameti...");
  }

  memset(*p_vert, 0, sizeof(OBJEKT_BOD) * head.pocet);

  for (i = 0; i < head.pocet; i++) {
    if (!ffread(&v, sizeof(v), 1, f)) {
      ffseek(f, t, SEEK_SET);
      null_free((void **) p_vert);
      return ((int) NULL);
    }
    (*p_vert)[i].x = v[0];
    (*p_vert)[i].y = v[1];
    (*p_vert)[i].z = v[2];
    (*p_vert)[i].dr = (*p_vert)[i].dg = (*p_vert)[i].db = 1.0f;
  }

  return (head.pocet);
}
예제 #7
0
int lo_nahraj_konfiguraci_kontejneru_out(FFILE f, EDIT_KONTEJNER * p_kont)
{
  KONTEJNER_KONFIG kkonf;
  KONTEJNER_KONFIG_OLD kkonf_old;

  if (lo_je_tag(f, KONFIG_TAG)) {       // nacti nove info
    ffread(&kkonf, sizeof(kkonf), 1, f);
    p_kont->m1flag = kkonf.flag & 0xffff;
    p_kont->kflag = kkonf.flag & 0xffff0000;
    return (TRUE);
  }
  else if (lo_je_tag(f, KONFIG_TAG_OLD)) {      // nacti stare info
    ffread(&kkonf_old, sizeof(kkonf_old), 1, f);
    p_kont->m1flag |= kkonf_old.flag ? MAT_PRUHLEDNY : 0;
    return (TRUE);
  }
  else
    return (FALSE);
}
예제 #8
0
int lo_nacti_word_matrix_out(FFILE f, GLMATRIX * p_mat)
{
  GENERIC_HEAD head;
  int t = fftell(f);

  if (!ffread(&head, sizeof(head), 1, f)) {
    ffseek(f, t, SEEK_SET);
    return (FALSE);
  }
  if (head.h[0] != 'W' || head.h[1] != 'W' || head.h[2] != 'W'
    || head.h[3] != 'W') {
    ffseek(f, t, SEEK_SET);
    return (FALSE);
  }
  if (!ffread(p_mat, sizeof(GLMATRIX), 1, f)) {
    ffseek(f, t, SEEK_SET);
    return (FALSE);
  }
  return (TRUE);
}
예제 #9
0
int lo_nacti_maplist_out(FFILE f, OBJEKT_BOD ** p_vert, int c_text)
{
  GENERIC_HEAD head;
  long t = fftell(f);
  float *p_map;
  float m[2];
  int i;

  if (*p_vert == NULL)
    return ((int) NULL);

  if (!ffread(&head, sizeof(head), 1, f)) {
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  if ((head.h[0] != 'M') ||
    (head.h[1] != 'M') || (head.h[2] != 'M') || (head.h[3] != 'M')) {
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  if (c_text >= 2) {
    c_text = 1;
  }

  for (i = 0; i < head.pocet; i++) {
    if (!ffread(&m, sizeof(m), 1, f)) {
      ffseek(f, t, SEEK_SET);
      return ((int) NULL);
    }
    p_map = &(*p_vert)[i].tu1;
    p_map[0 + c_text * 2] = m[0];
    p_map[1 + c_text * 2] = -m[1];
  }

  return (head.pocet);
}
예제 #10
0
int lo_nacti_barvy_out(FFILE f, OBJ_VERTEX * p_vert, word pocet)
{
  GENERIC_HEAD head;
  dword barva;
  long t = fftell(f);
  int i;

  if (p_vert == NULL)
    return (FALSE);

  for (i = 0; i < pocet; i++) {
    p_vert[i].dr = p_vert[i].dg = p_vert[i].db = 1.0f;
  }

  if (!ffread(&head, sizeof(head), 1, f)) {
    ffseek(f, t, SEEK_SET);
    return (FALSE);
  }

  if ((head.h[0] != 'D') ||
    (head.h[1] != 'D') || (head.h[2] != 'D') || (head.h[3] != 'D')) {
    ffseek(f, t, SEEK_SET);
    return (FALSE);
  }

  for (i = 0; i < head.pocet; i++) {
    if (!ffread(&barva, sizeof(dword), 1, f)) {
      ffseek(f, t, SEEK_SET);
      return (FALSE);
    }
    else {
      rgb_float(barva, &p_vert[i].dr);
    }
  }

  return (head.pocet);
}
예제 #11
0
파일: io_wav.c 프로젝트: ihrke/libeegtools
/** \brief read WAV-File.

	see https://ccrma.stanford.edu/courses/422/projects/WaveFormat/
	for details on the wav-file format
	\param f a FILE pointer
	\return the wavfile (freshly allocated) or NULL (failure)
 */
WavFile* wavfile_read( FILE *f ){
  uint32_t buf;
  WavFile *w;
  int stopflag=0;

  if( ffread( &buf, 1, 4, f ) &&  buf!=0x46464952 ){ /* "RIFF" */
	 stopflag=1;
  }
  ffread( &buf, 1, 4, f ); /* trash */
  if( ffread( &buf, 1, 4, f ) &&  buf!=0x45564157 ){ /* 'WAVE' */
	 stopflag=1;
  }
  if( ffread( &buf, 1, 4, f ) &&  buf!=0x20746d66 ){ /* 'fmt ' */
	 stopflag=1;
  }
  
  if( stopflag ){
	 fprintf( stderr, "No WAV-File\n" );
	 return NULL;
  }
  if( ffread( &buf, 1, 4, f ) && buf!=16 ){ /* no compression */
	 fprintf( stderr, "Cannot handle compression...\n" );
	 return NULL;
  }

  w = (WavFile*) malloc( sizeof(WavFile) );
  ffread( w, 1, 16, f );

  if( ffread( &buf, 1, 4, f ) && buf!=0x61746164 ){ /* 'data' */
	 fprintf( stderr, "No data\n" );
	 return NULL;
  }

  if( !ffread( &(w->data_size), 1, 4, f ) )
	 return NULL;
  
  w->data = (void*) malloc( w->data_size );
  ffread( w->data, 1, w->data_size, f );

  return w;
}
예제 #12
0
int lo_nacti_facelist_out(FFILE f, FACE ** p_face)
{
  GENERIC_HEAD head;
  long t = fftell(f);


  if (*p_face != NULL)
    return ((int) NULL);

  if (!ffread(&head, sizeof(head), 1, f)) {
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  if ((head.h[0] != 'F') ||
    (head.h[1] != 'F') || (head.h[2] != 'F') || (head.h[3] != 'F')) {
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  head.pocet *= 3;
  if (!head.pocet)
    chyba("load facelist -> 0 facu !");

  if ((*p_face = (FACE *) mmalloc(sizeof(FACE) * head.pocet)) == NULL) {
    chyba("Nedostatek pameti...");
  }

  if (!ffread(*p_face, sizeof(FACE), head.pocet, f)) {
    null_free((void **) p_face);
    ffseek(f, t, SEEK_SET);
    return ((int) NULL);
  }

  return (head.pocet);
}
예제 #13
0
size_t
stdiof_ffread (void *buf, size_t recsz, size_t numrec, FILE *stream)
{
	int	fd;
	size_t	reqdbytes;
	size_t	repval;
	size_t	recdone;

	fd = (long)stream;	/* redfine it to be what it actually is */
	reqdbytes = recsz * numrec;

	repval = ffread(fd, buf, reqdbytes);
	recdone = repval / recsz;

	return ( recdone );
}
예제 #14
0
/** Compare an array of doubles to doubles stored binary file.
 * The data must be stored in 32 bit floats
 *
 * \param precision to which position after comma it is compared
 * \return 
 *   - 0 if everything is equal
 *   - 1 if there is an element that is not equal
 * \todo check it, does not seem to work properly
 */
int isequal_doublearray_binfile(double *d, int n, const char *filename, int precision){
  FILE *f;
  double *d2;
  int i, flag=1;

  d2 = (double*)malloc(n*sizeof(double));
  if((f=fopen(filename, "rb"))==NULL){
	 errprintf("opening file '%s' failed\n", filename);
	 return -1;
  }

  ffread(d2, sizeof(double), n, f);
  fclose(f);

  flag = isequal_doublearray( d, d2, n, precision );
  free(d2);
  return flag;
}
예제 #15
0
static int
ffio_pgin(ncio *const nciop,
	off_t const offset, const size_t extent,
	void *const vp, size_t *nreadp, off_t *posp)
{
	int status;
	ssize_t nread;

#ifdef X_ALIGN
	assert(offset % X_ALIGN == 0);
	assert(extent % X_ALIGN == 0);
#endif

	if(*posp != offset)
	{
		if(ffseek(nciop->fd, offset, SEEK_SET) != offset)
		{
			status = errno;
			return status;
		}
		*posp = offset;
	}

	errno = 0;
	nread = ffread(nciop->fd, vp, extent);
	if(nread != extent)
	{
		status = errno;
		if(nread == -1 || status != ENOERR)
			return status;
		/* else it's okay we read 0. */
	}
	*nreadp = nread;
	*posp += nread;

	return ENOERR;
}
예제 #16
0
Errcode get_macro_input(void)
/* read and process macro into input stream */
{
int readsize;
Errcode err;
USHORT oflags;

	if((err = poll_macro_abort()) < Success)
		goto error;

	if(Mcb.macbuf == NULL) /* no input record in buffer read one in */
	{
		if(Mcb.sizeleft <= 0) /* end of macro file stream */
		{
			if(--Mcb.repeats > 0)
			{
				if((err = play_macro(Mcb.repeats)) < Success)
					goto error;
			}
			else
			{
				err = Err_abort;
				goto error;
			}
		}

		if(Mcb.next.b[0] & MACRO_REC) /* not an input record */
			goto reuse_last;

		/* retrieve record head and calculate record size to read */

		Mcb.ioflags = Mcb.next.flags;
		readsize = sizeof(USHORT); /* short for prefetch of next record head */

		if(Mcb.ioflags & HAS_CCOUNT) /* get previous io state and count */
		{
			if((err = ffread(Mcb.fp,&oflags,sizeof(USHORT))) < Success)
				goto error;

			Mcb.sizeleft -= sizeof(USHORT);

			if(oflags & CCOUNT_SHORT)
				readsize += sizeof(USHORT);
			else if(oflags & CCOUNT_LONG)
				readsize += sizeof(ULONG);
			else
				readsize += sizeof(UBYTE);

			if(oflags & HAS_MOUSEX)
				readsize += sizeof(SHORT); 
			if(oflags & HAS_MOUSEY)
				readsize += sizeof(SHORT); 
			if(oflags & HAS_HISTATE)
				readsize += sizeof(USHORT);
		}

		if(Mcb.ioflags & KEYHIT)
			readsize += sizeof(USHORT);
		if(Mcb.ioflags & HAS_PRESSURE)
			readsize += sizeof(UBYTE); 
		if(Mcb.ioflags & HAS_MOUSEX)
			readsize += sizeof(SHORT); 
		if(Mcb.ioflags & HAS_MOUSEY)
			readsize += sizeof(SHORT); 
		if(Mcb.ioflags & HAS_HISTATE)
			readsize += sizeof(USHORT);

		if((Mcb.sizeleft -= readsize) < 0)
			readsize -= sizeof(USHORT);	/* end of file, NO next record */

		if( readsize != 0 
			&& (err = ffread(Mcb.fp,Mcb.mbuf,readsize)) < Success)
		{
			goto error;
		}

		/* get last short in buffer, this is head of next rec or garbage if
		 * end of file (previous short before buffer) */

		Mcb.next.flags = *(USHORT *)&(Mcb.mbuf[readsize-sizeof(USHORT)]);

		Mcb.macbuf = Mcb.mbuf; /* flag record present, at start of buffer */

		if(Mcb.ioflags & HAS_CCOUNT)
		{
			/* add count to possibly decremented value and get count of
			 * polls left to do before using this record */

			if(oflags & CCOUNT_SHORT)
			{
				Mcb.iocount += VGETVAL(Mcb.macbuf,USHORT);
			}
			else if(oflags & CCOUNT_LONG)
			{
				Mcb.iocount += VGETVAL(Mcb.macbuf,ULONG);
			}
			else
			{
				Mcb.iocount += VGETVAL(Mcb.macbuf,UBYTE);
			}

			if((LONG)Mcb.iocount < 0) 
				/* oops, file corrupt or program outta sync */
			{
				err = Err_macrosync;
				goto error;
			}

			/* item with poll count has to provide previous input state
			 * to re-create recorded conditions in _poll_input() */

			icb.state = oflags & MACSTATE;

			if(oflags & HAS_MOUSEX)
			{
				icb.sx = VGETVAL(Mcb.macbuf,SHORT);
			}
			if(oflags & HAS_MOUSEY)
			{
				icb.sy = VGETVAL(Mcb.macbuf,SHORT);
			}
			if(oflags & HAS_HISTATE)
			{
				HISTATE_WORD(icb.state) |= VGETVAL(Mcb.macbuf,USHORT);
			}

			if(Mcb.iocount == 0) /* if count is zero we must put this
								  * iostate into the previous state 
								  * otherwise next poll will do this 
								  * in poll input */
			{
				SET_BUPBITS(icb.state);
				icb.ostate = icb.state & ALL_BSTATES;
				get_menucursorxy(); /* recalc previous values as current */
				ICB_COPYTO_LAST();  /* put them in last buffer */
			}
		}
	}

	if(Mcb.iocount > 0) /* we have record, but keep polling */
		goto reuse_last;

	/* count satisfied, let user have recorded input */

	icb.state = Mcb.ioflags & MACSTATE;

	if(icb.state & KEYHIT)
	{
		icb.inkey = VGETVAL(Mcb.macbuf,USHORT);
	}
	else
		icb.inkey = 0;

	if(Mcb.ioflags & HAS_PRESSURE)
	{
		icb.pressure = VGETVAL(Mcb.macbuf,UBYTE);
	}
	else
		icb.pressure = PRESSURE_MAX;

	if(Mcb.ioflags & HAS_MOUSEX)
	{
		Mcb.lastmouse.x = VGETVAL(Mcb.macbuf,SHORT);
	}
	if(Mcb.ioflags & HAS_MOUSEY)
	{
		Mcb.lastmouse.y = VGETVAL(Mcb.macbuf,SHORT);
	}
	*((Short_xy *)&icb.sx) = Mcb.lastmouse;
	if(Mcb.ioflags & HAS_HISTATE)
	{
		Mcb.last_histate = VGETVAL(Mcb.macbuf,USHORT);
	}
	HISTATE_WORD(icb.state) |= Mcb.last_histate; 

	Mcb.macbuf = NULL; /* flag macro consumed no longer present */
	return(Success);

reuse_last:

	--Mcb.iocount;			  /* decrement input poll counter */
	icb.state &= ALL_BSTATES; /* clear changed _poll_input() unique flags */
	return(Success);

error:
	return(macro_read_error(err));
}
예제 #17
0
EDIT_MATERIAL *lo_nahraj_material_out(FFILE f, EDIT_TEXT * p_text, int max,
  int save)
{
  EDIT_MATERIAL *p_mat;
  MATERIAL *p_dxmat;
  OLD_MULTITEXT_FLAG mt;
  char string[50];
  dword tmp;

  if (!lo_je_tag(f, MTRL_TAG))
    return (NULL);
  else {
    p_mat = vyrob_material();
    str_read(p_mat->jmeno, f);
  }
  ffread(string, sizeof(char), 9, f);

  // nacteni grb
  if (save) {
    p_dxmat = &p_mat->dxmat;
    p_dxmat->ambient_r = (float) string[0] / MAX_BYTE;
    p_dxmat->ambient_g = (float) string[1] / MAX_BYTE;
    p_dxmat->ambient_b = (float) string[2] / MAX_BYTE;

    p_dxmat->diffuse_r = (string[3]) ? ((float) string[3]) / MAX_BYTE : 1.0f;
    p_dxmat->diffuse_g = (string[4]) ? ((float) string[4]) / MAX_BYTE : 1.0f;
    p_dxmat->diffuse_b = (string[5]) ? ((float) string[4]) / MAX_BYTE : 1.0f;
    p_dxmat->diffuse_a = 1.0f;

    p_dxmat->specular_r = (float) string[6] / MAX_BYTE;
    p_dxmat->specular_g = (float) string[7] / MAX_BYTE;
    p_dxmat->specular_b = (float) string[8] / MAX_BYTE;

    p_dxmat->faktor_r = 1.0f;
    p_dxmat->faktor_g = 1.0f;
    p_dxmat->faktor_b = 1.0f;
    p_dxmat->faktor_a = 1.0f;
  }

  // nacte soubor s animacema
  if (lo_je_tag(f, MATANIM_TAG)) {
    str_read(p_mat->anim.jmeno, f);
    //lo_vyrob_animaci_list(p_mat,p_mat->anim.jmeno,p_text,max,ANIM_LOAD_ALL);
  }

  // nacte alfa tag
  if (lo_je_tag(f, FAKTOR_TAG)) {
    ffread(&tmp, sizeof(dword), 1, f);
  }

  // Nacte stage blok
  if (lo_je_tag(f, STAG_TAG)) {
    ffread(string, sizeof(char), 1, f);

    ffread(&tmp, sizeof(dword), 1, f);
    ffread(&tmp, sizeof(dword), 1, f);

    p_mat->alfa_state = 0;
    p_mat->text_state[0].text_stage = 0;
    p_mat->text_state[1].text_stage = 0;
  }

  // nacteni nuloveho blendu
  if (lo_je_tag(f, MULTI_TAG))
    ffread(&mt, sizeof(mt), 1, f);

  nahraj_texturu_fc(f, p_mat, p_text, max, 0, save);
  nahraj_texturu_fc(f, p_mat, p_text, max, 1, save);
  nahraj_texturu_fc(f, p_mat, p_text, max, 1, save);

  strlwr(p_mat->jmeno);

  if (save)
    return (p_mat);
  else {
    zrus_material(&p_mat);
    return ((EDIT_MATERIAL *) 1);
  }
}
예제 #18
0
int lo_nahraj_objekty_out(EDIT_MATERIAL ** p_mat, int max_mat, FFILE f,
  EDIT_KONTEJNER * p_kont, int mat)
{
  char string[50];
  int i, j, k;
  word r1;

  for (i = 0; i < p_kont->max_objektu; i++) {
    if (!lo_je_tag(f, "JMOB"))
      break;
    else
      str_read(string, f);

    if (!lo_je_tag(f, "TMSH"))
      continue;                 //je to objekt ale neni to mes

    if ((p_kont->p_obj[i] = lo_nacti_vec_FILE_out(f)) == NULL)
      chyba("Nacitani objektu...");

    strcpy(p_kont->p_obj[i]->jmeno, string);

    for (k = 0; k < 2; k++) {
      //nactenej jeden objekt - pricist jeste material
      if (!lo_je_tag(f, "FMAT")) {
        break;                  // neni material - na dalsi objekt
      }
      else
        str_read(string, f);

      if (mat) {
        if (!k) {
          if (!strcasecmp(string, S_NIC)) {
            p_kont->p_obj[i]->material = 0;
            p_kont->p_obj[i]->m1flag = 0;
            p_kont->p_obj[i]->m2flag = 0;
            p_kont->p_obj[i]->oflag = 0;
          }
          else {
            for (j = 0; j < max_mat; j++) {
              if (p_mat[j] && !strcasecmp(string, p_mat[j]->jmeno)) {
                p_kont->p_obj[i]->material = (word) j;
                p_kont->p_obj[i]->m1flag = p_mat[j]->flag;
                p_kont->p_obj[i]->m2flag = p_mat[j]->flag2;
                break;
              }
            }
            if (j == max_mat) {
              ddw("Neznamy material '%s' v objektu '%s'", string,
                p_kont->p_obj[i]->jmeno);
              p_kont->p_obj[i]->material = 0;
              p_kont->p_obj[i]->m1flag = 0;
              p_kont->p_obj[i]->m2flag = 0;
            }
          }
        }
      }
      else {
        p_kont->p_obj[i]->material = 0;
        p_kont->p_obj[i]->m1flag = 0;
        p_kont->p_obj[i]->m2flag = 0;
      }
    }
    if (lo_je_tag(f, "RECT")) { // sou tam recy
      ffread(&r1, sizeof(word), 1, f);
      ffread(&r1, sizeof(word), 1, f);
    }
  }
  return (i);
}