rendertexture.cpp

PDE simulator on GPU.

						iTextureFormat = WGL_TEXTURE_FLOAT_RGBA_NV; 
					}
					else
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RGBA_ARB;  
						iTextureFormat = WGL_TEXTURE_RGBA_ARB; 
					}
				} 
				else if (iBBits > 0)
				{ 
					if (bNVIDIA)
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV;  
						iTextureFormat = WGL_TEXTURE_FLOAT_RGB_NV; 
					}
					else
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RGB_ARB;  
						iTextureFormat = WGL_TEXTURE_RGB_ARB; 
					}
				} 
				else if (iGBits > 0)
				{ 
					if (bNVIDIA)
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV;  
						iTextureFormat = WGL_TEXTURE_FLOAT_RG_NV; 
					}
					else
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RGB_ARB;  
						iTextureFormat = WGL_TEXTURE_RGB_ARB; 
					}
				} 
				else 
				{ 
					if (bNVIDIA)
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV;  
						iTextureFormat = WGL_TEXTURE_FLOAT_R_NV; 
					}
					else
					{
						iBindTarget    = WGL_BIND_TO_TEXTURE_RGB_ARB;  
						iTextureFormat = WGL_TEXTURE_RGB_ARB; 
					}
				}    
			}
    }
    else
    {
		if (IsPowerOfTwo(_iWidth) && IsPowerOfTwo(_iHeight))
		{
			_iTextureTarget = GL_TEXTURE_2D;
			glBindTexture(_iTextureTarget, _iTextureID);
            
			// We'll use clamp to edge as the default texture wrap mode for all tex types
			glTexParameteri( _iTextureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
			glTexParameteri( _iTextureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
			glTexParameteri( _iTextureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			
			if (bMipmap)
			{
				_bMipmap = true;
				glTexParameteri( _iTextureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
				
				// Generate mipmap automatically if supported
				if (extgl_Extensions.SGIS_generate_mipmap)
				{
					glTexParameteri( _iTextureTarget, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
				}
				else
				{
					PrintExtensionError("GL_SGIS_generate_mipmap");
				}
			}
			else
			{
				glTexParameteri( _iTextureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			}
			
			// Set anisotropic filter to the max ratio
			if (bAnisoFilter)
			{
				if (extgl_Extensions.EXT_texture_filter_anisotropic)
				{
					_bAnisoFilter = true;
					float rMaxAniso;
					glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &rMaxAniso);
					glTexParameterf( _iTextureTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, rMaxAniso);
				}
			}
			
			if (RT_COPY_TO_TEXTURE == _eUpdateMode)
			{
				GLuint iInternalFormat;
				GLuint iFormat;
				if (iABits > 0)
				{
					iInternalFormat = GL_RGBA8;
					iFormat = GL_RGBA;
				}
				else 
				{
					iInternalFormat = GL_RGB8;
					iFormat = GL_RGB;
				}
				// Allocate the texture image (but pass it no data for now).
				glTexImage2D(_iTextureTarget, 0, iInternalFormat, _iWidth, _iHeight, 
					0, iFormat, GL_FLOAT, NULL);
			}
			else
			{    
				iWGLTextureTarget = WGL_TEXTURE_2D_ARB; 
				if (iABits > 0) 
				{ 
					iBindTarget    = WGL_BIND_TO_TEXTURE_RGBA_ARB;
					iTextureFormat = WGL_TEXTURE_RGBA_ARB;
				} 
				else 
				{
					iBindTarget    = WGL_BIND_TO_TEXTURE_RGB_ARB;  
					iTextureFormat = WGL_TEXTURE_RGB_ARB; 
				} 
			}
		} 
		else
		{
			if (!bNVIDIA)
			{
				fprintf(stderr, 
					"RenderTexture Error: Rectangle textures only supported on NVIDIA hardware.\n");
				return false;
			}
			_bRectangle = true;
			
			_iTextureTarget = GL_TEXTURE_RECTANGLE_NV;
			
			glBindTexture(_iTextureTarget, _iTextureID);
			
			glTexParameteri( _iTextureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
			glTexParameteri( _iTextureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
			glTexParameteri( _iTextureTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri( _iTextureTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			
			if (bMipmap) 
			{ 
				
				fprintf(stderr, 
					"RenderTexture Error: rectangle textures do not support mipmaps\n"); 
				return false; 
			} 
			
			if (RT_COPY_TO_TEXTURE == _eUpdateMode)
			{
				GLuint iInternalFormat;
				GLuint iFormat;
				if (iABits > 0)
				{
					iInternalFormat = GL_RGBA8;
					iFormat = GL_RGBA;
				}
				else 
				{
					iInternalFormat = GL_RGB8;
					iFormat = GL_RGB;
				}
				// Allocate the texture image (but pass it no data for now).
				glTexImage2D(_iTextureTarget, 0, iInternalFormat, _iWidth, _iHeight, 
					0, iFormat, GL_FLOAT, NULL);
			}
			else
			{
				iWGLTextureTarget = WGL_TEXTURE_RECTANGLE_NV; 
				if (iABits > 0) 
				{ 
					iBindTarget    = WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV; 
					iTextureFormat = WGL_TEXTURE_RGBA_ARB; 
				} 
				else 
				{ 
					iBindTarget   = WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV; 
					iTextureFormat= WGL_TEXTURE_RGB_ARB; 
				} 
			}
		} 
    }
  }
  
  if (_bIsDepthTexture)
  {
	  if (!bNVIDIA && !(IsPowerOfTwo(_iWidth) && IsPowerOfTwo(_iHeight)))
	  {
		  fprintf(stderr, 
			  "RenderTexture Error: ATI textures must be power-of-two-dimensioned.\n");
		  return false;
	  }
	  
	  glBindTexture(_iTextureTarget, _iDepthTextureID);  
	  
	  // We'll use clamp to edge as the default texture wrap mode for all tex types
	  glTexParameteri( _iTextureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	  glTexParameteri( _iTextureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
	  glTexParameteri( _iTextureTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	  glTexParameteri( _iTextureTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	  
	  // user will need to set up hardware shadow mapping himself (using ARB_shadow)
	  
	  if (RT_COPY_TO_TEXTURE == _eUpdateMode)
	  {
		  // Allocate the texture image (but pass it no data for now).
		  glTexImage2D(_iTextureTarget, 0, GL_DEPTH_COMPONENT, _iWidth, _iHeight, 
			  0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
	  }
	  else  // RENDER_TO_TEXTURE
	  {
		  if(_bRectangle)
		  {
			  iDepthBindTarget    = WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV;
			  iDepthTextureFormat = WGL_TEXTURE_DEPTH_COMPONENT_NV;
		  }
		  else
		  {
			  iDepthBindTarget    = WGL_BIND_TO_TEXTURE_DEPTH_NV;
			  iDepthTextureFormat = WGL_TEXTURE_DEPTH_COMPONENT_NV;
		  }
	  }
  }
  
  // Get the current context.
  HDC hdc = wglGetCurrentDC();
  if (NULL == hdc)
	  _wglGetLastError();
  HGLRC hglrc = wglGetCurrentContext();
  if (NULL == hglrc)
	  _wglGetLastError();
  
  int iFormat = 0;
  unsigned int iNumFormats;
  int attribChooseList[50]; 
  int attribCreateList[50];
  int attribChoose = 0;
  int attribCreate = 0;
  
  // Setup the attrib list for wglChoosePixelFormat()
  if (_bFloat)
  {
	  attribChooseList[attribChoose++] = WGL_RED_BITS_ARB;
	  attribChooseList[attribChoose++] = iRBits;
	  attribChooseList[attribChoose++] = WGL_GREEN_BITS_ARB;
	  attribChooseList[attribChoose++] = iGBits;
	  attribChooseList[attribChoose++] = WGL_BLUE_BITS_ARB;
	  attribChooseList[attribChoose++] = iBBits;
	  attribChooseList[attribChoose++] = WGL_ALPHA_BITS_ARB;
	  attribChooseList[attribChoose++] = iABits;
	  if (bNVIDIA)
	  {
		  attribChooseList[attribChoose++] = WGL_FLOAT_COMPONENTS_NV;
		  attribChooseList[attribChoose++] = GL_TRUE;
	  }
	  else
	  {
		  attribChooseList[attribChoose++] = WGL_PIXEL_TYPE_ARB;
		  attribChooseList[attribChoose++] = WGL_TYPE_RGBA_FLOAT_ATI;
	  }
  }
  
  attribChooseList[attribChoose++] = WGL_STENCIL_BITS_ARB;
  attribChooseList[attribChoose++] = (bStencil) ? 8 : 0;
  attribChooseList[attribChoose++] = WGL_DEPTH_BITS_ARB;
  attribChooseList[attribChoose++] = (bDepth) ? 24 : 0;
  attribChooseList[attribChoose++] = WGL_DRAW_TO_PBUFFER_ARB;
  attribChooseList[attribChoose++] = GL_TRUE;
  
  if (_bIsTexture && RT_RENDER_TO_TEXTURE == _eUpdateMode)
  {
	  attribChooseList[attribChoose++] = iBindTarget;
	  attribChooseList[attribChoose++] = GL_TRUE;
  }
  if (_bIsDepthTexture && RT_RENDER_TO_TEXTURE == _eUpdateMode)
  {
	  attribChooseList[attribChoose++] = iDepthBindTarget;
	  attribChooseList[attribChoose++] = GL_TRUE;
  }
  
  attribChooseList[attribChoose++] = 0;
  
  // Setup the attrib list for wglCreatePbuffer()
  if (_bIsTexture && RT_RENDER_TO_TEXTURE == _eUpdateMode)
  {
	  attribCreateList[attribCreate++] = WGL_TEXTURE_FORMAT_ARB;
	  attribCreateList[attribCreate++] = iTextureFormat;
	  attribCreateList[attribCreate++] = WGL_TEXTURE_TARGET_ARB;
	  attribCreateList[attribCreate++] = iWGLTextureTarget;
	  attribCreateList[attribCreate++] = WGL_MIPMAP_TEXTURE_ARB;
	  attribCreateList[attribCreate++] = (bMipmap) ? GL_TRUE : GL_FALSE;  
  }
  if (_bIsDepthTexture && RT_RENDER_TO_TEXTURE == _eUpdateMode)
  {
	  attribCreateList[attribCreate++] = WGL_DEPTH_TEXTURE_FORMAT_NV;
	  attribCreateList[attribCreate++] = iDepthTextureFormat;
  }
  attribCreateList[attribCreate++] = WGL_PBUFFER_LARGEST_ARB;
  attribCreateList[attribCreate++] = GL_FALSE;
  attribCreateList[attribCreate++] = 0;
  
  if (!wglChoosePixelFormatARB( hdc, attribChooseList, NULL, 1, &iFormat, &iNumFormats))
  {
	  fprintf(stderr, 
		  "RenderTexture::Initialize() creation error: wglChoosePixelFormatARB() failed.\n");
	  _wglGetLastError();
	  return false;
  }
  if ( iNumFormats <= 0 )
  {
	  fprintf(stderr, 
		  "RenderTexture::Initialize() creation error: Couldn't find a suitable pixel format.\n");
	  _wglGetLastError();
	  return false;
  }
  
  // Create the p-buffer.    
  _hPBuffer = wglCreatePbufferARB( hdc, iFormat, _iWidth, _iHeight, attribCreateList );
  if (!_hPBuffer)
  {
	  fprintf(stderr, "RenderTexture::Initialize() pbuffer creation error: wglCreatePbufferARB() failed\n");
	  _wglGetLastError();
	  return false;
  }
  
  // Get the device context.
  _hDC = wglGetPbufferDCARB( _hPBuffer);
  if ( !_hDC )
  {
	  fprintf(stderr, 
		  "RenderTexture::Initialize() creation error: wglGetGetPbufferDCARB() failed\n");
	  _wglGetLastError();
	  return false;
  }
  
  // Create a gl context for the p-buffer.
  
  
  _hGLContext = wglCreateContext( _hDC );
  if ( !_hGLContext )
  {
	  fprintf(stderr, "RenderTexture::Initialize() creation error:  wglCreateContext() failed\n");
	  _wglGetLastError();
	  return false;
  }
  
  // Share lists, texture objects, and program objects.
  if( bShare )
  {
	  if( !wglShareLists(hglrc, _hGLContext) )
	  {
		  fprintf(stderr, "RenderTexture::Initialize() creation error: wglShareLists() failed\n" );
		  _wglGetLastError();
		  return false;
	  }
  }
  
  // bind the pbuffer to the render texture object
  if (_bIsTexture && RT_RENDER_TO_TEXTURE == _eUpdateMode)
  {
	  glBindTexture(_iTextureTarget, _iTextureID);
	  if (wglBindTexImageARB(_hPBuffer, WGL_FRONT_LEFT_ARB) == FALSE)