ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreBitwise.h

@@ -1,331 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef _Bitwise_H__
-#define _Bitwise_H__
-
-#include "OgrePrerequisites.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-
-    /** Class for manipulating bit patterns.
-    */
-    class Bitwise {
-    public:
-        /** Returns the most significant bit set in a value.
-        */
-        static FORCEINLINE unsigned int mostSignificantBitSet(unsigned int value)
-        {
-            unsigned int result = 0;
-            while (value != 0) {
-                ++result;
-                value >>= 1;
-            }
-            return result-1;
-        }
-        /** Returns the closest power-of-two number greater or equal to value.
-            @note 0 and 1 are powers of two, so 
-                firstPO2From(0)==0 and firstPO2From(1)==1.
-        */
-        static FORCEINLINE uint32 firstPO2From(uint32 n)
-        {
-            --n;            
-            n |= n >> 16;
-            n |= n >> 8;
-            n |= n >> 4;
-            n |= n >> 2;
-            n |= n >> 1;
-            ++n;
-            return n;
-        }
-        /** Determines whether the number is power-of-two or not.
-            @note 0 and 1 are tread as power of two.
-        */
-        template<typename T>
-        static FORCEINLINE bool isPO2(T n)
-        {
-            return (n & (n-1)) == 0;
-        }
-        /** Returns the number of bits a pattern must be shifted right by to
-            remove right-hand zeros.
-        */
-		template<typename T>
-        static FORCEINLINE unsigned int getBitShift(T mask)
-		{
-			if (mask == 0)
-				return 0;
-
-			unsigned int result = 0;
-			while ((mask & 1) == 0) {
-				++result;
-				mask >>= 1;
-			}
-			return result;
-		}
-
-        /** Takes a value with a given src bit mask, and produces another
-            value with a desired bit mask.
-            @remarks
-                This routine is useful for colour conversion.
-        */
-		template<typename SrcT, typename DestT>
-        static inline DestT convertBitPattern(SrcT srcValue, SrcT srcBitMask, DestT destBitMask)
-		{
-			// Mask off irrelevant source value bits (if any)
-			srcValue = srcValue & srcBitMask;
-
-			// Shift source down to bottom of DWORD
-			const unsigned int srcBitShift = getBitShift(srcBitMask);
-			srcValue >>= srcBitShift;
-
-			// Get max value possible in source from srcMask
-			const SrcT srcMax = srcBitMask >> srcBitShift;
-
-			// Get max available in dest
-			const unsigned int destBitShift = getBitShift(destBitMask);
-			const DestT destMax = destBitMask >> destBitShift;
-
-			// Scale source value into destination, and shift back
-			DestT destValue = (srcValue * destMax) / srcMax;
-			return (destValue << destBitShift);
-		}
-
-        /**
-         * Convert N bit colour channel value to P bits. It fills P bits with the
-         * bit pattern repeated. (this is /((1<<n)-1) in fixed point)
-         */
-        static inline unsigned int fixedToFixed(uint32 value, unsigned int n, unsigned int p) 
-        {
-            if(n > p) 
-            {
-                // Less bits required than available; this is easy
-                value >>= n-p;
-            } 
-            else if(n < p)
-            {
-                // More bits required than are there, do the fill
-                // Use old fashioned division, probably better than a loop
-                if(value == 0)
-                        value = 0;
-                else if(value == (static_cast<unsigned int>(1)<<n)-1)
-                        value = (1<<p)-1;
-                else    value = value*(1<<p)/((1<<n)-1);
-            }
-            return value;    
-        }
-
-        /**
-         * Convert floating point colour channel value between 0.0 and 1.0 (otherwise clamped) 
-         * to integer of a certain number of bits. Works for any value of bits between 0 and 31.
-         */
-        static inline unsigned int floatToFixed(const float value, const unsigned int bits)
-        {
-            if(value <= 0.0f) return 0;
-            else if (value >= 1.0f) return (1<<bits)-1;
-            else return (unsigned int)(value * (1<<bits));     
-        }
-
-        /**
-         * Fixed point to float
-         */
-        static inline float fixedToFloat(unsigned value, unsigned int bits)
-        {
-            return (float)value/(float)((1<<bits)-1);
-        }
-
-        /**
-         * Write a n*8 bits integer value to memory in native endian.
-         */
-        static inline void intWrite(void *dest, const int n, const unsigned int value)
-        {
-            switch(n) {
-                case 1:
-                    ((uint8*)dest)[0] = (uint8)value;
-                    break;
-                case 2:
-                    ((uint16*)dest)[0] = (uint16)value;
-                    break;
-                case 3:
-#if OGRE_ENDIAN == OGRE_ENDIAN_BIG      
-                    ((uint8*)dest)[0] = (uint8)((value >> 16) & 0xFF);
-                    ((uint8*)dest)[1] = (uint8)((value >> 8) & 0xFF);
-                    ((uint8*)dest)[2] = (uint8)(value & 0xFF);
-#else
-                    ((uint8*)dest)[2] = (uint8)((value >> 16) & 0xFF);
-                    ((uint8*)dest)[1] = (uint8)((value >> 8) & 0xFF);
-                    ((uint8*)dest)[0] = (uint8)(value & 0xFF);
-#endif
-                    break;
-                case 4:
-                    ((uint32*)dest)[0] = (uint32)value;                
-                    break;                
-            }        
-        }
-        /**
-         * Read a n*8 bits integer value to memory in native endian.
-         */
-        static inline unsigned int intRead(const void *src, int n) {
-            switch(n) {
-                case 1:
-                    return ((uint8*)src)[0];
-                case 2:
-                    return ((uint16*)src)[0];
-                case 3:
-#if OGRE_ENDIAN == OGRE_ENDIAN_BIG      
-                    return ((uint32)((uint8*)src)[0]<<16)|
-                            ((uint32)((uint8*)src)[1]<<8)|
-                            ((uint32)((uint8*)src)[2]);
-#else
-                    return ((uint32)((uint8*)src)[0])|
-                            ((uint32)((uint8*)src)[1]<<8)|
-                            ((uint32)((uint8*)src)[2]<<16);
-#endif
-                case 4:
-                    return ((uint32*)src)[0];
-            } 
-            return 0; // ?
-        }
-
-        /** Convert a float32 to a float16 (NV_half_float)
-         	Courtesy of OpenEXR
-        */
-        static inline uint16 floatToHalf(float i)
-        {
-            union { float f; uint32 i; } v;
-            v.f = i;
-            return floatToHalfI(v.i);
-        }
-		/** Converts float in uint32 format to a a half in uint16 format
-		*/
-        static inline uint16 floatToHalfI(uint32 i)
-        {
-            register int s =  (i >> 16) & 0x00008000;
-            register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
-            register int m =   i        & 0x007fffff;
-        
-            if (e <= 0)
-            {
-                if (e < -10)
-                {
-                    return 0;
-                }
-                m = (m | 0x00800000) >> (1 - e);
-        
-                return static_cast<uint16>(s | (m >> 13));
-            }
-            else if (e == 0xff - (127 - 15))
-            {
-                if (m == 0) // Inf
-                {
-                    return static_cast<uint16>(s | 0x7c00);
-                } 
-                else    // NAN
-                {
-                    m >>= 13;
-                    return static_cast<uint16>(s | 0x7c00 | m | (m == 0));
-                }
-            }
-            else
-            {
-                if (e > 30) // Overflow
-                {
-                    return static_cast<uint16>(s | 0x7c00);
-                }
-        
-                return static_cast<uint16>(s | (e << 10) | (m >> 13));
-            }
-        }
-        
-        /**
-         * Convert a float16 (NV_half_float) to a float32
-         * Courtesy of OpenEXR
-         */
-        static inline float halfToFloat(uint16 y)
-        {
-            union { float f; uint32 i; } v;
-            v.i = halfToFloatI(y);
-            return v.f;
-        }
-		/** Converts a half in uint16 format to a float
-		 	in uint32 format
-		 */
-        static inline uint32 halfToFloatI(uint16 y)
-        {
-            register int s = (y >> 15) & 0x00000001;
-            register int e = (y >> 10) & 0x0000001f;
-            register int m =  y        & 0x000003ff;
-        
-            if (e == 0)
-            {
-                if (m == 0) // Plus or minus zero
-                {
-                    return s << 31;
-                }
-                else // Denormalized number -- renormalize it
-                {
-                    while (!(m & 0x00000400))
-                    {
-                        m <<= 1;
-                        e -=  1;
-                    }
-        
-                    e += 1;
-                    m &= ~0x00000400;
-                }
-            }
-            else if (e == 31)
-            {
-                if (m == 0) // Inf
-                {
-                    return (s << 31) | 0x7f800000;
-                }
-                else // NaN
-                {
-                    return (s << 31) | 0x7f800000 | (m << 13);
-                }
-            }
-        
-            e = e + (127 - 15);
-            m = m << 13;
-        
-            return (s << 31) | (e << 23) | m;
-        }
-         
-
-    };
-	/** @} */
-	/** @} */
-
-}
-
-#endif

data/deps/include/OGRE/OgreBlendMode.h

@@ -1,266 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __BLENDMODE_H__
-#define __BLENDMODE_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreColourValue.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Materials
-	*  @{
-	*/
-
-    /** Type of texture blend mode.
-    */
-    enum LayerBlendType
-    {
-        LBT_COLOUR,
-        LBT_ALPHA
-    };
-
-    /** List of valid texture blending operations, for use with TextureUnitState::setColourOperation.
-        @remarks
-            This list is a more limited list than LayerBlendOperationEx because it only
-            includes operations that are supportable in both multipass and multitexture
-            rendering and thus provides automatic fallback if multitexture hardware
-            is lacking or insufficient.
-    */
-    enum LayerBlendOperation {
-        /// Replace all colour with texture with no adjustment
-        LBO_REPLACE,
-        /// Add colour components together.
-        LBO_ADD,
-        /// Multiply colour components together.
-        LBO_MODULATE,
-        /// Blend based on texture alpha
-        LBO_ALPHA_BLEND
-
-    };
-
-    /** Expert list of valid texture blending operations, for use with TextureUnitState::setColourOperationEx
-        and TextureUnitState::setAlphaOperation, and internally in the LayerBlendModeEx class. It's worth
-        noting that these operations are for blending <i>between texture layers</i> and not between rendered objects
-        and the existing scene. Because all of these modes are only supported in multitexture hardware it may be
-        required to set up a fallback operation where this hardware is not available.
-    */
-    enum LayerBlendOperationEx {
-        /// use source1 without modification
-        LBX_SOURCE1,
-        /// use source2 without modification
-        LBX_SOURCE2,
-        /// multiply source1 and source2 together
-        LBX_MODULATE,
-        /// as LBX_MODULATE but brighten afterwards (x2)
-        LBX_MODULATE_X2,
-        /// as LBX_MODULATE but brighten more afterwards (x4)
-        LBX_MODULATE_X4,
-        /// add source1 and source2 together
-        LBX_ADD,
-        /// as LBX_ADD, but subtract 0.5 from the result
-        LBX_ADD_SIGNED,
-        /// as LBX_ADD, but subtract product from the sum
-        LBX_ADD_SMOOTH,
-        /// subtract source2 from source1
-        LBX_SUBTRACT,
-        /// use interpolated alpha value from vertices to scale source1, then add source2 scaled by (1-alpha)
-        LBX_BLEND_DIFFUSE_ALPHA,
-        /// as LBX_BLEND_DIFFUSE_ALPHA, but use alpha from texture
-        LBX_BLEND_TEXTURE_ALPHA,
-        /// as LBX_BLEND_DIFFUSE_ALPHA, but use current alpha from previous stages
-        LBX_BLEND_CURRENT_ALPHA,
-        /// as LBX_BLEND_DIFFUSE_ALPHA but use a constant manual blend value (0.0-1.0)
-        LBX_BLEND_MANUAL,
-        /// dot product of color1 and color2 
-        LBX_DOTPRODUCT,
-        /// use interpolated color values from vertices to scale source1, then add source2 scaled by (1-color)
-        LBX_BLEND_DIFFUSE_COLOUR
-    };
-
-    /** List of valid sources of values for blending operations used
-        in TextureUnitState::setColourOperation and TextureUnitState::setAlphaOperation,
-        and internally in the LayerBlendModeEx class.
-    */
-    enum LayerBlendSource
-    {
-        /// the colour as built up from previous stages
-        LBS_CURRENT,
-        /// the colour derived from the texture assigned to this layer
-        LBS_TEXTURE,
-        /// the interpolated diffuse colour from the vertices
-        LBS_DIFFUSE,
-        /// the interpolated specular colour from the vertices
-        LBS_SPECULAR,
-        /// a colour supplied manually as a separate argument
-        LBS_MANUAL
-    };
-    /** Class which manages blending of both colour and alpha components.
-        @remarks
-            This class is a utility class used by both TextureUnitState and
-            RenderSystem to wrap up the details of a blending operation. This blending
-            operation could be used for blending colour or alpha in a texture layer.
-            This class is really only for use by OGRE, since apps can deal with
-            blending modes through the TextureUnitState class methods
-            setColourOperation and setAlphaOperation.
-        @par
-            It's worth noting that these operations are for blending <i>between texture
-            layers</i> and not between rendered objects and the existing scene. If
-            you wish to make an object blend with others in the scene, e.g. to make
-            transparent objects etc, use the Material::setSceneBlending method.
-    */
-    class _OgreExport LayerBlendModeEx
-    {
-    public:
-        /// The type of blending (colour or alpha)
-        LayerBlendType blendType;
-        /// The operation to be applied
-        LayerBlendOperationEx operation;
-        /// The first source of colour/alpha
-        LayerBlendSource source1;
-        /// The second source of colour/alpha
-        LayerBlendSource source2;
-
-        /// Manual colour value for manual source1
-        ColourValue colourArg1;
-        /// Manual colour value for manual source2
-        ColourValue colourArg2;
-        /// Manual alpha value for manual source1
-        Real alphaArg1;
-        /// Manual alpha value for manual source2
-        Real alphaArg2;
-        /// Manual blending factor
-        Real factor;
-
-        bool operator==(const LayerBlendModeEx& rhs) const
-        {
-            if (blendType != rhs.blendType) return false;
-
-            if (blendType == LBT_COLOUR)
-            {
-
-                if (operation == rhs.operation &&
-                    source1 == rhs.source1 &&
-                    source2 == rhs.source2 &&
-                    colourArg1 == rhs.colourArg1 &&
-                    colourArg2 == rhs.colourArg2 &&
-                    factor == rhs.factor)
-                {
-                    return true;
-                }
-            }
-            else // if (blendType == LBT_ALPHA)
-            {
-                if (operation == rhs.operation &&
-                    source1 == rhs.source1 &&
-                    source2 == rhs.source2 &&
-                    alphaArg1 == rhs.alphaArg1 &&
-                    alphaArg2 == rhs.alphaArg2 &&
-                    factor == rhs.factor)
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        bool operator!=(const LayerBlendModeEx& rhs) const
-        {
-            return !(*this == rhs);
-        }
-
-
-
-    };
-
-    /** Types of blending that you can specify between an object and the existing contents of the scene.
-        @remarks
-            As opposed to the LayerBlendType, which classifies blends between texture layers, these blending
-            types blend between the output of the texture units and the pixels already in the viewport,
-            allowing for object transparency, glows, etc.
-        @par
-            These types are provided to give quick and easy access to common effects. You can also use
-            the more manual method of supplying source and destination blending factors.
-            See Material::setSceneBlending for more details.
-        @see
-            Material::setSceneBlending
-    */
-    enum SceneBlendType
-    {
-        /// Make the object transparent based on the final alpha values in the texture
-        SBT_TRANSPARENT_ALPHA,
-        /// Make the object transparent based on the colour values in the texture (brighter = more opaque)
-        SBT_TRANSPARENT_COLOUR,
-        /// Add the texture values to the existing scene content
-        SBT_ADD,
-		/// Multiply the 2 colours together
-		SBT_MODULATE,
-        /// The default blend mode where source replaces destination
-        SBT_REPLACE
-        // TODO : more
-    };
-
-    /** Blending factors for manually blending objects with the scene. If there isn't a predefined
-        SceneBlendType that you like, then you can specify the blending factors directly to affect the
-        combination of object and the existing scene. See Material::setSceneBlending for more details.
-    */
-    enum SceneBlendFactor
-    {
-        SBF_ONE,
-        SBF_ZERO,
-        SBF_DEST_COLOUR,
-        SBF_SOURCE_COLOUR,
-        SBF_ONE_MINUS_DEST_COLOUR,
-        SBF_ONE_MINUS_SOURCE_COLOUR,
-        SBF_DEST_ALPHA,
-        SBF_SOURCE_ALPHA,
-        SBF_ONE_MINUS_DEST_ALPHA,
-        SBF_ONE_MINUS_SOURCE_ALPHA
-
-    };
-
-	/** Blending operations controls how objects are blended into the scene. The default operation
-		is add (+) but by changing this you can change how drawn objects are blended into the
-		existing scene.
-	*/
-	enum SceneBlendOperation
-	{
-		SBO_ADD,
-		SBO_SUBTRACT,
-		SBO_REVERSE_SUBTRACT,
-		SBO_MIN,
-		SBO_MAX
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif