void Texture::Build(const char *filename, Texture::Filter filter)
	{
#pragma message( "Texture::Build() is not finished...")
#if 0
		size_t len = strlen(filename);
		const char *s= filename+ len- 3;

		if		(!strcmpi(s, "bmp"))	image = new ImageBMP;
		else if (!strcmpi(s, "tga"))	image = new ImageTGA;
		else if (!strcmpi(s, "jpg"))	image = new ImageJPG;
		else
		{
			DGL::LogError("Can't load image for texture: Unknown Format \"%s\" File\"%s\"",s, filename);
			return;
		}

		try {
			
			image->Load(filename);
            
			
			// First check the size:
			GLint maxSize;
			glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);

			GLint			width	= image->Width();
			GLint			height	= image->Height();

			if((width > maxSize)||(height > maxSize)||
				!IsPowerOfTwo(height)||!IsPowerOfTwo(width))
			{
				Clamp <GLint> ( 1, maxSize, width);
				Clamp <GLint> ( 1, maxSize, height);
				width = ClosestPowerOfTwo(width);
				height= ClosestPowerOfTwo(height);
				DGL::LogPrint(
					"Texture size is invalid: "
					"Resizing from (%i,%i) to (%i,%i)",
					image->Width(),image->Height(),width,height);

				image->Resize(width,height);
			}
			
			
			this->glTexture = Texture::_buildTexture(
										GL_TEXTURE_2D,
										image->Get(Image::COMPONENTS),
										image->Get(Image::WIDTH),
										image->Get(Image::HEIGHT),
										image->Get(Image::FORMAT),
										GL_UNSIGNED_BYTE,
										image->Data(),
										filter);
			delete image;


		} catch (Daher::Exception& ex) {
			LogError("Error Loading Image: \"%s\"", ex.What() );
		}
#else
		OldDGL::Texture::UseFilter(OldDGL::Texture::FILTER_TRILINEAR);
		OldDGL::Texture::SetParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, filter.GetParameter(GL_TEXTURE_WRAP_S) );
		OldDGL::Texture::SetParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, filter.GetParameter(GL_TEXTURE_WRAP_T) );

		char s[1024];
		D_strcpy(s, filename);
		this->glTexture = OldDGL::Texture::Load(s);
#endif
	}
Beispiel #2
0
void anim_fft_double (unsigned  NofSamples,
		      int       InverseTransform,
		      double   *RealIn,
		      double   *ImagIn,
		      double   *RealOut,
		      double   *ImagOut )
{
  unsigned NofBits;    /* Number of bits needed to store indices */
  unsigned LSample, j, k, n;
  unsigned BlockSize, BlockEnd;
  double AngleNumerator = 2.0 * M_PI;
  double TempReal, TempImagin;     /* temp real, temp imaginary */
  
  if ( !IsPowerOfTwo(NofSamples) ) {
    PrintError(("Error in fft():  NofSamples=%u is not power of two\n", NofSamples) );
    exit(1);
  }
  if ( InverseTransform ) AngleNumerator = -AngleNumerator;
  
  CHECKPOINTER ( RealIn );
  CHECKPOINTER ( RealOut );
  CHECKPOINTER ( ImagOut );

  NofBits = NumberOfBitsNeeded ( NofSamples );

  /*
  **   Do simultaneous data copy and bit-reversal ordering into outputs...
  */
  
  for ( LSample=0; LSample < NofSamples; LSample++ ) {
    j = ReverseBits ( LSample, NofBits );
    RealOut[j] = RealIn[LSample];
    ImagOut[j] = (ImagIn == NULL) ? 0.0 : ImagIn[LSample];
  }
  
  /*
  **   Do the FFT itself...
  */
  
  BlockEnd = 1;
  for ( BlockSize = 2; BlockSize <= NofSamples; BlockSize <<= 1 ) {
    double delta_angle = AngleNumerator / (double)BlockSize;
    double sm2 = sin ( -2 * delta_angle );
    double sm1 = sin ( -delta_angle );
    double cm2 = cos ( -2 * delta_angle );
    double cm1 = cos ( -delta_angle );
    double w = 2 * cm1;
    double ar[3], ai[3];
    
    for ( LSample=0; LSample < NofSamples; LSample += BlockSize ) {
      ar[2] = cm2;
      ar[1] = cm1;
      
      ai[2] = sm2;
      ai[1] = sm1;
      
      for ( j=LSample, n=0; n < BlockEnd; j++, n++ ) {
	ar[0] = w*ar[1] - ar[2];
	ar[2] = ar[1];
	ar[1] = ar[0];
	  
	ai[0] = w*ai[1] - ai[2];
	ai[2] = ai[1];
	ai[1] = ai[0];
	
	k = j + BlockEnd;
	TempReal = ar[0]*RealOut[k] - ai[0]*ImagOut[k];
	TempImagin = ar[0]*ImagOut[k] + ai[0]*RealOut[k];
	
	RealOut[k] = RealOut[j] - TempReal;
	ImagOut[k] = ImagOut[j] - TempImagin;
	
	RealOut[j] += TempReal;
	ImagOut[j] += TempImagin;
      }
    }
    BlockEnd = BlockSize;
  }
  
  /*
  **   Need to normalize if inverse transform...
  */
    
  if ( InverseTransform ) {
    double denom = (double)NofSamples;
    
    for ( LSample=0; LSample < NofSamples; LSample++ ) {
      RealOut[LSample] /= denom;
      ImagOut[LSample] /= denom;
    }
  }
}