Michael Mc Donnell | 2 Mar 00:29 2015
Picon

Fixed clipping bug in osgtessellationshaders example

Hi Robert,

The tessellation shader example has a small bug.The middle of the
geometry is clipped as soon as it is tessellated. The clipping is
probably caused by rounding errors because it is only in one spot. The
clipping disappears when the camera is moved, and reappears when it is
moved back. Expanding the the bounding box fixed the clipping bug.

I have attached the fix as a patch file and the whole file itself.
Written against svn revision 14745.

Thank you,
Michael Mc Donnell
_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Ulrich Hertlein | 1 Mar 12:59 2015
Picon

GLDefines typo causing warnings on OS X


Hi Robert,

I believe there is a typo that is causing a 'already defined' compiler warnings on OS X
(clang):

--- a/include/osg/GLDefines
+++ b/include/osg/GLDefines
 <at>  <at>  -177,7 +177,7  <at>  <at>  typedef char GLchar;
 #define GL_FRAMEBUFFER_SRGB               0x8DB9
 #endif

-#ifndef EXT_geometry_shader4
+#ifndef GL_EXT_geometry_shader4
 #define GL_GEOMETRY_VERTICES_OUT_EXT            0x8DDA
 #define GL_GEOMETRY_INPUT_TYPE_EXT              0x8DDB
 #define GL_GEOMETRY_OUTPUT_TYPE_EXT             0x8DDC

Cheers,
/ulrich
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
 * Copyright (C) 2003-2005 3Dlabs Inc. Ltd.
 * Copyright (C) 2004-2005 Nathan Cournia
 * Copyright (C) 2007 Art Tevs
 * Copyright (C) 2008 Zebra Imaging
 * Copyright (C) 2010 VIRES Simulationstechnologie GmbH
 * Copyright (C) 2012 David Callu
 * Copyright (C) 2008 Mike Weiblen
(Continue reading)

Jannik Heller | 28 Feb 03:03 2015
Picon

Fix framerate dependent rotation in OrbitManipulator

Hi Robert,

I noticed the rotation in the OrbitManipulator depends on the framerate. To reproduce this issue, start
the osganimate example, rotate the model with the left mouse button, then let go of the mouse button while
still moving. You will notice that with V-Sync enabled, the model rotates slower.

The OrbitManipulator calculates a scale to counteract the framerate dependency, but it turns out this
scale wasn't used for the rotation yet.

I've attached the fix based against svn/trunk r14740.

Cheers,
Jannik

------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=62863#62863

_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Robert Osfield | 25 Feb 20:19 2015
Picon

Re: osgviewerQt example fix - parent and flags

Thanks Janathan, change merged and submitted to svn/trunk.

On 25 January 2015 at 01:09, Jonathan Greig <redteam316-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> wrote:
I was testing out the example and it works fine as a standalone example, but I found that it didn't work as expected when adding the class to some existing code I have to test it out. The osg widget was appearing but it didn't appear to be updating. After tweaking it to pass on the parent QWidget pointer from my code, it worked as expected. I added the WindowFlags to the attached file for good measure. If you look at the Qt Documentation for QWidget ( http://doc.qt.io/qt-5/qwidget.html#QWidget ), you'll see that is exactly where I got this from. When subclassing a widget as such, you should allow the user to pass in the parent at least, considering that has a major effect on how or if Qt may clean up the memory.

Anyway, its a simple fix.

Cheers,
Jonathan

_______________________________________________
osg-submissions mailing list
osg-submissions <at> lists.openscenegraph.org
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org


_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Miha Ravšelj | 22 Feb 22:53 2015
Picon

serializer bug in osgText::TextBase and osg::Camera

Hello,

I have been testing I/O operation on osgText::Text and I discovered that writing to osgt format does not work correctly due to invalid bit-wise comparison.

I checked all the serializers for similar user serializers and found that also osg::Camera has same bug in writeClearMask. I didn't found any other serializer but if there are any that you are aware of (beside TextBase and Camera) they should be checked as well.

The attached code in openscenegraph.zip resolves this issue in both serializers.

I have also attached BitFlagsSerializer.h as a proposal for serializing bit flags . If there are multiple bitflags that are serialized inside OSG then I believe it is better if system serializer is added and used instead of producing same or similar code in user serializer(s).

Miha
Attachment (BitFlagsSerializer.h): text/x-chdr, 6532 bytes
Attachment (openscenegraph.zip): application/zip, 6723 bytes
_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Michael Mc Donnell | 21 Feb 22:22 2015
Picon

Add plus and minus keys to tessellation shader example

Hi Robert,

There is no way to increase or decrease the tessellation evenly with
one key in the tessellation shader example. I expected that pressing
plus would increase both the inner and outer tessellation at the same
time. Instead I have to press up arrow and then right arrow. There is
no way to decrease the tessellation evenly either. I have to press
down arrow and then left arrow.

I have changed the code so that the plus key increases both the inner
and outer tessellation. The minus key decrease both the inner and
outer tessellation. You can still use the arrow keys to control inner
and outer tessellation separately.

I have tested it on Windows 8.1. The arrow keys still work the same way.

Base version is 14689.

Thank you,
Michael Mc Donnell
_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Sebastian Messerschmidt | 18 Feb 10:57 2015
Picon
Picon

Silencing ReaderWriterDDS

Hi Robert,

Attached you find a version of the ReaderWriterDDS with info outputs set 
to OSG_INFO instead of OSG_NOTICE. The old version spams the console for 
each loaded DDS file.
The changes are based on the trunk version.
/**********************************************************************
*
*    FILE:            ReaderWriterdds.cpp
*
*    DESCRIPTION:    Class for reading a DDS file into an osg::Image.
*
*                    Example on reading a DDS file code can be found at:
*                    http://developer.nvidia.com/docs/IO/1327/ATT/
*                    ARB_texture_compression.pdf
*                    Author: Sebastien Domine, NVIDIA Corporation
*
*    CREATED BY:     Rune Schmidt Jensen, rsj <at> uni-dk
*
*    HISTORY:        Created   31.03.2003
*             Modified  13.05.2004
*                by George Tarantilis, gtaranti <at> nps.navy.mil
*             Modified  22.05.2009
*                Wojtek Lewandowski, lewandowski <at> ai.com.pl
*
*    WARNING:
*          Bit Masks in the WrtiteDDS are set for 8 bit components
*          write with 4 or 16 bit components will
*          probably produce corrupted file
*          Wojtek Lewandowski 2009-05-22
*
**********************************************************************/
#include <osg/Texture>
#include <osg/Notify>

#include <osgDB/Registry>
#include <osgDB/FileNameUtils>
#include <osgDB/FileUtils>
#include <osgDB/fstream>
#include <iomanip>
#include <stdio.h>
#include <string.h>

// Macro similar to what's in FLT/TRP plugins (except it uses wide char under Windows if OSG_USE_UTF8_FILENAME)
#if defined(_WIN32)
    #include <windows.h>
    #include <osg/Config>
    #include <osgDB/ConvertUTF>
    #ifdef OSG_USE_UTF8_FILENAME
        #define DELETEFILE(file) DeleteFileW(osgDB::convertUTF8toUTF16((file)).c_str())
    #else
        #define DELETEFILE(file) DeleteFileA((file))
    #endif

#else   // Unix

    #include <stdio.h>
    #define DELETEFILE(file) remove((file))

#endif

#if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE)
    #define GL_RED                  0x1903
    #define GL_LUMINANCE4_ALPHA4    0x8043
#endif

#if defined(OSG_GL3_AVAILABLE)
    #define GL_LUMINANCE4_ALPHA4    0x8043
#endif

// NOTICE ON WIN32:
// typedef DWORD unsigned long;
// sizeof(DWORD) = 4

typedef unsigned int UI32;
typedef int I32;

struct  DDCOLORKEY
{
    DDCOLORKEY():
        dwColorSpaceLowValue(0),
        dwColorSpaceHighValue(0) {}

    UI32    dwColorSpaceLowValue;
    UI32    dwColorSpaceHighValue;
};

struct DDPIXELFORMAT
{

    DDPIXELFORMAT():
        dwSize(0),
        dwFlags(0),
        dwFourCC(0),
        dwRGBBitCount(0),
        dwRBitMask(0),
        dwGBitMask(0),
        dwBBitMask(0),
        dwRGBAlphaBitMask(0) {}


    UI32    dwSize;
    UI32    dwFlags;
    UI32    dwFourCC;
    union
    {
        UI32    dwRGBBitCount;
        UI32    dwYUVBitCount;
        UI32    dwZBufferBitDepth;
        UI32    dwAlphaBitDepth;
        UI32    dwLuminanceBitDepth;
    };
    union
    {
        UI32    dwRBitMask;
        UI32    dwYBitMask;
    };
    union
    {
        UI32    dwGBitMask;
        UI32    dwUBitMask;
    };
    union
    {
        UI32    dwBBitMask;
        UI32    dwVBitMask;
    };
    union
    {
        UI32    dwRGBAlphaBitMask;
        UI32    dwYUVAlphaBitMask;
        UI32    dwRGBZBitMask;
        UI32    dwYUVZBitMask;
    };
};

struct  DDSCAPS2
{
     DDSCAPS2():
        dwCaps(0),
        dwCaps2(0),
        dwCaps3(0),
        dwCaps4(0) {}

    UI32       dwCaps;
    UI32       dwCaps2;
    UI32       dwCaps3;
    union
    {
        UI32       dwCaps4;
        UI32       dwVolumeDepth;
    };
};

struct DDSURFACEDESC2
{
    DDSURFACEDESC2():
        dwSize(0),
        dwFlags(0),
        dwHeight(0),
        dwWidth(0),
        lPitch(0),
        dwBackBufferCount(0),
        dwMipMapCount(0),
        dwAlphaBitDepth(0),
        dwReserved(0),
        lpSurface(0),
        dwTextureStage(0) {}


    UI32         dwSize;
    UI32         dwFlags;
    UI32         dwHeight;
    UI32         dwWidth;
    union
    {
        I32              lPitch;
        UI32     dwLinearSize;
    };
    union
    {
        UI32      dwBackBufferCount;
        UI32      dwDepth;
    };
    union
    {
        UI32     dwMipMapCount;
        UI32     dwRefreshRate;
    };
    UI32         dwAlphaBitDepth;
    UI32         dwReserved;
    UI32        lpSurface;         //Fred Marmond: removed from pointer type to UI32 for 64bits compatibility. it is unused data
    DDCOLORKEY    ddckCKDestOverlay;
    DDCOLORKEY    ddckCKDestBlt;
    DDCOLORKEY    ddckCKSrcOverlay;
    DDCOLORKEY    ddckCKSrcBlt;
    DDPIXELFORMAT ddpfPixelFormat;
    DDSCAPS2      ddsCaps;
    UI32 dwTextureStage;
};

//
// Structure of a DXT-1 compressed texture block
// see page "Opaque and 1-Bit Alpha Textures (Direct3D 9)" on http://msdn.microsoft.com
// url at time of writing http://msdn.microsoft.com/en-us/library/bb147243(v=VS.85).aspx
//
struct DXT1TexelsBlock
{
    unsigned short color_0;     // colors at their
    unsigned short color_1;     // extreme
    unsigned int   texels4x4;   // interpolated colors (2 bits per texel)
};

//
// DDSURFACEDESC2 flags that mark the validity of the struct data
//
#define DDSD_CAPS               0x00000001l     // default
#define DDSD_HEIGHT             0x00000002l        // default
#define DDSD_WIDTH              0x00000004l        // default
#define DDSD_PIXELFORMAT        0x00001000l        // default
#define DDSD_PITCH              0x00000008l     // For uncompressed formats
#define DDSD_MIPMAPCOUNT        0x00020000l
#define DDSD_LINEARSIZE         0x00080000l     // For compressed formats
#define DDSD_DEPTH              0x00800000l        // Volume Textures

//
// DDPIXELFORMAT flags
//
#define DDPF_ALPHAPIXELS        0x00000001l
#define DDPF_FOURCC             0x00000004l        // Compressed formats
#define DDPF_RGB                0x00000040l        // Uncompressed formats
#define DDPF_ALPHA              0x00000002l
#define DDPF_COMPRESSED         0x00000080l
#define DDPF_LUMINANCE          0x00020000l
#define DDPF_BUMPLUMINANCE      0x00040000l        // L,U,V
#define DDPF_BUMPDUDV           0x00080000l        // U,V

//
// DDSCAPS flags
//
#define DDSCAPS_TEXTURE         0x00001000l     // default
#define DDSCAPS_COMPLEX         0x00000008l
#define DDSCAPS_MIPMAP          0x00400000l
#define DDSCAPS2_VOLUME         0x00200000l


#ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
    ((UI32)(char)(ch0) | ((UI32)(char)(ch1) << 8) |   \
    ((UI32)(char)(ch2) << 16) | ((UI32)(char)(ch3) << 24 ))
#endif //defined(MAKEFOURCC)

/*
* FOURCC codes for DX compressed-texture pixel formats
*/
#define FOURCC_DXT1  (MAKEFOURCC('D','X','T','1'))
#define FOURCC_DXT2  (MAKEFOURCC('D','X','T','2'))
#define FOURCC_DXT3  (MAKEFOURCC('D','X','T','3'))
#define FOURCC_DXT4  (MAKEFOURCC('D','X','T','4'))
#define FOURCC_DXT5  (MAKEFOURCC('D','X','T','5'))

/*
* FOURCC codes for 3dc compressed-texture pixel formats
*/
#define FOURCC_ATI1  (MAKEFOURCC('A','T','I','1'))
#define FOURCC_ATI2  (MAKEFOURCC('A','T','I','2'))

/*
* FOURCC codes for DX10 files
*/
#define FOURCC_DX10  (MAKEFOURCC('D','X','1','0'))

typedef enum OSG_DXGI_FORMAT {
  OSG_DXGI_FORMAT_UNKNOWN                     = 0,
  OSG_DXGI_FORMAT_R32G32B32A32_TYPELESS       = 1,
  OSG_DXGI_FORMAT_R32G32B32A32_FLOAT          = 2,
  OSG_DXGI_FORMAT_R32G32B32A32_UINT           = 3,
  OSG_DXGI_FORMAT_R32G32B32A32_SINT           = 4,
  OSG_DXGI_FORMAT_R32G32B32_TYPELESS          = 5,
  OSG_DXGI_FORMAT_R32G32B32_FLOAT             = 6,
  OSG_DXGI_FORMAT_R32G32B32_UINT              = 7,
  OSG_DXGI_FORMAT_R32G32B32_SINT              = 8,
  OSG_DXGI_FORMAT_R16G16B16A16_TYPELESS       = 9,
  OSG_DXGI_FORMAT_R16G16B16A16_FLOAT          = 10,
  OSG_DXGI_FORMAT_R16G16B16A16_UNORM          = 11,
  OSG_DXGI_FORMAT_R16G16B16A16_UINT           = 12,
  OSG_DXGI_FORMAT_R16G16B16A16_SNORM          = 13,
  OSG_DXGI_FORMAT_R16G16B16A16_SINT           = 14,
  OSG_DXGI_FORMAT_R32G32_TYPELESS             = 15,
  OSG_DXGI_FORMAT_R32G32_FLOAT                = 16,
  OSG_DXGI_FORMAT_R32G32_UINT                 = 17,
  OSG_DXGI_FORMAT_R32G32_SINT                 = 18,
  OSG_DXGI_FORMAT_R32G8X24_TYPELESS           = 19,
  OSG_DXGI_FORMAT_D32_FLOAT_S8X24_UINT        = 20,
  OSG_DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS    = 21,
  OSG_DXGI_FORMAT_X32_TYPELESS_G8X24_UINT     = 22,
  OSG_DXGI_FORMAT_R10G10B10A2_TYPELESS        = 23,
  OSG_DXGI_FORMAT_R10G10B10A2_UNORM           = 24,
  OSG_DXGI_FORMAT_R10G10B10A2_UINT            = 25,
  OSG_DXGI_FORMAT_R11G11B10_FLOAT             = 26,
  OSG_DXGI_FORMAT_R8G8B8A8_TYPELESS           = 27,
  OSG_DXGI_FORMAT_R8G8B8A8_UNORM              = 28,
  OSG_DXGI_FORMAT_R8G8B8A8_UNORM_SRGB         = 29,
  OSG_DXGI_FORMAT_R8G8B8A8_UINT               = 30,
  OSG_DXGI_FORMAT_R8G8B8A8_SNORM              = 31,
  OSG_DXGI_FORMAT_R8G8B8A8_SINT               = 32,
  OSG_DXGI_FORMAT_R16G16_TYPELESS             = 33,
  OSG_DXGI_FORMAT_R16G16_FLOAT                = 34,
  OSG_DXGI_FORMAT_R16G16_UNORM                = 35,
  OSG_DXGI_FORMAT_R16G16_UINT                 = 36,
  OSG_DXGI_FORMAT_R16G16_SNORM                = 37,
  OSG_DXGI_FORMAT_R16G16_SINT                 = 38,
  OSG_DXGI_FORMAT_R32_TYPELESS                = 39,
  OSG_DXGI_FORMAT_D32_FLOAT                   = 40,
  OSG_DXGI_FORMAT_R32_FLOAT                   = 41,
  OSG_DXGI_FORMAT_R32_UINT                    = 42,
  OSG_DXGI_FORMAT_R32_SINT                    = 43,
  OSG_DXGI_FORMAT_R24G8_TYPELESS              = 44,
  OSG_DXGI_FORMAT_D24_UNORM_S8_UINT           = 45,
  OSG_DXGI_FORMAT_R24_UNORM_X8_TYPELESS       = 46,
  OSG_DXGI_FORMAT_X24_TYPELESS_G8_UINT        = 47,
  OSG_DXGI_FORMAT_R8G8_TYPELESS               = 48,
  OSG_DXGI_FORMAT_R8G8_UNORM                  = 49,
  OSG_DXGI_FORMAT_R8G8_UINT                   = 50,
  OSG_DXGI_FORMAT_R8G8_SNORM                  = 51,
  OSG_DXGI_FORMAT_R8G8_SINT                   = 52,
  OSG_DXGI_FORMAT_R16_TYPELESS                = 53,
  OSG_DXGI_FORMAT_R16_FLOAT                   = 54,
  OSG_DXGI_FORMAT_D16_UNORM                   = 55,
  OSG_DXGI_FORMAT_R16_UNORM                   = 56,
  OSG_DXGI_FORMAT_R16_UINT                    = 57,
  OSG_DXGI_FORMAT_R16_SNORM                   = 58,
  OSG_DXGI_FORMAT_R16_SINT                    = 59,
  OSG_DXGI_FORMAT_R8_TYPELESS                 = 60,
  OSG_DXGI_FORMAT_R8_UNORM                    = 61,
  OSG_DXGI_FORMAT_R8_UINT                     = 62,
  OSG_DXGI_FORMAT_R8_SNORM                    = 63,
  OSG_DXGI_FORMAT_R8_SINT                     = 64,
  OSG_DXGI_FORMAT_A8_UNORM                    = 65,
  OSG_DXGI_FORMAT_R1_UNORM                    = 66,
  OSG_DXGI_FORMAT_R9G9B9E5_SHAREDEXP          = 67,
  OSG_DXGI_FORMAT_R8G8_B8G8_UNORM             = 68,
  OSG_DXGI_FORMAT_G8R8_G8B8_UNORM             = 69,
  OSG_DXGI_FORMAT_BC1_TYPELESS                = 70,
  OSG_DXGI_FORMAT_BC1_UNORM                   = 71,
  OSG_DXGI_FORMAT_BC1_UNORM_SRGB              = 72,
  OSG_DXGI_FORMAT_BC2_TYPELESS                = 73,
  OSG_DXGI_FORMAT_BC2_UNORM                   = 74,
  OSG_DXGI_FORMAT_BC2_UNORM_SRGB              = 75,
  OSG_DXGI_FORMAT_BC3_TYPELESS                = 76,
  OSG_DXGI_FORMAT_BC3_UNORM                   = 77,
  OSG_DXGI_FORMAT_BC3_UNORM_SRGB              = 78,
  OSG_DXGI_FORMAT_BC4_TYPELESS                = 79,
  OSG_DXGI_FORMAT_BC4_UNORM                   = 80,
  OSG_DXGI_FORMAT_BC4_SNORM                   = 81,
  OSG_DXGI_FORMAT_BC5_TYPELESS                = 82,
  OSG_DXGI_FORMAT_BC5_UNORM                   = 83,
  OSG_DXGI_FORMAT_BC5_SNORM                   = 84,
  OSG_DXGI_FORMAT_B5G6R5_UNORM                = 85,
  OSG_DXGI_FORMAT_B5G5R5A1_UNORM              = 86,
  OSG_DXGI_FORMAT_B8G8R8A8_UNORM              = 87,
  OSG_DXGI_FORMAT_B8G8R8X8_UNORM              = 88,
  OSG_DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM  = 89,
  OSG_DXGI_FORMAT_B8G8R8A8_TYPELESS           = 90,
  OSG_DXGI_FORMAT_B8G8R8A8_UNORM_SRGB         = 91,
  OSG_DXGI_FORMAT_B8G8R8X8_TYPELESS           = 92,
  OSG_DXGI_FORMAT_B8G8R8X8_UNORM_SRGB         = 93,
  OSG_DXGI_FORMAT_BC6H_TYPELESS               = 94,
  OSG_DXGI_FORMAT_BC6H_UF16                   = 95,
  OSG_DXGI_FORMAT_BC6H_SF16                   = 96,
  OSG_DXGI_FORMAT_BC7_TYPELESS                = 97,
  OSG_DXGI_FORMAT_BC7_UNORM                   = 98,
  OSG_DXGI_FORMAT_BC7_UNORM_SRGB              = 99,
  OSG_DXGI_FORMAT_AYUV                        = 100,
  OSG_DXGI_FORMAT_Y410                        = 101,
  OSG_DXGI_FORMAT_Y416                        = 102,
  OSG_DXGI_FORMAT_NV12                        = 103,
  OSG_DXGI_FORMAT_P010                        = 104,
  OSG_DXGI_FORMAT_P016                        = 105,
  OSG_DXGI_FORMAT_420_OPAQUE                  = 106,
  OSG_DXGI_FORMAT_YUY2                        = 107,
  OSG_DXGI_FORMAT_Y210                        = 108,
  OSG_DXGI_FORMAT_Y216                        = 109,
  OSG_DXGI_FORMAT_NV11                        = 110,
  OSG_DXGI_FORMAT_AI44                        = 111,
  OSG_DXGI_FORMAT_IA44                        = 112,
  OSG_DXGI_FORMAT_P8                          = 113,
  OSG_DXGI_FORMAT_A8P8                        = 114,
  OSG_DXGI_FORMAT_B4G4R4A4_UNORM              = 115,
  OSG_DXGI_FORMAT_FORCE_UINT                  = 0xffffffffUL
} OSG_DXGI_FORMAT;

typedef enum OSG_D3D10_RESOURCE_DIMENSION {
  OSG_D3D10_RESOURCE_DIMENSION_UNKNOWN    = 0,
  OSG_D3D10_RESOURCE_DIMENSION_BUFFER     = 1,
  OSG_D3D10_RESOURCE_DIMENSION_TEXTURE1D  = 2,
  OSG_D3D10_RESOURCE_DIMENSION_TEXTURE2D  = 3,
  OSG_D3D10_RESOURCE_DIMENSION_TEXTURE3D  = 4
} OSG_D3D10_RESOURCE_DIMENSION;

typedef struct {
  OSG_DXGI_FORMAT              dxgiFormat;
  OSG_D3D10_RESOURCE_DIMENSION resourceDimension;
  UI32                     miscFlag;
  UI32                     arraySize;
  UI32                     reserved;
} OSG_DDS_HEADER_DXT10;

static unsigned int ComputeImageSizeInBytes( int width, int height, int depth,
                                             unsigned int pixelFormat, unsigned int pixelType,
                                             int packing = 1, int slice_packing = 1, int image_packing = 1 )
{
    if( width < 1 )  width = 1;
    if( height < 1 ) height = 1;
    if( depth < 1 )  depth = 1;

    return osg::Image::computeImageSizeInBytes(width, height, depth, pixelFormat, pixelType, packing, slice_packing, image_packing);
}

osg::Image* ReadDDSFile(std::istream& _istream, bool flipDDSRead)
{
    DDSURFACEDESC2 ddsd;

    char filecode[4];

    _istream.read(filecode, 4);
    if (strncmp(filecode, "DDS ", 4) != 0) {
        return NULL;
    }
    // Get the surface desc.
    _istream.read((char*)(&ddsd), sizeof(ddsd));

    osg::ref_ptr<osg::Image> osgImage = new osg::Image();

    //Check valid structure sizes
    if(ddsd.dwSize != 124 && ddsd.ddpfPixelFormat.dwSize != 32)
    {
        return NULL;
    }

    int depth = 1;

    // Check for volume image
    if( ddsd.dwDepth > 0 && (ddsd.dwFlags & DDSD_DEPTH))
    {
        depth = ddsd.dwDepth;
    }

    // Retreive image properties.
    int s = ddsd.dwWidth;
    int t = ddsd.dwHeight;
    int r = depth;
    unsigned int dataType = GL_UNSIGNED_BYTE;
    unsigned int pixelFormat = 0;
    unsigned int internalFormat = 0;

    // Handle some esoteric formats
    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPDUDV)
    {
        OSG_WARN << "ReadDDSFile warning: DDPF_BUMPDUDV format is not supported" << std::endl;
        return NULL;
//         ddsd.ddpfPixelFormat.dwFlags =
//             DDPF_LUMINANCE + DDPF_ALPHAPIXELS;
//         // handle V8U8 as A8L8
//         // handle V16U16 as A16L16
//         // but Q8W8U8L8 as RGB?
//         // A2W10U10V10 as RGBA (dwFlags == DDPF_BUMPDUDV + DDPF_ALPHAPIXELS)
    }
    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPLUMINANCE)
    {
        OSG_WARN << "ReadDDSFile warning: DDPF_BUMPLUMINANCE format is not supported" << std::endl;
        return NULL;
//         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
//         // handle as RGB
//         // L6V5U5 -- 655 is not supported data type in GL
//         // X8L8V8U8 -- just as RGB
    }

    // Uncompressed formats will usually use DDPF_RGB to indicate an RGB format,
    // while compressed formats will use DDPF_FOURCC with a four-character code.

    bool usingAlpha = ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS;
    int packing(1);
    bool isDXTC(false);

    // Uncompressed formats.
    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB)
    {
        struct RGBFormat
        {
                const char*  name;
                UI32         bitCount;
                UI32         rBitMask;
                UI32         gBitMask;
                UI32         bBitMask;
                UI32         aBitMask;
                unsigned int internalFormat;
                unsigned int pixelFormat;
                unsigned int dataType;
        };

        const unsigned int UNSUPPORTED = 0;

        static const RGBFormat rgbFormats[] =
        {
            { "R3G3B2"     ,  8,       0xe0,       0x1c,       0x03,       0x00,
              GL_RGB , GL_RGB , GL_UNSIGNED_BYTE_3_3_2 },

            { "R5G6B5"     , 16,     0xf800,     0x07e0,     0x001f,     0x0000,
              GL_RGB , GL_RGB , GL_UNSIGNED_SHORT_5_6_5 },
            { "A1R5G5B5"   , 16,     0x7c00,     0x03e0,     0x001f,     0x8000,
              GL_RGBA, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV },
            { "X1R5G5B5"   , 16,     0x7c00,     0x03e0,     0x001f,     0x0000,
              GL_RGB , GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV },
            { "A4R4G4B4"   , 16,     0x0f00,     0x00f0,     0x000f,     0xf000,
              GL_RGBA, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV },
            { "X4R4G4B4"   , 16,     0x0f00,     0x00f0,     0x000f,     0x0000,
              GL_RGB , GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV },
            { "A8R3G3B2"   , 16,     0x00e0,     0x001c,     0x0003,     0xff00,
              GL_RGBA, GL_BGRA, UNSUPPORTED },

            { "R8G8B8",      24,   0xff0000,   0x00ff00,   0x0000ff,   0x000000,
              GL_RGB , GL_BGR , GL_UNSIGNED_BYTE },

            { "B8G8R8",      24,   0x0000ff,   0x00ff00,   0xff0000,   0x000000,
              GL_RGB , GL_RGB , GL_UNSIGNED_BYTE },

            { "A8R8G8B8",    32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000,
              GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE },
            { "X8R8G8B8",    32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000,
              GL_RGB , GL_BGRA, GL_UNSIGNED_BYTE },
            { "A8B8G8R8",    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000,
              GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE },
            { "X8B8G8R8",    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000,
              GL_RGB , GL_RGBA, GL_UNSIGNED_BYTE },
            { "A2R10G10B10", 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000,
              GL_RGBA, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV },
            { "A2B10G10R10", 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000,
              GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV },
            { "G16R16",      32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000,
              GL_RGB, UNSUPPORTED, GL_UNSIGNED_SHORT },
        };

        bool found = false;

        for ( unsigned int i = 0; i < sizeof ( rgbFormats ) / sizeof ( RGBFormat ); i++ )
        {
            const RGBFormat& f = rgbFormats[ i ];
            if ( ddsd.ddpfPixelFormat.dwRGBBitCount     == f.bitCount &&
                 ddsd.ddpfPixelFormat.dwRBitMask        == f.rBitMask &&
                 ddsd.ddpfPixelFormat.dwGBitMask        == f.gBitMask &&
                 ddsd.ddpfPixelFormat.dwBBitMask        == f.bBitMask &&
                 ddsd.ddpfPixelFormat.dwRGBAlphaBitMask == f.aBitMask )
            {
                if ( f.internalFormat != UNSUPPORTED &&
                     f.pixelFormat    != UNSUPPORTED &&
                     f.dataType       != UNSUPPORTED )
                {
                    OSG_INFO << "ReadDDSFile info : format = " << f.name << std::endl;
                    internalFormat = f.internalFormat;
                    pixelFormat    = f.pixelFormat;
                    dataType       = f.dataType;
                    found = true;
                    break;
                }
                else
                {
                    OSG_INFO << "ReadDDSFile info : " << f.name
                                           << " format is not supported" << std::endl;
                    return NULL;
                }
            }
        }

        if ( !found )
        {
            OSG_WARN << "ReadDDSFile warning: unhandled RGB pixel format in dds file, image not loaded" << std::endl;
            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRGBBitCount     = "
                                   << ddsd.ddpfPixelFormat.dwRGBBitCount << std::endl;
            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRBitMask        = 0x"
                                   << std::hex << std::setw(8) << std::setfill('0')
                                   << ddsd.ddpfPixelFormat.dwRBitMask << std::endl;
            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwGBitMask        = 0x"
                                   << std::hex << std::setw(8) << std::setfill('0')
                                   << ddsd.ddpfPixelFormat.dwGBitMask << std::endl;
            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwBBitMask        = 0x"
                                   << std::hex << std::setw(8) << std::setfill('0')
                                   << ddsd.ddpfPixelFormat.dwBBitMask << std::endl;
            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0x"
                                   << std::hex << std::setw(8) << std::setfill('0')
                                   << ddsd.ddpfPixelFormat.dwRGBAlphaBitMask << std::dec << std::endl;
            return NULL;
        }
    }
    else if(ddsd.ddpfPixelFormat.dwFlags & DDPF_LUMINANCE)
    {
            internalFormat = usingAlpha ? GL_LUMINANCE_ALPHA : GL_LUMINANCE;
            pixelFormat    = usingAlpha ? GL_LUMINANCE_ALPHA : GL_LUMINANCE;
            if ( usingAlpha && ddsd.ddpfPixelFormat.dwLuminanceBitDepth == 8 )
            {
                OSG_INFO << "ReadDDSFile info : format = L4A4" << std::endl;
                pixelFormat = GL_LUMINANCE4_ALPHA4; // invalid enumerant?
            }
            else if ( usingAlpha && ddsd.ddpfPixelFormat.dwLuminanceBitDepth == 32 )
            {
                OSG_INFO << "ReadDDSFile info : format = L16A16" << std::endl;
                dataType = GL_UNSIGNED_SHORT;
            }
            else if ( !usingAlpha && ddsd.ddpfPixelFormat.dwLuminanceBitDepth == 16 )
            {
                OSG_INFO << "ReadDDSFile info : format = L16" << std::endl;
                dataType = GL_UNSIGNED_SHORT;
            }
            else if ( usingAlpha )
            {
                OSG_INFO << "ReadDDSFile info : format = L8A8" << std::endl;
            }
            else
            {
                OSG_INFO << "ReadDDSFile info : format = L8" << std::endl;
            }
//             else if ( ddsd.ddpfPixelFormat.dwLuminanceBitDepth == (usingAlpha ? 64 : 32) )
//             {
//                 dataType = GL_UNSIGNED_INT;
//             }
    }
    else if(ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHA)
    {
            OSG_INFO << "ReadDDSFile info : format = ALPHA" << std::endl;
            internalFormat = GL_ALPHA;
            pixelFormat    = GL_ALPHA;
    }
    // Compressed formats
    else if(ddsd.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
    {
        switch(ddsd.ddpfPixelFormat.dwFourCC)
        {
        case FOURCC_DXT1:
            OSG_INFO << "ReadDDSFile info : format = DXT1, usingAlpha=" <<usingAlpha<< std::endl;
            if (usingAlpha)
            {
                internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
                pixelFormat    = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
            }
            else
            {
                internalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
                pixelFormat    = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
            }
            packing = 2;        // 4 bits/pixel. 4 px = 2 bytes
            isDXTC = true;
            break;
        case FOURCC_DXT3:
            OSG_INFO << "ReadDDSFile info : format = DXT3" << std::endl;
            internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
            pixelFormat    = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
            packing = 4;        // 8 bits/pixel. 4 px = 4 bytes
            isDXTC = true;
            break;
        case FOURCC_DXT5:
            OSG_INFO << "ReadDDSFile info : format = DXT5" << std::endl;
            internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
            pixelFormat    = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
            packing = 4;        // 8 bits/pixel. 4 px = 4 bytes
            isDXTC = true;
            break;
        case FOURCC_ATI1:
            OSG_INFO << "ReadDDSFile info : format = ATI1" << std::endl;
            internalFormat = GL_COMPRESSED_RED_RGTC1_EXT;
            pixelFormat    = GL_COMPRESSED_RED_RGTC1_EXT;
            break;
        case FOURCC_ATI2:
            OSG_INFO << "ReadDDSFile info : format = ATI2" << std::endl;
            internalFormat = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
            pixelFormat    = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
            break;
        case 0x00000024: // A16B16G16R16
            OSG_INFO << "ReadDDSFile info : format = A16B16G16R16" << std::endl;
            internalFormat = GL_RGBA;
            pixelFormat    = GL_RGBA;
            dataType       = GL_UNSIGNED_SHORT;
            break;
        case 0x00000071: // A16B16G16R16F
            OSG_INFO << "ReadDDSFile info : format = A16B16G16R16F" << std::endl;
            internalFormat = GL_RGBA; // why no transparency?
            pixelFormat    = GL_RGBA;
            dataType       = GL_HALF_FLOAT;
            break;
        case 0x0000006E: // Q16W16V16U16
            OSG_INFO << "ReadDDSFile info : format = Q16W16V16U16" << std::endl;
            internalFormat = GL_RGBA;
            pixelFormat    = GL_RGBA;
            dataType       = GL_UNSIGNED_SHORT;
            break;
        case 0x00000070: // G16R16F
            OSG_INFO << "ReadDDSFile info : G16R16F format is not supported"
                                   << std::endl;
            return NULL;
//             internalFormat = GL_RGB;
//             pixelFormat    = must be GL_RED and GL_GREEN
//             dataType       = GL_HALF_FLOAT;
            break;
        case 0x00000073: // G32R32F
            OSG_INFO << "ReadDDSFile info : G32R32F format is not supported"
                                   << std::endl;
            return NULL;
//             internalFormat = GL_RGB;
//             pixelFormat    = must be GL_RED and GL_GREEN
//             dataType       = GL_FLOAT;
            break;
        case 0x00000072: // R32F
            OSG_INFO << "ReadDDSFile info : format = R32F" << std::endl;
            internalFormat = GL_RGB;
            pixelFormat    = GL_RED;
            dataType       = GL_FLOAT;
            break;
        case 0x0000006F: // R16F
            OSG_INFO << "ReadDDSFile info : format = R16F" << std::endl;
            internalFormat = GL_RGB;
            pixelFormat    = GL_RED;
            dataType       = GL_HALF_FLOAT;
            break;
        case 0x00000074: // A32B32G32R32F
            OSG_INFO << "ReadDDSFile info : format = A32B32G32R32F" << std::endl;
            internalFormat = GL_RGBA;
            pixelFormat    = GL_RGBA;
            dataType       = GL_FLOAT;
            break;
        case 0x00000075: // CxV8U8
            OSG_INFO << "ReadDDSFile info : CxV8U8 format is not supported" << std::endl;
            return NULL;

        case FOURCC_DX10:
            OSG_INFO << "ReadDDSFile info : format = DX10 file" << std::endl;
            {
                OSG_DDS_HEADER_DXT10 header10;
                _istream.read((char*)(&header10), sizeof(header10));
                switch (header10.dxgiFormat) {
                case OSG_DXGI_FORMAT_R32G32B32A32_FLOAT:
                    internalFormat = GL_RGBA32F_ARB;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R32G32B32A32_UINT:
                    internalFormat = GL_RGBA32UI_EXT;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_UNSIGNED_INT;
                    break;

                case OSG_DXGI_FORMAT_R32G32B32A32_SINT:
                    internalFormat = GL_RGBA32I_EXT;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_INT;
                    break;

                case OSG_DXGI_FORMAT_R32G32B32_FLOAT:
                    internalFormat = GL_RGB32F_ARB;
                    pixelFormat    = GL_RGB;
                    dataType       = GL_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R32G32B32_UINT:
                    internalFormat = GL_RGB32UI_EXT;
                    pixelFormat    = GL_RGB;
                    dataType       = GL_UNSIGNED_INT;
                    break;

                case OSG_DXGI_FORMAT_R32G32B32_SINT:
                    internalFormat = GL_RGB32I_EXT;
                    pixelFormat    = GL_RGB;
                    dataType       = GL_INT;
                    break;

                case OSG_DXGI_FORMAT_R16G16B16A16_FLOAT:
                    internalFormat = GL_RGBA16F_ARB;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_HALF_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R16G16B16A16_UNORM:
                    internalFormat = GL_RGBA16;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_UNSIGNED_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16G16B16A16_UINT:
                    internalFormat = GL_RGBA16UI_EXT;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_UNSIGNED_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16G16B16A16_SNORM:
                    internalFormat = GL_RGBA16_SNORM;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16G16B16A16_SINT:
                    internalFormat = GL_RGBA16I_EXT;
                    pixelFormat    = GL_RGBA;
                    dataType       = GL_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R32G32_FLOAT:
                    internalFormat = GL_RG32F;
                    pixelFormat    = GL_RG;
                    dataType       = GL_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R32G32_UINT:
                    internalFormat = GL_RG32UI;
                    pixelFormat    = GL_RG;
                    dataType       = GL_UNSIGNED_INT;
                    break;

                case OSG_DXGI_FORMAT_R32G32_SINT:
                    internalFormat = GL_RG32I;
                    pixelFormat    = GL_RG;
                    dataType       = GL_INT;
                    break;

                case OSG_DXGI_FORMAT_R16G16_FLOAT:
                    internalFormat = GL_RG16F;
                    pixelFormat    = GL_RG;
                    dataType       = GL_HALF_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R16G16_UNORM:
                    internalFormat = GL_RG16;
                    pixelFormat    = GL_RG;
                    dataType       = GL_UNSIGNED_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16G16_UINT:
                    internalFormat = GL_RG16UI;
                    pixelFormat    = GL_RG;
                    dataType       = GL_UNSIGNED_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16G16_SNORM:
                    internalFormat = GL_RG16_SNORM;
                    pixelFormat    = GL_RG;
                    dataType       = GL_UNSIGNED_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16G16_SINT:
                    internalFormat = GL_RG16I;
                    pixelFormat    = GL_RG;
                    dataType       = GL_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R32_FLOAT:
                    internalFormat = GL_R32F;
                    pixelFormat    = GL_RED;
                    dataType       = GL_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R32_UINT:
                    internalFormat = GL_R32UI;
                    pixelFormat    = GL_RED;
                    dataType       = GL_UNSIGNED_INT;
                    break;

                case OSG_DXGI_FORMAT_R32_SINT:
                    internalFormat = GL_R32I;
                    pixelFormat    = GL_RED;
                    dataType       = GL_INT;
                    break;

                case OSG_DXGI_FORMAT_R8G8_UNORM:
                    internalFormat = GL_RG;
                    pixelFormat    = GL_RG;
                    dataType       = GL_UNSIGNED_BYTE;
                    break;

                case OSG_DXGI_FORMAT_R8G8_UINT:
                    internalFormat = GL_RG8UI;
                    pixelFormat    = GL_RG;
                    dataType       = GL_UNSIGNED_BYTE;
                    break;

                case OSG_DXGI_FORMAT_R8G8_SNORM:
                    internalFormat = GL_RG_SNORM;
                    pixelFormat    = GL_RG;
                    dataType       = GL_BYTE;
                    break;

                case OSG_DXGI_FORMAT_R8G8_SINT:
                    internalFormat = GL_RG8I;
                    pixelFormat    = GL_RG;
                    dataType       = GL_BYTE;
                    break;

                case OSG_DXGI_FORMAT_R16_FLOAT:
                    internalFormat = GL_R16F;
                    pixelFormat    = GL_RED;
                    dataType       = GL_HALF_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R16_UNORM:
                    internalFormat = GL_RED;
                    pixelFormat    = GL_RED;
                    dataType       = GL_HALF_FLOAT;
                    break;

                case OSG_DXGI_FORMAT_R16_UINT:
                    internalFormat = GL_R16UI;
                    pixelFormat    = GL_RED;
                    dataType       = GL_UNSIGNED_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16_SNORM:
                    internalFormat = GL_RED_SNORM;
                    pixelFormat    = GL_RED;
                    dataType       = GL_SHORT;
                    break;

                case OSG_DXGI_FORMAT_R16_SINT:
                    internalFormat = GL_R16I;
                    pixelFormat    = GL_RED;
                    dataType       = GL_SHORT;
                    break;

                default:
                    OSG_WARN << "ReadDDSFile warning: unhandled DX10 pixel format 0x"
                             << std::hex << std::setw(8) << std::setfill('0')
                             << header10.dxgiFormat << std::dec
                             << " in dds file, image not loaded." << std::endl;
                    return NULL;
                }
            }
            break;

        case MAKEFOURCC( 'U', 'Y', 'V', 'Y' ): // not supported in OSG
        case MAKEFOURCC( 'U', 'Y', 'V', '2' ): // not supported in OSG
        case MAKEFOURCC( 'R', 'G', 'B', 'G' ): // R8G8_B8G8 -- what is it?
        case MAKEFOURCC( 'G', 'R', 'G', 'B' ): // G8R8_G8B8 -- what is it?
            //break;

        default:
            OSG_WARN << "ReadDDSFile warning: unhandled FOURCC pixel format ("
                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0x000000ff))
                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0x0000ff00) >> 8)
                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0x00ff0000) >> 16)
                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0xff000000) >> 24)
                                   << " = 0x" << std::hex << std::setw(8) << std::setfill('0')
                                   << ddsd.ddpfPixelFormat.dwFourCC << std::dec
                                   << ") in dds file, image not loaded." << std::endl;
            return NULL;
        }
    }
    else
    {
        OSG_WARN << "ReadDDSFile warning: unhandled pixel format (ddsd.ddpfPixelFormat.dwFlags"
                               << " = 0x" << std::hex << std::setw(8) << std::setfill('0')
                               << ddsd.ddpfPixelFormat.dwFlags << std::dec
                               << ") in dds file, image not loaded."<<std::endl;
        return NULL;
    }

    unsigned int size = ComputeImageSizeInBytes( s, t, r, pixelFormat, dataType, packing );

    // Take care of mipmaps if any.
    unsigned int sizeWithMipmaps = size;
    osg::Image::MipmapDataType mipmap_offsets;
    if ( ddsd.dwMipMapCount>1 )
    {
        unsigned numMipmaps = osg::Image::computeNumberOfMipmapLevels( s, t, r );
        if( numMipmaps > ddsd.dwMipMapCount ) numMipmaps = ddsd.dwMipMapCount;
        // array starts at 1 level offset, 0 level skipped
        mipmap_offsets.resize( numMipmaps - 1 );

        int width = s;
        int height = t;
        int depth = r;

        for( unsigned int k = 0; k < mipmap_offsets.size(); ++k  )
        {
           mipmap_offsets[k] = sizeWithMipmaps;

           width = osg::maximum( width >> 1, 1 );
           height = osg::maximum( height >> 1, 1 );
           depth = osg::maximum( depth >> 1, 1 );

           sizeWithMipmaps +=
                ComputeImageSizeInBytes( width, height, depth, pixelFormat, dataType, packing );
        }
    }

   OSG_INFO<<"ReadDDS, dataType = 0x"<<std::hex<<dataType<<std::endl;

    unsigned char* imageData = new unsigned char [sizeWithMipmaps];
    if(!imageData)
    {
        OSG_WARN << "ReadDDSFile warning: imageData == NULL" << std::endl;
        return NULL;
    }

    // Read pixels in two chunks. First main image, next mipmaps.
    if ( !_istream.read( (char*)imageData, size ) )
    {
        delete [] imageData;
        OSG_WARN << "ReadDDSFile warning: couldn't read imageData" << std::endl;
        return NULL;
    }

    // If loading mipmaps in second chunk fails we may still use main image
    if ( size < sizeWithMipmaps && !_istream.read( (char*)imageData + size, sizeWithMipmaps - size ) )
    {
        sizeWithMipmaps = size;
        mipmap_offsets.resize( 0 );
        OSG_WARN << "ReadDDSFile warning: couldn't read mipmapData" << std::endl;

        // if mipmaps read failed we leave some not used overhead memory allocated past main image
        // this memory will not be used but it will not cause leak in worst meaning of this word.
    }

    osgImage->setImage(s,t,r, internalFormat, pixelFormat, dataType, imageData, osg::Image::USE_NEW_DELETE, packing);

    if (mipmap_offsets.size()>0) osgImage->setMipmapLevels(mipmap_offsets);

    if (flipDDSRead) {
        osgImage->setOrigin(osg::Image::BOTTOM_LEFT);
        if (!isDXTC || ((s>4 && s%4==0 && t>4 && t%4==0) || s<4))        // Flip may crash (access violation) or fail for non %4 dimensions (except for s<4). Tested with revision trunk 2013-02-22.
        {
            OSG_INFO<<"Flipping dds on load"<<std::endl;
            osgImage->flipVertical();
        }
        else
        {
            OSG_WARN << "ReadDDSFile warning: Vertical flip was skipped. Image dimensions have to be multiple of 4." << std::endl;
        }
    }

    // Return Image.
    return osgImage.release();
}

bool WriteDDSFile(const osg::Image *img, std::ostream& fout, bool autoFlipDDSWrite)
{
    bool isDXTC(false);

    // Initialize ddsd structure and its members
    DDSURFACEDESC2 ddsd;
    memset( &ddsd, 0, sizeof( ddsd ) );
    DDPIXELFORMAT  ddpf;
    memset( &ddpf, 0, sizeof( ddpf ) );
    //DDCOLORKEY     ddckCKDestOverlay;
    //DDCOLORKEY     ddckCKDestBlt;
    //DDCOLORKEY     ddckCKSrcOverlay;
    //DDCOLORKEY     ddckCKSrcBlt;
    DDSCAPS2       ddsCaps;
    memset( &ddsCaps, 0, sizeof( ddsCaps ) );

    ddsd.dwSize = sizeof(ddsd);
    ddpf.dwSize = sizeof(ddpf);

    // Default values and initialization of structures' flags
    unsigned int SD_flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
    unsigned int CAPS_flags  = DDSCAPS_TEXTURE;
    unsigned int PF_flags = 0;
    unsigned int CAPS2_flags = 0;

    // Get image properties
    unsigned int dataType       = img->getDataType();
    unsigned int pixelFormat    = img->getPixelFormat();
    //unsigned int internalFormat = img->getInternalTextureFormat();
    //unsigned int components     = osg::Image::computeNumComponents(pixelFormat);
    unsigned int pixelSize      = osg::Image::computePixelSizeInBits(pixelFormat, dataType);
    unsigned int imageSize      = img->getTotalSizeInBytes();

   OSG_INFO<<"WriteDDS, dataType = 0x"<<std::hex<<dataType<<std::endl;

   // Check that theorical image size (computation taking into account DXTC blocks) is not bigger than actual image size.
    // This may happen, for instance, if some operation tuncated the data buffer non block-aligned. Example:
    //  - Read DXT1 image, size = 8x7. Actually, image data is 8x8 because it stores 4x4 blocks.
    //  - Some hypothetical operation wrongly assumes the data buffer is 8x7 and truncates the buffer. This may even lead to access violations.
    //  - Then we write the DXT1 image: last block(s) is (are) corrupt.
    // Actually what could be very nice is to handle some "lines packing" (?) in DDS reading, indicating that the image buffer has "additional lines to reach a multiple of 4".
    // Please note this can also produce false positives (ie. when data buffer is large enough, but getImageSizeInBytes() returns a smaller value). There is no way to detect this, until we fix getImageSizeInBytes() with "line packing".
    unsigned int imageSizeTheorical = ComputeImageSizeInBytes( img->s(), img->t(), img->r(), pixelFormat, dataType, img->getPacking() );
    if (imageSize < imageSizeTheorical) {
        OSG_FATAL << "Image cannot be written as DDS (Maybe a corrupt S3TC-DXTC image, with non %4 dimensions)." << std::endl;
        return false;
    }

    ddsd.dwWidth  = img->s();
    ddsd.dwHeight = img->t();
    int r = img->r();

    if(r > 1)  /* check for 3d image */
    {
        ddsd.dwDepth = r;
        SD_flags    |= DDSD_DEPTH;
        CAPS_flags  |= DDSCAPS_COMPLEX;
        CAPS2_flags |= DDSCAPS2_VOLUME;
    }

    // Determine format - set flags and ddsd, ddpf properties
    switch (pixelFormat)
    {
        //Uncompressed
    case GL_RGBA:
        {
            ddpf.dwRBitMask        = 0x000000ff;
            ddpf.dwGBitMask        = 0x0000ff00;
            ddpf.dwBBitMask        = 0x00ff0000;
            ddpf.dwRGBAlphaBitMask = 0xff000000;
            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_RGB);
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;
    case GL_BGRA:
        {
            ddpf.dwBBitMask        = 0x000000ff;
            ddpf.dwGBitMask        = 0x0000ff00;
            ddpf.dwRBitMask        = 0x00ff0000;
            ddpf.dwRGBAlphaBitMask = 0xff000000;
            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_RGB);
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;
    case GL_LUMINANCE_ALPHA:
        {
            ddpf.dwRBitMask         = 0x000000ff;
            ddpf.dwRGBAlphaBitMask  = 0x0000ff00;
            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_LUMINANCE);
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;
    case GL_RGB:
        {
            ddpf.dwRBitMask        = 0x000000ff;
            ddpf.dwGBitMask        = 0x0000ff00;
            ddpf.dwBBitMask        = 0x00ff0000;
            PF_flags |= DDPF_RGB;
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;
    case GL_BGR:
        {
            ddpf.dwBBitMask        = 0x000000ff;
            ddpf.dwGBitMask        = 0x0000ff00;
            ddpf.dwRBitMask        = 0x00ff0000;
            PF_flags |= DDPF_RGB;
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;
    case GL_LUMINANCE:
    case GL_DEPTH_COMPONENT:
        {
            ddpf.dwRBitMask         = 0x000000ff;
            PF_flags |= DDPF_LUMINANCE;
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;
    case GL_ALPHA:
        {
            ddpf.dwRGBAlphaBitMask  = 0x000000ff;
            PF_flags |= DDPF_ALPHA;
            ddpf.dwRGBBitCount = pixelSize;
            ddsd.lPitch = img->getRowSizeInBytes();
            SD_flags |= DDSD_PITCH;
        }
        break;

        //Compressed
    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
        {
            isDXTC = true;
            ddpf.dwFourCC = FOURCC_DXT1;
            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_FOURCC);
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
        {
            isDXTC = true;
            ddpf.dwFourCC = FOURCC_DXT3;
            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_FOURCC);
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
        {
            isDXTC = true;
            ddpf.dwFourCC = FOURCC_DXT5;
            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_FOURCC);
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
        {
            isDXTC = true;
            ddpf.dwFourCC = FOURCC_DXT1;
            PF_flags |= DDPF_FOURCC;  /* No alpha here */
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
        {
            ddpf.dwFourCC = FOURCC_ATI1;
            PF_flags |= DDPF_FOURCC;  /* No alpha here */
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_RED_RGTC1_EXT:
        {
            ddpf.dwFourCC = FOURCC_ATI1;
            PF_flags |= DDPF_FOURCC;  /* No alpha here */
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
        {
            ddpf.dwFourCC = FOURCC_ATI2;
            PF_flags |= DDPF_FOURCC;  /* No alpha here */
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
        {
            ddpf.dwFourCC = FOURCC_ATI2;
            PF_flags |= DDPF_FOURCC;  /* No alpha here */
            ddsd.dwLinearSize = imageSize;
            SD_flags |= DDSD_LINEARSIZE;
        }
        break;
    default:
        OSG_WARN<<"Warning:: unhandled pixel format in image, file cannot be written."<<std::endl;
        return false;
    }

    // set even more flags
    if( !img->isMipmap() ) {

       OSG_INFO<<"no mipmaps to write out."<<std::endl;

    //} else if( img->getPacking() > 1 ) {

    //   OSG_WARN<<"Warning: mipmaps not written. DDS requires packing == 1."<<std::endl;

    } else { // image contains mipmaps and has 1 byte alignment

        SD_flags   |= DDSD_MIPMAPCOUNT;
        CAPS_flags |= DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;

        ddsd.dwMipMapCount = img->getNumMipmapLevels();

        OSG_INFO<<"writing out with mipmaps ddsd.dwMipMapCount"<<ddsd.dwMipMapCount<<std::endl;
    }

    // Assign flags and structure members of ddsd
    ddsd.dwFlags    = SD_flags;
    ddpf.dwFlags    = PF_flags;
    ddsCaps.dwCaps  = CAPS_flags;
    ddsCaps.dwCaps2 = CAPS2_flags;

    ddsd.ddpfPixelFormat = ddpf;
    ddsd.ddsCaps = ddsCaps;

    osg::ref_ptr<const osg::Image> source;
    if (autoFlipDDSWrite && img->getOrigin() == osg::Image::BOTTOM_LEFT)
    {
        OSG_INFO<<"Flipping dds image on write"<<std::endl;

        osg::ref_ptr<osg::Image> copy( new osg::Image(*img,osg::CopyOp::DEEP_COPY_ALL) );
        const int s(copy->s());
        const int t(copy->t());
        if (!isDXTC || ((s>4 && s%4==0 && t>4 && t%4==0) || s<4))        // Flip may crash (access violation) or fail for non %4 dimensions (except for s<4). Tested with revision trunk 2013-02-22.
        {
            copy->flipVertical();
        }
        else
        {
            OSG_WARN << "WriteDDSFile warning: Vertical flip was skipped. Image dimensions have to be multiple of 4." << std::endl;
        }
        source = copy;
    }
    else
    {
        source = img;
    }

    // Write DDS file
    fout.write("DDS ", 4); /* write FOURCC */
    fout.write(reinterpret_cast<char*>(&ddsd), sizeof(ddsd)); /* write file header */

    for(osg::Image::DataIterator itr(source.get()); itr.valid(); ++itr)
    {
        fout.write(reinterpret_cast<const char*>(itr.data()), itr.size() );
    }

    // Check for correct saving
    if ( fout.fail() )
        return false;

    // If we get that far the file was saved properly //
    return true;
}


class ReaderWriterDDS : public osgDB::ReaderWriter
{
public:

    ReaderWriterDDS()
    {
        supportsExtension("dds","DDS image format");
        supportsOption("dds_dxt1_rgb","Set the pixel format of DXT1 encoded images to be RGB variant of DXT1");
        supportsOption("dds_dxt1_rgba","Set the pixel format of DXT1 encoded images to be RGBA variant of DXT1");
        supportsOption("dds_dxt1_detect_rgba","For DXT1 encode images set the pixel format according to presence of transparent pixels");
        supportsOption("dds_flip","Flip the image about the horizontal axis");
        supportsOption("ddsNoAutoFlipWrite", "(Write option) Avoid automatically flipping the image vertically when writing, depending on the origin (Image::getOrigin()).");
    }

    virtual const char* className() const
    {
        return "DDS Image Reader/Writer";
    }

    virtual ReadResult readObject(const std::string& file, const osgDB::ReaderWriter::Options* options) const
    {
        return readImage(file,options);
    }

    virtual ReadResult readObject(std::istream& fin, const Options* options) const
    {
        return readImage(fin,options);
    }

    virtual ReadResult readImage(const std::string& file, const osgDB::ReaderWriter::Options* options) const
    {
        std::string ext = osgDB::getLowerCaseFileExtension(file);
        if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;

        std::string fileName = osgDB::findDataFile( file, options );

        if (fileName.empty()) return ReadResult::FILE_NOT_FOUND;

        osgDB::ifstream stream(fileName.c_str(), std::ios::in | std::ios::binary);
        if(!stream) return ReadResult::FILE_NOT_HANDLED;
        ReadResult rr = readImage(stream, options);
        if(rr.validImage()) rr.getImage()->setFileName(file);
        return rr;
    }

    virtual ReadResult readImage(std::istream& fin, const Options* options) const
    {
        bool dds_flip(false);
        bool dds_dxt1_rgba(false);
        bool dds_dxt1_rgb(false);
        bool dds_dxt1_detect_rgba(false);
        if (options)
        {
            std::istringstream iss(options->getOptionString());
            std::string opt;
            while (iss >> opt)
            {
                if (opt == "dds_flip") dds_flip = true;
                if (opt == "dds_dxt1_rgba") dds_dxt1_rgba = true;
                if (opt == "dds_dxt1_rgb") dds_dxt1_rgb = true;
                if (opt == "dds_dxt1_detect_rgba") dds_dxt1_detect_rgba = true;
            }
        }
        osg::Image* osgImage = ReadDDSFile(fin, dds_flip);
        if (osgImage==NULL) return ReadResult::FILE_NOT_HANDLED;

        if (osgImage->getPixelFormat()==GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
            osgImage->getPixelFormat()==GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
        {
            if (dds_dxt1_rgba)
            {
                osgImage->setPixelFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
                osgImage->setInternalTextureFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
            }
            else if (dds_dxt1_rgb)
            {
                osgImage->setPixelFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
                osgImage->setInternalTextureFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
            }
            else if (dds_dxt1_detect_rgba)
            {
                // check to see if DXT1c (RGB_S3TC_DXT1) format image might actually be
                // a DXT1a format image

                // temporarily set pixel format to GL_COMPRESSED_RGBA_S3TC_DXT1_EXT so
                // that the isImageTranslucent() method assumes that RGBA is present and then
                // checks the alpha values to see if they are all 1.0.
                osgImage->setPixelFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
                osgImage->setInternalTextureFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
                if (!osgImage->isImageTranslucent())
                {
                    // image contains alpha's that are 1.0, so treat is as RGB
                    OSG_INFO<<"Image with PixelFormat==GL_COMPRESSED_RGB_S3TC_DXT1_EXT is opaque."<<std::endl;
                    osgImage->setPixelFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
                    osgImage->setInternalTextureFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
                }
                else
                {
                    // image contains alpha's that are non 1.0, so treat is as RGBA
                    OSG_INFO<<"Image with PixelFormat==GL_COMPRESSED_RGB_S3TC_DXT1_EXT has transparency, setting format to GL_COMPRESSED_RGBA_S3TC_DXT1_EXT."<<std::endl;
                }
            }
        }

        return osgImage;
    }

    virtual WriteResult writeObject(const osg::Object& object,const std::string& file, const osgDB::ReaderWriter::Options* options) const
    {
        const osg::Image* image = dynamic_cast<const osg::Image*>(&object);
        if (!image) return WriteResult::FILE_NOT_HANDLED;

        return writeImage(*image,file,options);
    }

    virtual WriteResult writeObject(const osg::Object& object,std::ostream& fout,const Options* options) const
    {
        const osg::Image* image = dynamic_cast<const osg::Image*>(&object);
        if (!image) return WriteResult::FILE_NOT_HANDLED;

        return writeImage(*image,fout,options);
    }


    virtual WriteResult writeImage(const osg::Image &image,const std::string& file, const osgDB::ReaderWriter::Options* options) const
    {
        std::string ext = osgDB::getFileExtension(file);
        if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED;

        osgDB::ofstream fout(file.c_str(), std::ios::out | std::ios::binary);
        if(!fout) return WriteResult::ERROR_IN_WRITING_FILE;

        WriteResult res( writeImage(image,fout,options) );
        if (!res.success()) {
            // Remove file on failure
            fout.close();
            DELETEFILE(file.c_str());
        }
        return res;
    }

    virtual WriteResult writeImage(const osg::Image& image,std::ostream& fout,const Options* options) const
    {
        bool noAutoFlipDDSWrite = options && options->getOptionString().find("ddsNoAutoFlipWrite")!=std::string::npos;
        bool success = WriteDDSFile(&image, fout, !noAutoFlipDDSWrite);

        if(success)
            return WriteResult::FILE_SAVED;
        else
            return WriteResult::ERROR_IN_WRITING_FILE;
    }
};

// now register with Registry to instantiate the above
// reader/writer.
REGISTER_OSGPLUGIN(dds, ReaderWriterDDS)
_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Stephan Wenglorz | 15 Feb 10:13 2015
Picon

Fix for OperationThread::setDone()

Hi Robert,

the attached fix corrects a small bug in OperationThread::setDone(bool), 
calling it had the opposite effect of what was intended, i.e. setting 
done to false actually finished the thread. The effect was that VPB 
threads would exit before starting osgdem when a task had been enqueued, 
because they initially set done to false.

Base is OSG svn/trunk rev. 14694.

Cheers,
Stephan
Attachment (OperationThread.cpp): text/x-c++src, 11 KiB
_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
Daniel Schmid | 13 Feb 13:29 2015
Picon

New ViewDependShadowMap updates (was Re: ViewDependShadowMap improvements)

Hi all

I have a small change I needed to do in order for VDSM to work properly.

Its at the very end of the ViewDependentShadowMap::cull method:

Original:

Code:

if (settings->getApplyShadowToSceneCallback())
settings->getApplyShadowToSceneCallback()->applyStateSet(&cv, selectStateSetForRenderingShadow(*vdd));
else decoratorStateGraph->setStateSet(selectStateSetForRenderingShadow(*vdd));

Proposition:

Code:

osg::StateSet* sceneStateSet = selectStateSetForRenderingShadow(*vdd);

if (settings->getApplyShadowToSceneCallback())
settings->getApplyShadowToSceneCallback()->applyStateSet(&cv, sceneStateSet);

decoratorStateGraph->setStateSet(sceneStateSet);

This minor change doesn't break anything, but it allows me to do changes in the callback (add textures and
uniforms custom shader) and then have the modified stateset pushed in to the decoratorStateGraph.
Previously this was not possible.

Regards
Daniel

------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=62668#62668
Arjun Ramamurthy | 13 Feb 08:27 2015
Picon

MultiView StatsHandler Bug Fix

Hi,

When we use StatsHandler in multiple views, then we are unable to control 1st view. Attached fix is based on
OSG 3.2.1.

Reproduction Scenario:
1. Use "osgcompositeviewer.cpp" (modified osg example) provided with the following command line
arguments "cow.osg -2".
2. After starting the application, use mouse inputs to control the scene in both the view (this should work
as expected).
3. Now enable Stats via 's' key in 1st view then use mouse inputs ONLY in 1st view (this will work).
4. Now just hover the mouse pointer onto 2nd view (so that the 2nd view comes into focus) and then try to
control 1st view using mouse inputs. ONLY 2nd view will respond. There is no healing other than restarting
the application.

Reason for the Bug:
1. StatsHandler creates HUDCamera 
	1a. Using GraphicsContext of 1st view in StatsHandler::setUpHUDCamera() i.e. windows.front() context
	1b. With AllowEventFocus(true)
2. This causes 1st view's context to have 2 Cameras attached to it (Main + Stats HUD)
3. In CompositeViewer::generatePointerData(), whenever an event is handled for 1st view it will always
add PointerData of 1st view's Stats HUD camera instead of Main Camera due to
"std::sort(activeCameras.begin(), activeCameras.end(), osg::CameraRenderOrderSortOp());"
4. Since HUD camera doesn't have a osgViewer::View*, the following code in
CompositeViewer::eventTraversal() results in events being pushed to _viewWithFocus
	if (!view)
	{
		if (_viewWithFocus.valid())
		{
			// OSG_NOTICE<<"Falling back to using _viewWithFocus"<<std::endl;
			view = _viewWithFocus.get();
		}
		else if (!_views.empty())
		{
			// OSG_NOTICE<<"Falling back to using first view as one with focus"<<std::endl;
			view = _views[0].get();
		}
	}
5. As explained in reproduction scenario, once 2nd view comes to focus, then _viewWithFocus will be 2nd
view and 1st view cannot be controlled there after

Fix:
To fix this issue StatsHandler's HUDCamera can be created with "_camera->setAllowEventFocus(false);"

Fix has been tested on Windows using "osgcompositeviewer.cpp" example provided with the following
command line arguments "cow.osg -2"

Thank you!

Cheers,
Arjun

------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=62665#62665

Attachments: 
http://forum.openscenegraph.org//files/multiview_statshandler_bug_fix_548.zip
Farshid Lashkari | 13 Feb 01:50 2015
Picon

Fix integer overflow in gluScaleImage

Hi Robert,

I've attached a fix for some internal glu functions so that they use size_t for computing allocation sizes instead of GLint. I encountered some large images that were triggering integer overflows with the current code.

Cheers,
Farshid
Attachment (mipmap.zip): application/zip, 45 KiB
_______________________________________________
osg-submissions mailing list
osg-submissions@...
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org

Gmane