~unity-team/nux/nux.redirected-views

 

    IOpenGLTexture2D *ptr;

    CreateTexture(Width, Height, Levels, PixelFormat, (IOpenGLTexture2D **) &ptr, NUX_FILE_LINE_PARAM);

    ObjectPtr<IOpenGLTexture2D> h = ObjectPtr<IOpenGLTexture2D> (ptr);

    ptr->UnReference();

    return h;

  }

 

  int GpuDevice::CreateTexture(

    unsigned int Width

    , unsigned int Height

    , unsigned int Levels

    , BitmapFormat PixelFormat

    , IOpenGLTexture2D **ppTexture

    , NUX_FILE_LINE_DECL

    )

  {

    if ((Width <= 0) || (Height <= 0))

      *ppTexture = NULL;

      return 0;

    // From : http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_non_power_of_two.txt

    //    The "floor" convention has a relatively straightforward way to

    //        evaluate(with integer math) means to determine how many mipmap

    //        levels are required for a complete pyramid:

    //    numLevels = 1 + floor(log2(max(w, h, d)))

    unsigned int NumTotalMipLevel    = 1 + floorf(Log2(Max(Width, Height)));

 

    //    Levels

    //        [in] Number of levels in the texture. If this is zero, generate all texture sublevels

    //        down to 1 by 1 pixels for hardware that supports mip-maps textures. Call GetNumMipLevel to see the

    //        number of levels generated.

    else if (Levels > NumTotalMipLevel)

 

    //    The "floor" convention can be evaluated incrementally with the

    //        following recursion:

    //

    //    nextLODdim = max(1, currentLODdim >> 1)

    //

    //        where currentLODdim is the dimension of a level N and nextLODdim

    //        is the dimension of level N+1.  The recursion stops when level

    //        numLevels-1 is reached.

 

    *ppTexture = new IOpenGLTexture2D(Width, Height, NumMipLevel, PixelFormat, false, NUX_FILE_LINE_PARAM);

 

    return 1;

    IOpenGLTexture2D *ptr;

    ptr = new IOpenGLTexture2D(width, height, levels, pixel_format, true, NUX_FILE_LINE_PARAM); // ref count = 1;

    ptr->_OpenGLID = id;

    ObjectPtr<IOpenGLTexture2D> h = ObjectPtr<IOpenGLTexture2D> (ptr); // ref count = 2

    ptr->UnReference(); // ref count = 1

    return h;

    IOpenGLRectangleTexture *ptr;

    CreateRectangleTexture(Width, Height, Levels, PixelFormat, (IOpenGLRectangleTexture **) &ptr, NUX_FILE_LINE_PARAM);

    ObjectPtr<IOpenGLRectangleTexture> h = ObjectPtr<IOpenGLRectangleTexture> (ptr);

    ptr->UnReference();

    return h;

  }

 

  int GpuDevice::CreateRectangleTexture(

    unsigned int Width

    , unsigned int Height

    , unsigned int Levels

    , BitmapFormat PixelFormat

    , IOpenGLRectangleTexture **ppTexture

    , NUX_FILE_LINE_DECL

    )

  {

    if ((Width <= 0) || (Height <= 0))

      *ppTexture = NULL;

      return 0;

    // From : http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_non_power_of_two.txt

    //    The "floor" convention has a relatively straightforward way to

    //        evaluate(with integer math) means to determine how many mipmap

    //        levels are required for a complete pyramid:

    //    numLevels = 1 + floor(log2(max(w, h, d)))

    unsigned int NumTotalMipLevel    = 1 + floorf(Log2(Max(Width, Height)));

 

    //    Levels

    //        [in] Number of levels in the texture. If this is zero, generate all texture sublevels

    //        down to 1 by 1 pixels for hardware that supports mip-maps textures. Call GetNumMipLevel to see the

    //        number of levels generated.

      //Rectangle texture texture don't support mipmaps

    else if (Levels > NumTotalMipLevel)

 

    //    The "floor" convention can be evaluated incrementally with the

    //        following recursion:

    //

    //    nextLODdim = max(1, currentLODdim >> 1)

    //

    //        where currentLODdim is the dimension of a level N and nextLODdim

    //        is the dimension of level N+1.  The recursion stops when level

    //        numLevels-1 is reached.

 

    *ppTexture = new IOpenGLRectangleTexture(Width, Height, NumMipLevel, PixelFormat, false, NUX_FILE_LINE_PARAM);

 

 

    return 1;

    IOpenGLCubeTexture *ptr;

    CreateCubeTexture(EdgeLength, Levels, PixelFormat, (IOpenGLCubeTexture **) &ptr);

    ObjectPtr<IOpenGLCubeTexture> h = ObjectPtr<IOpenGLCubeTexture> (ptr);

    ptr->UnReference();

    return h;

  }

  int GpuDevice::CreateCubeTexture(

    unsigned int EdgeLength

    , unsigned int Levels

    , BitmapFormat PixelFormat

    , IOpenGLCubeTexture **ppCubeTexture

    , NUX_FILE_LINE_DECL

    )

  {

    unsigned int NumTotalMipLevel    = 1 + floorf(Log2(EdgeLength));

    //    Levels

    //        [in] Number of levels in the texture. If this is zero, Direct3D will generate all texture sublevels

    //        down to 1 by 1 pixels for hardware that supports mipmapped textures. Call GetNumMipLevel to see the

    //        number of levels generated.

    else if (Levels > NumTotalMipLevel)

    *ppCubeTexture = new IOpenGLCubeTexture(EdgeLength, NumMipLevel, PixelFormat);

 

    return 1;

    IOpenGLVolumeTexture *ptr;

    CreateVolumeTexture(Width, Height, Depth, Levels, PixelFormat, (IOpenGLVolumeTexture **) &ptr, NUX_FILE_LINE_PARAM);

    ObjectPtr<IOpenGLVolumeTexture> h = ObjectPtr<IOpenGLVolumeTexture> (ptr);

    ptr->UnReference();

    return h;

  }

  int GpuDevice::CreateVolumeTexture(

    unsigned int Width

    , unsigned int Height

    , unsigned int Depth

    , unsigned int Levels

    , BitmapFormat PixelFormat

    , IOpenGLVolumeTexture **ppVolumeTexture

    , NUX_FILE_LINE_DECL

    )

  {

    //    Levels

    //        [in] Number of levels in the texture. If this is zero, Direct3D will generate all texture sublevels

    //        down to 1 by 1 pixels for hardware that supports mipmapped textures. Call GetNumMipLevel to see the

    //        number of levels generated.

    else if (Levels > NumTotalMipLevel)

    *ppVolumeTexture = new IOpenGLVolumeTexture(Width, Height, Depth, NumMipLevel, PixelFormat);

 

    return OGL_OK;

    IOpenGLAnimatedTexture *ptr;

    CreateAnimatedTexture(Width, Height, Depth, PixelFormat, (IOpenGLAnimatedTexture **) &ptr);

    ObjectPtr<IOpenGLAnimatedTexture> h = ObjectPtr<IOpenGLAnimatedTexture> (ptr);

    ptr->UnReference();

    return h;

  }

 

  int GpuDevice::CreateAnimatedTexture(unsigned int Width,

    unsigned int Height,

    unsigned int Depth,

    BitmapFormat PixelFormat,

    IOpenGLAnimatedTexture **ppAnimatedTexture)

  {

    *ppAnimatedTexture = new IOpenGLAnimatedTexture(Width, Height, Depth, PixelFormat);

 

    return OGL_OK;

    IOpenGLQuery *ptr;

    CreateQuery(Type, (IOpenGLQuery **) &ptr);

    ObjectPtr<IOpenGLQuery> h = ObjectPtr<IOpenGLQuery> (ptr);

    ptr->UnReference();

    return h;

  }

 

  int GpuDevice::CreateQuery(QUERY_TYPE Type, IOpenGLQuery **ppQuery)

  {

    *ppQuery = new IOpenGLQuery(Type);

 

    return OGL_OK;