nux-1.16.0
nux Namespace Reference

The Writer singleton is responsible for controlling where the logging message go. More...

Classes

class  Tooltip
class  AbstractButton
 The base class of Button widgets. More...
class  AbstractComboBox
class  AbstractPaintLayer
class  AbstractSeparator
class  AbstractThread
class  ActionItem
class  AnimatedTextureArea
class  Area
class  BaseWindow
class  Knot
class  BezierCurveControl
class  Knot2
class  BezierCurveControl2
class  Button
class  CairoWrapper
class  Canvas
class  CheckBox
struct  ClientAreaDraw
class  ClientArea
class  ColorArea
class  ColorDialogProxy
class  ColorEditor
class  ColorMarkGroup
class  ColorGradient
class  ColorPickerDialog
class  ColorPreview
class  ColorRangeValuator
class  ComboBoxComplex
class  ComboBoxSimple
class  CurveControl
class  Dialog
class  DoubleValidator
class  EditTextBox
class  FileSelector
class  FloatingWindow
class  Focusable
class  FolderTreeItem
class  FunctionGraph
class  GridHLayout
 An horizontal grid layout. More...
class  GridVLayout
 A vertical grid layout. More...
class  GroupBox
class  GroupBox2
class  HexRegExpValidator
class  Histogram
class  HLayout
class  HScrollBar
class  HSeparator
class  HSplitter
class  HToolBar
class  HueRangeValuator
class  InputArea
class  IntegerValidator
class  BaseKeyboardHandler
class  LayeredChildProperties
class  LayeredLayout
 An layered layout. More...
class  Layout
class  SpaceLayout
class  ListControl
class  Matrix3DialogProxy
 A 3x3 matrix editor dialog. More...
class  Matrix3Editor
 A User Interface component hosting a 4x4 Matrix. More...
class  Matrix3Preview
class  Matrix4DialogProxy
 A 4x4 matrix editor dialog. More...
class  Matrix4Editor
 A User Interface component hosting a 4x4 Matrix. More...
class  Matrix4Preview
class  MenuBarItem
class  MenuBar
class  MenuItem
class  MenuSeparator
class  MenuPage
class  MouseAreaCtrl
class  AreaEventProcessor
class  NodeItem
struct  TypeString
class  NodeNetCom
class  NumericValuator
class  NuxGlobalSingletonInitializer
class  NuxGlobalInitializer
class  GeometryPositioning
class  InteractState
 State of UI controls. More...
class  TextureAlignmentStyle
class  BasePainter
class  PushBackgroundScope
class  PushShapeBackgroundScope
class  PushShapeCornerBackgroundScope
class  PushColorBackgroundScope
class  ColorLayer
class  ShapeLayer
class  SliceScaledTextureLayer
class  TextureLayer
class  Panel
class  PopUpWindow
class  CheckBoxPropertyItem
class  ColorGradientPropertyItem
class  ColorPreviewPropertyItem
class  ComboBoxListPropertyItem
class  ComboBoxPropertyItem
class  DoubleValuatorPropertyItem
class  EditTextLinePropertyItem
class  FilePropertyItem
class  IntValuatorPropertyItem
class  Matrix3PreviewPropertyItem
class  Matrix4PreviewPropertyItem
class  RangeValueIntegerPropertyItem
class  RangeValuePropertyItem
class  RGBAPropertyItem
class  RGBPropertyItem
class  SpinBoxDoublePropertyItem
class  SpinBoxPropertyItem
class  SplineCurvePropertyItem
class  Vector3PropertyItem
class  Vector3ValuatorPropertyItem
class  Vector4PropertyItem
class  SectionProperty
class  RangeValue
class  RangeValueInteger
class  RGBValuator
class  ScrollBar
class  ScrollView
class  SpinBox
class  SpinBox_Logic
class  SpinBoxDouble
class  SplineKnot
class  SplineCurveEditor
class  SplineCurveDialogProxy
class  SplineCurvePreview
class  StaticText
class  StaticTextBox
class  SystemThread
class  TableCtrl
class  ColumnHeader
class  RowHeader
class  TableItem
class  TabView
class  CairoFont
class  TextEntry
class  TextureArea
struct  UXStyle
struct  PainterImage
class  UXTheme
class  TimeGraph
class  Timeline
class  TimelineEaseInOutQuad
class  TimelineEaseInQuad
class  TimelineEaseOutQuad
class  TimelineEaseInOutCubic
class  TimelineEaseInCubic
class  TimelineEaseOutCubic
struct  TimeStruct
class  TimerObject
class  TimerFunctor
class  TimerHandle
class  TimerHandler
class  ToggleButton
 A Button control that performs and action when clicked. More...
class  ToolButton
class  TreeItem
class  TreeControl
struct  DrawAreaContext
class  Validator
class  Valuator
class  ValuatorDouble
class  ValuatorInt
class  Vector3Valuator
class  Vector3DoubleValuator
class  View
class  VLayout
class  VScrollBar
class  VSeparator
class  VSplitter
class  VToolBar
class  WindowCompositor
struct  NuxEventSource
struct  TimeoutData
class  WindowThread
class  AsyncFileWriter
 Write to a file asynchronously. More...
class  UnicharToAnsicharConvertion
class  AnsicharToUnicharConvertion
 ANSICHAR to UNICHAR conversion. More...
class  TCharToAnsiConvertion
 TCHAR to ANSI conversion. More...
class  TCharToUnicharConvertion
 TCHAR to Unichar conversion. More...
class  AnsiToTCharConversion
 ANSI to TCHAR conversion. More...
class  NCharacterConversion
class  NUTF8
 Convert UTF-16 to UTF-8. More...
class  NUTF16
 Convert UTF-8 to UTF-16. More...
class  NCPU
class  CRC32
class  Exception
class  BoundsException
class  NotSupportedException
class  DivisionByZeroException
class  InvalidIndexException
class  NFileTransferMonitor
class  NFileManager
class  NFileManagerGeneric
class  NGNUSerialFileReader
class  NGNUSerialFileWriter
class  NFileManagerGNU
class  NSerializer
class  NFileName
class  FilePath
class  GlobalSingletonInitializer
class  GlobalInitializer
class  InitiallyUnownedObject
 The base class of Nux initially unowned objects. More...
class  ComplexNumber
class  Const
class  Line2D
class  Line3D
class  Matrix2x2
class  Matrix3x3
class  Matrix4x4
class  Point2D
class  Point3D
class  Quaternion
class  CubicSpline
class  Vec2
class  Vec3
class  Vec4
class  UniqueIndex
class  ObjectStats
class  Trackable
 Base class of heap allocated objects. More...
class  Object
 The base class of Nux objects. More...
class  ObjectPtr
 A smart pointer class. Implemented as an intrusive smart pointer. More...
class  ObjectWeakPtr
 A weak smart pointer class. Implemented as an intrusive smart pointer. More...
struct  NObjectType
class  LogOutputDevice
class  NullOutput
 Output to null device. More...
class  LogFileOutput
 Output to log file. More...
class  VisualOutputConsole
 Output to microsoft visual console. More...
class  PrintfOutputConsole
 Standard printf output console. More...
class  LogOutputRedirector
class  NGlobalData
class  NProcess
class  PropertyChangedSignal
class  Property
 A read/write property that stores the value type. More...
class  ROProperty
 A read only property that uses a function to get the value. More...
class  RWProperty
 A read/write property that uses a functions to get and set the value. More...
class  PropertyBase
class  Introspectable
class  SerializableProperty
class  Rect
class  Size
struct  VoidTraits
struct  VoidTraits< void >
struct  PointerTraits
struct  PointerTraits< U * >
struct  UnicodeCharTraits
struct  UnicodeCharTraits< wchar_t >
struct  AnsiCharTraits
struct  AnsiCharTraits< char >
class  TypeTraitsNoConstructor
class  TypeTraitsConstructor
class  ConstructorTraits
class  ConstructorTraits< T * >
class  ConstructorTraits< bool >
class  ConstructorTraits< char >
class  ConstructorTraits< unsigned char >
class  ConstructorTraits< short >
class  ConstructorTraits< unsigned short >
class  ConstructorTraits< int >
class  ConstructorTraits< unsigned int >
class  ConstructorTraits< long >
class  ConstructorTraits< unsigned long >
class  ConstructorTraits< long long >
class  ConstructorTraits< unsigned long long >
class  ConstructorTraits< float >
class  ConstructorTraits< double >
class  NTypeTraits
struct  RemovePointerFromType
struct  RemovePointerFromType< T * >
struct  RemovePointerFromType< const T * >
struct  RemovePointerFromType< volatile T * >
struct  RemovePointerFromType< const volatile T * >
class  TCharToUpperCase
class  TCharToLowerCase
struct  ToLowerCaseFunctor
struct  ToUpperCaseFunctor
struct  LexicographicCompare
struct  LexicographicCompareWithConversion
struct  EqualFunctor
class  NString
class  NThreadSafeCounter
class  NCriticalSection
class  NScopeLock
 Scope Lock class. More...
class  NThreadLocalStorage
class  NThread
class  TimeStamp
struct  EventToNameStruct
class  Event
 Nux event class. More...
class  FontRenderer
class  StringBBox
class  PageBBox
struct  CharDescriptor
struct  KerningPair
struct  Charset
struct  Glyph
class  FontTexture
struct  _DeviceModes
class  GraphicSystem
class  GLFramebufferObject
class  GLRenderbuffer
class  NuxGraphicsGlobalSingletonInitializer
class  NuxGraphicsGlobalInitializer
class  PBuffer
struct  StateLookUpTable
struct  RenderStateMap
class  GpuRenderStates
struct  PixelFormatReadInfo
struct  TEXTURE_DESC
struct  _SURFACE_DESC
struct  _VOLUME_DESC
struct  _ANIMATEDTEXTURE_DESC
struct  _VERTEXBUFFER_DESC
struct  _INDEXBUFFER_DESC
struct  _LOCKED_RECT
struct  _SURFACE_RECT
struct  _VOLUME_BOX
struct  _VOLUME_LOCKED_BOX
struct  VERTEXELEMENT
class  ResourceData
 Base class for all types of resources. More...
class  NResourceSet
class  CachedResourceData
class  NResourceFactory
 Device independent resource factory. More...
class  TGLResourceFactory
class  NResourceUpdater
 Device independent resource updater. More...
class  TResourceCache
class  NResourceCache
class  GLSh_ColorPicker
class  GLSh_DrawFunction
class  GLSh_Fill
class  GLShaderParameter
struct  QuadAttributeParam
class  TemplateQuadBuffer
class  BaseTexture
 Abstract base class for textures. More...
class  Texture2D
 General Texture. More...
class  TextureRectangle
class  TextureCube
class  TextureVolume
class  TextureFrameAnimation
class  CachedBaseTexture
class  CachedTexture2D
class  CachedTextureRectangle
class  CachedTextureCube
class  CachedTextureVolume
class  CachedTextureFrameAnimation
struct  TextureStateLookUpTable
struct  TextureStateMap
class  GLTextureStates
class  GLTimer
class  VertexBuffer
class  IndexBuffer
class  VertexDeclaration
class  CachedVertexBuffer
class  CachedIndexBuffer
class  CachedVertexDeclaration
class  MeshBuffer
class  CachedMeshBuffer
class  DisplayAccessController
struct  OpenGLVersion
struct  STREAMSOURCE
class  GpuInfo
class  GpuDevice
class  GraphicsDisplay
class  ROPConfig
class  BlendOperator
struct  OpenGLContext
class  FxStructure
class  GraphicsEngine
 Rendering engine class. More...
class  IOpenGLAnimatedTexture
class  IOpenGLAsmShader
class  IOpenGLAsmVertexShader
class  IOpenGLAsmPixelShader
class  IOpenGLAsmShaderProgram
class  IOpenGLBaseTexture
class  IOpenGLCubeTexture
class  IOpenGLFrameBufferObject
class  IOpenGLShader
class  IOpenGLVertexShader
class  IOpenGLPixelShader
class  IOpenGLShaderProgram
class  IOpenGLIndexBuffer
class  IOpenGLPixelBufferObject
class  IOpenGLQuery
class  IOpenGLRectangleTexture
struct  ShaderAttributeDefinition
class  IOpenGLResource
class  IOpenGLSurface
class  IOpenGLTexture2D
class  IOpenGLVertexBuffer
class  IOpenGLVertexDeclaration
class  IOpenGLVolume
class  IOpenGLVolumeTexture
class  MeshData
struct  ObjMeshVertex
struct  ObjMeshFace
struct  ObjMesh
struct  _ObjMeshFaceIndex
class  NuxGraphicsResources
struct  TexWrapMapping
struct  TexFilterMapping
struct  RopBlendMapping
class  TexCoordXForm
 Texture parameter and coordinate computation class. More...
class  RenderingStats
class  XInputWindow
struct  PixelFormatInfo
struct  ReadBackPixelFormatInfo
class  CairoFontOptions
class  CairoGraphics
 A cairo graphics container. More...
class  GdkGraphics
class  RawData
struct  DXTColBlock
struct  DXT3AlphaBlock
struct  DXT5AlphaBlock
class  ImageSurface
 Image Surface class. More...
class  NBitmapData
class  NTextureData
class  NCubemapData
class  NVolumeData
class  NAnimatedTextureData
struct  ImageInfo

Typedefs

typedef void(* ThreadUserInitFunc )(NThread *, void *InitData)
typedef void(* ThreadUserExitFunc )(NThread *, void *ExitData)
typedef void(* ThreadMainFunc )(NThread *, void *MainData)
typedef BaseWindow ViewWindow
typedef void(* ConfigureNotifyCallback )(int, int, Geometry &, void *)
typedef float(* FunctionCallback )(float)
typedef sigc::slot< void,
Geometry const &, cairo_t * > 
DrawCanvasCallback
typedef InputArea CoreArea
typedef float(* SplineFunctionCallback )(float)
typedef InputArea sizehandler2
typedef Rect Geometry
typedef int(* EventInspector )(Area *area, Event *event, void *data)
 Event Inspector function prototype.
typedef Matrix3x3< float > Matrix3
typedef Matrix4x4< float > Matrix4
typedef Point2D< float > Point2
typedef Point3D< float > Point3
typedef Vec2< float > Vector2
typedef Vec2< float > Vertex2
typedef Vec3< float > Vector3
typedef Vec3< float > Vertex3
typedef Vec4< float > Vector4
typedef Point2D< int > Point
typedef unsigned char t_u8
typedef unsigned char t_byte
typedef unsigned char t_uchar
typedef char t_char
typedef signed char t_s8
typedef signed char t_schar
typedef unsigned short t_u16
typedef unsigned short t_uint16
typedef unsigned short t_ushort
typedef unsigned short t_word
typedef short t_s16
typedef short t_int16
typedef short t_short
typedef unsigned int t_u32
typedef unsigned int t_uint32
typedef unsigned int t_uint
typedef unsigned int t_dword
typedef int t_s32
typedef int t_int32
typedef int t_int
typedef unsigned long t_ulong
typedef long t_long
typedef unsigned long long t_u64
typedef unsigned long long t_uint64
typedef unsigned long long t_qword
typedef unsigned long long t_ulonglong
typedef long long t_s64
typedef long long t_int64
typedef long long t_sqword
typedef long long t_slonglong
typedef float t_float
typedef float t_f32
typedef double t_double
typedef double t_f64
typedef char * t_pchar
typedef wchar_t t_wchar
typedef unsigned short t_unicodechar
typedef unsigned short * t_punicodechar
typedef bool t_bool
typedef void t_void
typedef void * t_pvoid
typedef unsigned char t_UTF8
typedef unsigned int t_UTF32
typedef std::size_t t_size
typedef int t_saddress
typedef unsigned int t_uaddress
typedef t_uint32 NUX_POINTER
typedef long t_integer
typedef unsigned long t_addressu32
typedef unsigned long long t_addressu64
typedef void *(* ThreadRoutineFunc )(void *)
typedef unsigned char uchar
typedef unsigned long ulong
typedef Event IEvent
typedef enum nux::_TextAlignment TextAlignment
typedef struct nux::_DeviceModes DeviceModes
typedef struct nux::_SURFACE_DESC SURFACE_DESC
typedef struct nux::_VOLUME_DESC VOLUME_DESC
typedef struct
nux::_ANIMATEDTEXTURE_DESC 
ANIMATEDTEXTURE_DESC
typedef struct
nux::_VERTEXBUFFER_DESC 
VERTEXBUFFER_DESC
typedef struct
nux::_INDEXBUFFER_DESC 
INDEXBUFFER_DESC
typedef struct nux::_LOCKED_RECT SURFACE_LOCKED_RECT
typedef struct nux::_SURFACE_RECT SURFACE_RECT
typedef struct nux::_VOLUME_BOX VOLUME_BOX
typedef struct
nux::_VOLUME_LOCKED_BOX 
VOLUME_LOCKED_BOX
typedef enum nux::_ATTRIB_DECL_TYPE ATTRIB_DECL_TYPE
typedef enum
nux::_ATTRIB_COMPONENT_TYPE 
ATTRIB_COMPONENT_TYPE

Enumerations

enum  State {
  NUX_STATE_ACTIVE = 0, NUX_STATE_NORMAL = 1, NUX_STATE_PRELIGHT = 2, NUX_STATE_SELECTED = 3,
  NUX_STATE_INSENSITIVE = 4
}
enum  MinorDimensionSize {
  MINOR_SIZE_FULL, MINOR_SIZE_PERCENTAGE, MINOR_SIZE_FIX, MINOR_SIZE_MATCHCONTENT,
  eFull = MINOR_SIZE_FULL, ePercentage = MINOR_SIZE_PERCENTAGE, eFix = MINOR_SIZE_FIX, eMatchContent = MINOR_SIZE_MATCHCONTENT
}
enum  MinorDimensionPosition {
  MINOR_POSITION_TOP, MINOR_POSITION_BOTTOM, MINOR_POSITION_LEFT, MINOR_POSITION_RIGHT,
  MINOR_POSITION_CENTER, eAbove = MINOR_POSITION_TOP, eBelow = MINOR_POSITION_BOTTOM, eLeft = MINOR_POSITION_LEFT,
  eRight = MINOR_POSITION_RIGHT, eCenter = MINOR_POSITION_CENTER
}
 Policy for and element position in the minor dimension of a layout. More...
enum  LayoutContentDistribution {
  MAJOR_POSITION_TOP, MAJOR_POSITION_BOTTOM, MAJOR_POSITION_LEFT, MAJOR_POSITION_RIGHT,
  MAJOR_POSITION_CENTER, MAJOR_POSITION_EXPAND, eStackTop = MAJOR_POSITION_TOP, eStackBottom = MAJOR_POSITION_BOTTOM,
  eStackLeft = MAJOR_POSITION_LEFT, eStackRight = MAJOR_POSITION_RIGHT, eStackCenter = MAJOR_POSITION_CENTER, eStackExpand = MAJOR_POSITION_EXPAND
}
 Control how a layout distribute its children position. More...
enum  SizeCompliance {
  SIZE_EQUAL_WIDTH = (1L), SIZE_EQUAL_HEIGHT = (1L) << 1, SIZE_SMALLER_WIDTH = (1L) << 2, SIZE_SMALLER_HEIGHT = (1L) << 3,
  SIZE_LARGER_WIDTH = (1L) << 4, SIZE_LARGER_HEIGHT = (1L) << 5, SIZE_FORCE_COMPLY = (1L) << 6, eCompliantWidth = SIZE_EQUAL_WIDTH,
  eCompliantHeight = SIZE_EQUAL_HEIGHT, eSmallerWidth = SIZE_SMALLER_WIDTH, eSmallerHeight = SIZE_SMALLER_HEIGHT, eLargerWidth = SIZE_LARGER_WIDTH,
  eLargerHeight = SIZE_LARGER_HEIGHT, eForceComply = SIZE_FORCE_COMPLY
}
enum  KeyNavDirection {
  KEY_NAV_NONE, KEY_NAV_UP, KEY_NAV_DOWN, KEY_NAV_RIGHT,
  KEY_NAV_LEFT, KEY_NAV_TAB_NEXT, KEY_NAV_TAB_PREVIOUS, KEY_NAV_ENTER
}
enum  Position { NUX_POSITION_LEFT, NUX_POSITION_RIGHT, NUX_POSITION_TOP, NUX_POSITION_BOTTOM }
enum  FocusDirection {
  FOCUS_DIRECTION_NONE, FOCUS_DIRECTION_NEXT, FOCUS_DIRECTION_PREV, FOCUS_DIRECTION_UP,
  FOCUS_DIRECTION_DOWN, FOCUS_DIRECTION_LEFT, FOCUS_DIRECTION_RIGHT
}
enum  FocusEventType { FOCUS_EVENT_NONE, FOCUS_EVENT_ACTIVATE, FOCUS_EVENT_DIRECTION }
enum  LayoutPosition { NUX_LAYOUT_BEGIN = 0, NUX_LAYOUT_END = 0x7fffffff }
enum  AreaMouseStatus {
  AREA_MOUSE_STATUS_NONE = 0L, AREA_MOUSE_STATUS_DOWN = (1L << 0), AREA_MOUSE_STATUS_UP = (1L << 1), AREA_MOUSE_STATUS_FOCUS = (1L << 2),
  AREA_MOUSE_STATUS_MOVE = (1L << 3), AREA_MOUSE_STATUS_ENTER = (1L << 4), AREA_MOUSE_STATUS_LEAVE = (1L << 5)
}
 State of the mouse on an area. More...
enum  NodeParameterType {
  NODE_TYPE_UNDEFINED = 1, NODE_TYPE_FOLDER, NODE_TYPE_BOOL, NODE_TYPE_CHECKBOX,
  NODE_TYPE_SPINBOX, NODE_TYPE_DOUBLESPINBOX, NODE_TYPE_COMBOSIMPLE, NODE_TYPE_COMBOCOMPLEX,
  NODE_TYPE_VECTOR3, NODE_TYPE_VECTOR4, NODE_TYPE_RGB, NODE_TYPE_RGBA,
  NODE_TYPE_STATICTEXT, NODE_TYPE_SPLINE, NODE_TYPE_EDITTEXT, NODE_TYPE_RANGE,
  NODE_TYPE_RANGEINTEGER, NODE_TYPE_INTVALUATOR, NODE_TYPE_DOUBLEVALUATOR, NODE_TYPE_VECTORVALUATOR,
  NODE_TYPE_COLORPREVIEW, NODE_TYPE_MATRIX4PREVIEW, NODE_TYPE_MATRIX3PREVIEW, NODE_TYPE_FORCE_DWORD = 0x7fffffff
}
enum  UXStyleImageRef {
  eIMAGE_STYLE_NONE = 0, eSTROKE_CORNER_SQUARE, eSTROKE_CORNER_ROUND1, eSTROKE_CORNER_ROUND2,
  eSTROKE_CORNER_ROUND4, eSTROKE_CORNER_ROUND10, eSHAPE_CORNER_SQUARE, eSHAPE_CORNER_ROUND1,
  eSHAPE_CORNER_ROUND2, eSHAPE_CORNER_ROUND4, eSHAPE_CORNER_ROUND10, eSHAPE_CORNER_ROUND10_SHADOW,
  eSHAPE_CORNER_ROUND4_SHADOW, eSHAPE_CORNER_SHADOW, eTRIANGLE_UP, eTRIANGLE_DOWN,
  eTRIANGLE_LEFT, eTRIANGLE_RIGHT, eWINDOW_SIZEGRIP, eSHAPE_CHECK_MARK,
  eSHAPE_CHECK_BOX_FOCUS, eSHAPE_CHECK_BOX_PRELIGHT, eSHAPE_CHECK_BOX, eCHECKBOX_NORMAL_ON,
  eCHECKBOX_NORMAL_OFF, eCHECKBOX_FOCUS_ON, eCHECKBOX_FOCUS_OFF, eCHECKBOX_PRELIGHT_ON,
  eCHECKBOX_PRELIGHT_OFF, eRADIO_NORMAL_ON, eRADIO_NORMAL_OFF, eRADIO_FOCUS_ON,
  eRADIO_FOCUS_OFF, eRADIO_PRELIGHT_ON, eRADIO_PRELIGHT_OFF, eBUTTON_NORMAL,
  eBUTTON_FOCUS, eBUTTON_PRELIGHT, eSPINNERUP, eSPINNERDOWN,
  eCOMBOBOX_OPEN_BUTTON, eTAB_LEFT, eTAB_RIGHT, eSPINER_UP,
  eSPINER_DOWN, eTREE_NODE_OPEN, eTREE_NODE_CLOSE, eSCROLLBAR_TRIANGLE_UP,
  eSCROLLBAR_TRIANGLE_DOWN, eSCROLLBAR_TRIANGLE_LEFT, eSCROLLBAR_TRIANGLE_RIGHT, eVECTORXLABEL,
  eVECTORYLABEL, eVECTORZLABEL, eVECTORWLABEL, eVALUATORVERTICALMOVE,
  eVALUATORHORIZONTALMOVE, eVALUATORMOVE, eHSCROLLBAR, eVSCROLLBAR,
  eMATRIX3PREVIEW, eMATRIX4PREVIEW, eDOT6x6, eGraphIcon,
  eGraphBarIcon, eWindowCloseButton
}
enum  EventCycleStatus {
  eSolveNone = (0L), eMouseEventSolved = (1L), eKeyEventSolved = (1L) << 1, eDoNotProcess = (1L) << 2,
  EVENT_CYCLE_EXCLUSIVE = (1L) << 3, EVENT_CYCLE_EXCLUSIVE_CONTINUE = (1L) << 4, EVENT_CYCLE_SOLVED = (1L) << 5, EVENT_CYCLE_DO_NOT_PROCESS = (1L) << 6,
  EVENT_CYCLE_RESET_AREA_STATE = (1L) << 7
}
enum  PositionPolicy {
  ePositionLeft, ePositionRight, ePositionCenter, ePositionFull,
  ePositionProportional
}
enum  SizePolicy { eSizeFixed, eSizeResizeable }
enum  ShapeCornerType {
  eCornerNone = 0, eCornerTopLeft = (1L), eCornerTopRight = (1L << 1), eCornerBottomLeft = (1L << 2),
  eCornerBottomRight = (1L << 3), eAllCorners = eCornerTopLeft | eCornerTopRight | eCornerBottomLeft | eCornerBottomRight
}
enum  TextureAlignment {
  eTACenter, eTALeft, eTARight, eTATop,
  eTABottom
}
enum  VerticalAlignment { eVACenter, eVATop, eVABottom }
enum  HorizontalAlignment { eHACenter, eHALeft, eHARight }
enum  eControlType {
  eNumericValuator, eSpinBox, eVector3Box, eBooleanBox,
  eStaticText, ePopupBox
}
enum  ConversionResult { conversionOK = 0, sourceExhausted, targetExhausted, sourceIllegal }
enum  ConversionFlags { strictConversion = 0, lenientConversion }
enum  { UNICODE_UTF32_BE = 0x0000FEFF }
enum  { UNICODE_UTF32_LE = 0xFFFE0000 }
enum  { UNICODE_UTF16_BE = 0xFEFF }
enum  { UNICODE_UTF16_LE = 0xFFFE }
enum  { UNICODE_UTF8 = 0xEFBBBF }
enum  { UNICODE_BOM = 0xfeff }
enum  MessageSeverity {
  NUX_MSG_SEVERITY_CRITICAL = 0, NUX_MSG_SEVERITY_ALERT = 1, NUX_MSG_SEVERITY_WARNING = 2, NUX_MSG_SEVERITY_INFO = 3,
  NUX_MSG_SEVERITY_NONE = 4
}
enum  EFileWrite {
  FILEWRITE_NOFAIL = 0x01, FILEWRITE_NOREPLACEEXISTING = 0x02, FILEWRITE_EVENIFREADONLY = 0x04, FILEWRITE_UNBUFFERED = 0x08,
  FILEWRITE_APPEND = 0x10, FILEWRITE_ALLOWREAD = 0x20
}
enum  ECopyResult {
  COPY_OK = 0x00, COPY_MISCFAIL = 0x01, COPY_READFAIL = 0x02, COPY_WRITEFAIL = 0x03,
  COPY_CANCELED = 0x06
}
enum  NUX_STATUS {
  NUX_OK, NUX_ERROR, NUX_FILENOTFOUND, NUX_COPYFILE_ERROR,
  NUX_DELETEFILE_ERROR
}
enum  ThreadState {
  THREADINIT, THREADRUNNING, THREADSUSPENDED, THREADSTOP,
  THREAD_START_ERROR, THREAD_STOP_ERROR, THREAD_SUSPEND_ERROR, THREAD_RESUME_ERROR
}
enum  MouseButton {
  NUX_INVALID_MOUSE_BUTTON = 0, NUX_MOUSE_BUTTON1 = 1, NUX_MOUSE_BUTTON2 = 2, NUX_MOUSE_BUTTON3 = 3,
  NUX_MOUSE_BUTTON4 = 4, NUX_MOUSE_BUTTON5 = 5, NUX_MOUSE_BUTTON6 = 6, NUX_LEFT_MOUSE = NUX_MOUSE_BUTTON1,
  NUX_MIDDLE_MOUSE = NUX_MOUSE_BUTTON2, NUX_RIGHT_MOUSE = NUX_MOUSE_BUTTON3
}
enum  KeyModifier {
  NUX_STATE_SHIFT = 0x00010000, NUX_STATE_CAPS_LOCK = 0x00020000, NUX_STATE_CTRL = 0x00040000, NUX_STATE_ALT = 0x00080000,
  NUX_STATE_NUMLOCK = 0x00100000, NUX_STATE_META = 0x00400000, NUX_STATE_SCROLLLOCK = 0x00800000
}
enum  NuxEventType {
  NUX_NO_EVENT = 0, NUX_MOUSE_PRESSED, NUX_MOUSE_RELEASED, NUX_MOUSE_MOVE,
  NUX_MOUSE_DOUBLECLICK, NUX_MOUSE_WHEEL, NUX_MOUSEWHEEL = NUX_MOUSE_WHEEL, NUX_KEYDOWN,
  NUX_KEYUP, NUX_SIZE_CONFIGURATION, NUX_WINDOW_MAP, NUX_WINDOW_UNMAP,
  NUX_WINDOW_CONFIGURATION, NUX_WINDOW_ENTER_FOCUS, NUX_WINDOW_EXIT_FOCUS, NUX_WINDOW_DIRTY,
  NUX_WINDOW_MOUSELEAVE, NUX_DESTROY_WINDOW, NUX_TERMINATE_APP, NUX_TAKE_FOCUS,
  NUX_DND_MOVE, NUX_DND_DROP, NUX_DND_ENTER, NUX_DND_LEAVE,
  NUX_DND_ENTER_WINDOW, NUX_DND_LEAVE_WINDOW
}
enum  _TextAlignment { eAlignTextNone = 0, eAlignTextLeft = 1, eAlignTextRight = 2, eAlignTextCenter = 3 }
enum  {
  GFXRS_FRONT_POLYGONMODE, GFXRS_BACK_POLYGONMODE, GFXRS_CULLFACEENABLE, GFXRS_CULLFACE,
  GFXRS_FRONTFACE, GFXRS_SCISSORTESTENABLE, GFXRS_FOGENABLE, GFXRS_ZTESTENABLE,
  GFXRS_ZWRITEENABLE, GFXRS_ZFUNC, GFXRS_ZNEAR, GFXRS_ZFAR,
  GFXRS_ALPHABLENDENABLE, GFXRS_BLENDOP, GFXRS_BLENDOPALPHA, GFXRS_SRCBLEND,
  GFXRS_DESTBLEND, GFXRS_SRCBLENDALPHA, GFXRS_DESTBLENDALPHA, GFXRS_ALPHATESTENABLE,
  GFXRS_ALPHATESTREF, GFXRS_ALPHATESTFUNC, GFXRS_STENCILENABLE, GFXRS_TWOSIDEDSTENCILENABLE,
  GFXRS_FRONT_STENCILWRITEMASK, GFXRS_BACK_STENCILWRITEMASK, GFXRS_FRONT_STENCILFUNC, GFXRS_FRONT_STENCILREF,
  GFXRS_FRONT_STENCILMASK, GFXRS_FRONT_STENCILFAIL, GFXRS_FRONT_STENCILZFAIL, GFXRS_FRONT_STENCILZPASS,
  GFXRS_BACK_STENCILFUNC, GFXRS_BACK_STENCILREF, GFXRS_BACK_STENCILMASK, GFXRS_BACK_STENCILFAIL,
  GFXRS_BACK_STENCILZFAIL, GFXRS_BACK_STENCILZPASS, GFXRS_POINTSMOOTHENABLE, GFXRS_LINESMOOTHENABLE,
  GFXRS_POINTSIZE, GFXRS_LINEWIDTH, GFXRS_POINTHINT, GFXRS_LINEHINT,
  GFXRS_COLORWRITEENABLE_R, GFXRS_COLORWRITEENABLE_G, GFXRS_COLORWRITEENABLE_B, GFXRS_COLORWRITEENABLE_A,
  GFXRS_POLYGONOFFSETENABLE, GFXRS_POLYGONOFFSETFACTOR, GFXRS_POLYGONOFFSETUNITS, GFXRS_MAX_RENDERSTATES
}
enum  {
  GFXSS_ADDRESSU, GFXSS_ADDRESSV, GFXSS_ADDRESSW, GFXSS_MINFILTER,
  GFXSS_MAGFILTER, GFXSS_MIPMAPFILTER, GFXSS_MIPMAPLODBIAS, GFXSS_MAXANISOTROPY,
  GFXSS_SRGBWRITEENABLE, GFXSS_MAX_SAMPLERSTATES
}
enum  PorterDuffOperator {
  CLEAR = 0, SRC, DST, SRC_OVER,
  DST_OVER, SRC_IN, DST_IN, SRC_OUT,
  DST_OUT, SRC_ATOP, DST_ATOP, XOR,
  PLUS
}
enum  {
  OGL_OK = 0, OGL_ERROR, OGL_ERROR_UNKNOWN, OGL_INVALID_SURFACE_LEVEL,
  OGL_INVALID_CALL, OGL_INVALID_LOCK, OGL_INVALID_UNLOCK, OGL_INVALID_TEXTURE,
  OGL_FORCE_DWORD = 0x7fffffff
}
enum  TEXTURE_FORMAT {
  TEXTURE_FMT_UNKNOWN = 0, TEXTURE_FMT_ALPHA = GL_ALPHA, TEXTURE_FMT_ALPHA8 = GL_ALPHA8, TEXTURE_FMT_ALPHA16 = GL_ALPHA16,
  TEXTURE_FMT_LUMINANCE = GL_LUMINANCE, TEXTURE_FMT_LUMINANCE8 = GL_LUMINANCE8, TEXTURE_FMT_LUMINANCE16 = GL_LUMINANCE16, TEXTURE_FMT_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA,
  TEXTURE_FMT_LUMINANCE8_ALPHA8 = GL_LUMINANCE8_ALPHA8, TEXTURE_FMT_LUMINANCE16_ALPHA16 = GL_LUMINANCE16_ALPHA16, TEXTURE_FMT_INTENSITY = GL_INTENSITY, TEXTURE_FMT_INTENSITY8 = GL_INTENSITY8,
  TEXTURE_FMT_INTENSITY16 = GL_INTENSITY16, TEXTURE_FMT_GL_DEPTH_COMPONENT = GL_DEPTH_COMPONENT, TEXTURE_FMT_GL_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24, TEXTURE_FMT_RGBA = GL_RGBA,
  TEXTURE_FMT_RGBA8 = GL_RGBA8, TEXTURE_FMT_RGBA16 = GL_RGBA16, TEXTURE_FMT_RGBA16F_ARB = GL_RGBA16F_ARB, TEXTURE_FMT_RGBA32F_ARB = GL_RGBA32F_ARB,
  TEXTURE_FMT_RGB = GL_RGB, TEXTURE_FMT_RGB8 = GL_RGB8, TEXTURE_FMT_RGB16 = GL_RGB16, TEXTURE_FMT_RGB16F_ARB = GL_RGB16F_ARB,
  TEXTURE_FMT_RGB32F_ARB = GL_RGB32F_ARB, TEXTURE_FMT_COMPRESSED_RGB_S3TC_DXT1_EXT = GL_COMPRESSED_RGB_S3TC_DXT1_EXT, TEXTURE_FMT_COMPRESSED_RGBA_S3TC_DXT1_EXT = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, TEXTURE_FMT_COMPRESSED_RGBA_S3TC_DXT3_EXT = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
  TEXTURE_FMT_COMPRESSED_RGBA_S3TC_DXT5_EXT = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, TEXTURE_FMT_FORCE_DWORD = 0x7fffffff
}
enum  eCUBEMAP_FACES {
  CUBEMAP_FACE_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X, CUBEMAP_FACE_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X, CUBEMAP_FACE_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y, CUBEMAP_FACE_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
  CUBEMAP_FACE_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z, CUBEMAP_FACE_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, CUBEMAP_FACE_FORCE_DWORD = 0x7fffffff
}
enum  VBO_USAGE {
  VBO_USAGE_UNKNOWN = 0, VBO_USAGE_STATIC = GL_STATIC_DRAW, VBO_USAGE_DYNAMIC = GL_DYNAMIC_DRAW, VBO_USAGE_STREAM = GL_STREAM_DRAW,
  VBO_USAGE_FORCE_DWORD = 0x7fffffff
}
enum  INDEX_FORMAT { INDEX_FORMAT_UNKNOWN = 0, INDEX_FORMAT_USHORT = GL_UNSIGNED_SHORT, INDEX_FORMAT_UINT = GL_UNSIGNED_INT, INDEX_FORMAT_FORCE_DWORD = 0x7fffffff }
enum  PRIMITIVE_TYPE {
  PRIMITIVE_TYPE_POINTLIST = GL_POINTS, PRIMITIVE_TYPE_LINELIST = GL_LINES, PRIMITIVE_TYPE_LINESTRIP = GL_LINE_STRIP, PRIMITIVE_TYPE_TRIANGLELIST = GL_TRIANGLES,
  PRIMITIVE_TYPE_TRIANGLESTRIP = GL_TRIANGLE_STRIP, PRIMITIVE_TYPE_TRIANGLEFAN = GL_TRIANGLE_FAN, PRIMITIVE_TYPE_QUADLIST = GL_QUADS, PRIMITIVE_TYPE_QUADSTRIP = GL_QUAD_STRIP,
  PRIMITIVE_TYPE_FORCE_DWORD = 0x7fffffff
}
enum  OpenGLResourceType {
  RTINDEXBUFFER, RTVERTEXBUFFER, RTSURFACE, RTVOLUME,
  RTBASETEXTURE, RTTEXTURE, RTTEXTURERECTANGLE, RTCUBETEXTURE,
  RTVOLUMETEXTURE, RTANIMATEDTEXTURE, RTVERTEXDECLARATION, RTQUERY,
  RTFRAMEBUFFEROBJECT, RT_GLSL_VERTEXSHADER, RT_GLSL_PIXELSHADER, RT_GLSL_GEOMETRYSHADER,
  RT_GLSL_SHADERPROGRAM, RT_CG_VERTEXSHADER, RT_CG_PIXELSHADER, RT_FORCE_DWORD = 0x7fffffff
}
enum  MULTISAMPLE_TYPE {
  MULTISAMPLE_TYPE_NONE = 0, MULTISAMPLE_TYPE_NONMASKABLE = 1, MULTISAMPLE_TYPE_2_SAMPLES = 2, MULTISAMPLE_TYPE_3_SAMPLES = 3,
  MULTISAMPLE_TYPE_4_SAMPLES = 4, MULTISAMPLE_TYPE_5_SAMPLES = 5, MULTISAMPLE_TYPE_6_SAMPLES = 6, MULTISAMPLE_TYPE_7_SAMPLES = 7,
  MULTISAMPLE_TYPE_8_SAMPLES = 8, MULTISAMPLE_TYPE_9_SAMPLES = 9, MULTISAMPLE_TYPE_10_SAMPLES = 10, MULTISAMPLE_TYPE_11_SAMPLES = 11,
  MULTISAMPLE_TYPE_12_SAMPLES = 12, MULTISAMPLE_TYPE_13_SAMPLES = 13, MULTISAMPLE_TYPE_14_SAMPLES = 14, MULTISAMPLE_TYPE_15_SAMPLES = 15,
  MULTISAMPLE_TYPE_16_SAMPLES = 16, MULTISAMPLE_TYPE_FORCE_DWORD = 0x7fffffff
}
enum  MEM_POOL {
  MEM_POOL_DEFAULT = 0, MEM_POOL_MANAGED = 1, MEM_POOL_SYSTEMMEM = 2, MEM_POOL_SCRATCH = 3,
  MEM_POOL_FORCE_DWORD = 0x7fffffff
}
enum  _ATTRIB_DECL_TYPE {
  ATTRIB_DECLTYPE_UNKNOWN = 0, ATTRIB_DECLTYPE_FLOAT1, ATTRIB_DECLTYPE_FLOAT2, ATTRIB_DECLTYPE_FLOAT3,
  ATTRIB_DECLTYPE_FLOAT4, ATTRIB_DECLTYPE_COLOR, ATTRIB_DECLTYPE_UBYTE4, ATTRIB_DECLTYPE_SHORT2,
  ATTRIB_DECLTYPE_SHORT4, ATTRIB_DECLTYPE_UBYTE4N, ATTRIB_DECLTYPE_SHORT2N, ATTRIB_DECLTYPE_SHORT4N,
  ATTRIB_DECLTYPE_USHORT2N, ATTRIB_DECLTYPE_USHORT4N, ATTRIB_DECLTYPE_UDEC3, ATTRIB_DECLTYPE_DEC3N,
  ATTRIB_DECLTYPE_FLOAT16_2, ATTRIB_DECLTYPE_FLOAT16_4, ATTRIB_DECLTYPE_UNUSED, ATTRIB_DECLTYPE_FORCE_DWORD = 0x7fffffff
}
enum  _ATTRIB_COMPONENT_TYPE {
  ATTRIB_CT_UNKNOWN = 0, ATTRIB_CT_BYTE = GL_BYTE, ATTRIB_CT_UNSIGNED_BYTE = GL_UNSIGNED_BYTE, ATTRIB_CT_SHORT = GL_SHORT,
  ATTRIB_CT_UNSIGNED_SHORT = GL_UNSIGNED_SHORT, ATTRIB_CT_INT = GL_INT, ATTRIB_CT_UNSIGNED_INT = GL_UNSIGNED_INT, ATTRIB_CT_FLOAT = GL_FLOAT,
  ATTRIB_CT_HALF_FLOAT = GL_HALF_FLOAT_ARB, ATTRIB_CT_DOUBLE = GL_DOUBLE, ATTRIB_CT_FORCE_DWORD = 0x7fffffff
}
enum  ATTRIB_USAGE_DECL {
  ATTRIB_USAGE_DECL_POSITION = 0, ATTRIB_USAGE_DECL_BLENDWEIGHT = 1, ATTRIB_USAGE_DECL_NORMAL = 2, ATTRIB_USAGE_DECL_COLOR = 3,
  ATTRIB_USAGE_DECL_COLOR1 = 4, ATTRIB_USAGE_DECL_FOGCOORD = 5, ATTRIB_USAGE_DECL_PSIZE = 6, ATTRIB_USAGE_DECL_BLENDINDICES = 7,
  ATTRIB_USAGE_DECL_TEXCOORD = 8, ATTRIB_USAGE_DECL_TEXCOORD0 = 8, ATTRIB_USAGE_DECL_TEXCOORD1 = 9, ATTRIB_USAGE_DECL_TEXCOORD2 = 10,
  ATTRIB_USAGE_DECL_TEXCOORD3 = 11, ATTRIB_USAGE_DECL_TEXCOORD4 = 12, ATTRIB_USAGE_DECL_TEXCOORD5 = 13, ATTRIB_USAGE_DECL_TEXCOORD6 = 14,
  ATTRIB_USAGE_DECL_TEXCOORD7 = 15, ATTRIB_USAGE_DECL_TANGENT = 14, ATTRIB_USAGE_DECL_BINORMAL = 15, ATTRIB_USAGE_DECL_FORCE_DWORD = 0x7fffffff
}
enum  QUERY_TYPE {
  QUERY_TYPE_VCACHE = 4, QUERY_TYPE_RESOURCEMANAGER = 5, QUERY_TYPE_VERTEXSTATS = 6, QUERY_TYPE_EVENT = 8,
  QUERY_TYPE_OCCLUSION = 9, QUERY_TYPE_SCREENEXTENT = 10, QUERY_TYPE_FORCE_DWORD = 0x7fffffff
}
enum  EResourceUpdateHint { RUH_Static, RUH_CacheableDynamic, RUH_Dynamic }
enum  eShaderParameterType { eVERTEXUNIFORMTYPE, eFRAGMENTUNIFORMTYPE, eSAMPLERUNIFORMTYPE }
 Type of shader in a shader.
enum  eShaderType { eVERTEXSHADERTYPE, eFRAGMENTSHADERTYPE }
 Type of shader.
enum  {
  GFXTS_ADDRESSU, GFXTS_ADDRESSV, GFXTS_ADDRESSW, GFXTS_MINFILTER,
  GFXTS_MAGFILTER, GFXTS_MIPFILTER, GFXTS_MIP_BASE_LEVEL, GFXTS_MIP_MAX_LEVEL,
  GFXTS_MIN_LOD, GFXTS_MAX_LOD, GFXTS_BORDERCOLOR, GFXTS_MAX_TEXTURESTATES
}
enum  GpuBrand { GPU_VENDOR_UNKNOWN = 0, GPU_BRAND_AMD, GPU_BRAND_NVIDIA, GPU_BRAND_INTEL }
 Brand of GPUs.
enum  WindowStyle {
  WINDOWSTYLE_NORMAL, WINDOWSTYLE_PANEL, WINDOWSTYLE_DIALOG, WINDOWSTYLE_TOOL,
  WINDOWSTYLE_NOBORDER, WINDOWSTYLE_NORMAL, WINDOWSTYLE_PANEL, WINDOWSTYLE_DIALOG,
  WINDOWSTYLE_TOOL, WINDOWSTYLE_NOBORDER
}
enum  WindowStyle {
  WINDOWSTYLE_NORMAL, WINDOWSTYLE_PANEL, WINDOWSTYLE_DIALOG, WINDOWSTYLE_TOOL,
  WINDOWSTYLE_NOBORDER, WINDOWSTYLE_NORMAL, WINDOWSTYLE_PANEL, WINDOWSTYLE_DIALOG,
  WINDOWSTYLE_TOOL, WINDOWSTYLE_NOBORDER
}
enum  DndAction {
  DNDACTION_COPY, DNDACTION_MOVE, DNDACTION_LINK, DNDACTION_ASK,
  DNDACTION_PRIVATE, DNDACTION_NONE
}
enum  VtxAttributeIndex {
  VTXATTRIB_INVALID = -1, VTXATTRIB_POSITION = 0, VTXATTRIB_WEIGHT = 1, VTXATTRIB_NORMAL = 2,
  VTXATTRIB_COLOR = 3, VTXATTRIB_COLOR_PRIMARY = 3, VTXATTRIB_COLOR_SECONDARY = 4, VTXATTRIB_FOGCOORD = 5,
  VTXATTRIB_TEXCOORD = 8, VTXATTRIB_TEXCOORD0 = 8, VTXATTRIB_TEXCOORD1 = 9, VTXATTRIB_TEXCOORD2 = 10,
  VTXATTRIB_TEXCOORD3 = 11, VTXATTRIB_TEXCOORD4 = 12, VTXATTRIB_TEXCOORD5 = 13, VTXATTRIB_TEXCOORD6 = 14,
  VTXATTRIB_TEXCOORD7 = 15
}
enum  VertexAttributeType {
  VAT_UNDEFINED = 0, VAT_FLOAT = 1, VAT_FLOAT2, VAT_FLOAT3,
  VAT_FLOAT4, VAT_FLOAT_MAT2, VAT_FLOAT_MAT3, VAT_FLOAT_MAT4
}
enum  ShaderType { SHADER_TYPE_GLSL = 0, SHADER_TYPE_CG, SHADER_TYPE_FORCE_DWORD = 0x7fffffff }
enum  NuxMeshPrimitiveType {
  NUX_MESH_PRIMITIVE_UNKNOWN = 0, NUX_MESH_TRIANGLE, NUX_MESH_TRIANGLE_STRIP, NUX_MESH_TRIANGLE_FAN,
  NUX_MESH_LINE, NUX_MESH_LINE_STRIP, NUX_MESH_LINE_LOOP, NUX_MESH_POINT,
  NUX_MESH_QUAD, NUX_MESH_QUAD_STRIP
}
enum  TexWrap {
  TEXWRAP_UNKNOWN = 0, TEXWRAP_REPEAT, TEXWRAP_CLAMP, TEXWRAP_CLAMP_TO_EDGE,
  TEXWRAP_CLAMP_TO_BORDER, TEXWRAP_MIRRORED_REPEAT, TEXWRAP_MIRROR_CLAMP_EXT, TEXWRAP_MIRROR_CLAMP_TO_EDGE_EXT,
  TEXWRAP_MIRROR_CLAMP_TO_BORDER_EXT
}
 Graphics wraping modes. More...
enum  TexFilter {
  TEXFILTER_UNKNOWN = 0, TEXFILTER_LINEAR, TEXFILTER_NEAREST, TEXFILTER_NEAREST_MIPMAP_NEAREST,
  TEXFILTER_LINEAR_MIPMAP_NEAREST, TEXFILTER_NEAREST_MIPMAP_LINEAR, TEXFILTER_LINEAR_MIPMAP_LINEAR
}
 Graphics filtering modes. More...
enum  RopBlend {
  ROPBLEND_UNKNOWN = 0, ROPBLEND_ZERO, ROPBLEND_ONE, ROPBLEND_SRC_COLOR,
  ROPBLEND_ONE_MINUS_SRC_COLOR, ROPBLEND_DST_COLOR, ROPBLEND_ONE_MINUS_DST_COLOR, ROPBLEND_SRC_ALPHA,
  ROPBLEND_ONE_MINUS_SRC_ALPHA, ROPBLEND_DST_ALPHA, ROPBLEND_ONE_MINUS_DST_ALPHA, ROPBLEND_CONSTANT_COLOR,
  ROPBLEND_ONE_MINUS_CONSTANT_COLOR, ROPBLEND_CONSTANT_ALPHA, ROPBLEND_ONE_MINUS_CONSTANT_ALPHA, ROPBLEND_SRC_ALPHA_SATURATE
}
 Graphics blend modes. More...
enum  BitmapFormat {
  BITFMT_UNKNOWN = 0, BITFMT_R8G8B8A8, BITFMT_A8B8G8R8, BITFMT_B8G8R8A8,
  BITFMT_A8R8G8B8, BITFMT_R8G8B8, BITFMT_B8G8R8, BITFMT_R5G6B5,
  BITFMT_RGBA16F, BITFMT_RGB32F, BITFMT_RGBA32F, BITFMT_D24S8,
  BITFMT_DXT1, BITFMT_DXT2, BITFMT_DXT3, BITFMT_DXT4,
  BITFMT_DXT5, BITFMT_R10G10B10A2, BITFMT_B10G10R10A2, BITFMT_A2R10G10B10,
  BITFMT_A2B10G10R10, BITFMT_A8, BITFMT_END_GFX_FORMATS, BITFMT_X8R8G8B8,
  BITFMT_X8B8G8R8, BITFMT_X1R5G5B5, BITFMT_A1R5G5B5, BITFMT_A4R4G4B4,
  BITFMT_X4R4G4B4, BITFMT_A8R3G3B2, BITFMT_R3G3B2
}

Functions

 NUX_IMPLEMENT_OBJECT_TYPE (Tooltip)
void DrawCairo (cairo_t *cr, gboolean outline, gfloat line_width, gfloat *rgba, gboolean negative, gboolean stroke)
void ComputeMask (cairo_t *cr)
 NUX_IMPLEMENT_OBJECT_TYPE (AbstractButton)
 NUX_IMPLEMENT_OBJECT_TYPE (AbstractThread)
 NUX_IMPLEMENT_OBJECT_TYPE (ActionItem)
 NUX_IMPLEMENT_OBJECT_TYPE (Area)
 NUX_IMPLEMENT_OBJECT_TYPE (BaseWindow)
int ClosestCubicBezierEndPoint (int i)
 NUX_IMPLEMENT_OBJECT_TYPE (Button)
 NUX_IMPLEMENT_OBJECT_TYPE (CheckBox)
 NUX_IMPLEMENT_OBJECT_TYPE (FloatingWindow)
 NUX_IMPLEMENT_OBJECT_TYPE (GridHLayout)
 NUX_IMPLEMENT_OBJECT_TYPE (GridVLayout)
 NUX_IMPLEMENT_OBJECT_TYPE (HLayout)
 NUX_IMPLEMENT_OBJECT_TYPE (HSplitter)
 NUX_IMPLEMENT_OBJECT_TYPE (InputArea)
 NUX_IMPLEMENT_OBJECT_TYPE (LayeredLayout)
 NUX_IMPLEMENT_OBJECT_TYPE (Layout)
 NUX_IMPLEMENT_OBJECT_TYPE (SpaceLayout)
 NUX_IMPLEMENT_ROOT_OBJECT_TYPE (MenuBarItem)
 NUX_IMPLEMENT_OBJECT_TYPE (MenuBar)
 NUX_IMPLEMENT_OBJECT_TYPE (MenuItem)
 NUX_IMPLEMENT_OBJECT_TYPE (MenuSeparator)
 NUX_IMPLEMENT_OBJECT_TYPE (MenuPage)
 NUX_IMPLEMENT_ROOT_OBJECT_TYPE (NodeItem)
 NUX_IMPLEMENT_OBJECT_TYPE (NodeNetCom)
const char * ConvertTypeToString (NodeParameterType type)
bool QueryNodeXMLIntAttribute (const TiXmlElement *elementxml, const TCHAR *attribute, int *Value, int searchid)
bool QueryNodeXMLDoubleAttribute (const TiXmlElement *elementxml, const TCHAR *attribute, double *Value, int searchid)
bool QueryNodeXMLStringAttribute (const TiXmlElement *elementxml, const TCHAR *attribute, tstring &Value, int searchid)
bool QueryNodeXMLAttribute (const TiXmlElement *elementxml, const TCHAR *attribute, std::string &Value, int searchid)
void NuxInitialize (const TCHAR *CommandLine)
WindowThreadCreateGUIThread (const TCHAR *WindowTitle, t_u32 width, t_u32 height, WindowThread *Parent=NULL, ThreadUserInitFunc UserInitFunc=NULL, void *InitData=NULL)
 Create a main graphics thread. This thread has a window and no parent window (The Parent parameter should always be null).
WindowThreadCreateWindowThread (WindowStyle WndStyle, const TCHAR *WindowTitle, t_u32 width, t_u32 height, WindowThread *Parent, ThreadUserInitFunc UserInitFunc, void *InitData)
WindowThreadCreateModalWindowThread (WindowStyle WndStyle, const TCHAR *WindowTitle, t_u32 width, t_u32 height, WindowThread *Parent, ThreadUserInitFunc UserInitFunc, void *InitData)
SystemThreadCreateSystemThread (AbstractThread *Parent, ThreadUserInitFunc UserInitFunc, void *InitData)
bool RegisterNuxThread (NThread *ThreadPtr)
void UnregisterNuxThread (NThread *ThreadPtr)
ThreadState GetThreadState (unsigned int ThreadID)
ObjectPtr< FontTextureGetSysFont ()
ObjectPtr< FontTextureGetSysBoldFont ()
WindowCompositorGetWindowCompositor ()
NThreadGetThreadApplication ()
WindowThreadGetGraphicsThread ()
WindowThreadGetWindowThread ()
BasePainterGetPainter ()
UXThemeGetTheme ()
TimerHandlerGetTimer ()
GraphicsDisplayGetWindow ()
GraphicsEngineGetGraphicsEngine ()
 inlDeclareThreadLocalStorage (NThread *, 0, ThreadLocal_InalogicAppImpl)
Geometry ComputeGeometryPositioning (const Geometry &container_geo, const Geometry &content_geo, GeometryPositioning gctx)
 Compute the position of one geometry inside an other.
 NUX_IMPLEMENT_OBJECT_TYPE (RGBValuator)
 NUX_IMPLEMENT_OBJECT_TYPE (ScrollView)
 NUX_IMPLEMENT_OBJECT_TYPE (StaticTextBox)
 NUX_IMPLEMENT_OBJECT_TYPE (SystemThread)
void PresentBufferToScreen (ObjectPtr< IOpenGLBaseTexture > texture, int x, int y)
 NUX_IMPLEMENT_OBJECT_TYPE (TextEntry)
 NUX_IMPLEMENT_OBJECT_TYPE (TextureArea)
 NUX_IMPLEMENT_OBJECT_TYPE (TimeGraph)
bool IsMouseOwned ()
 NUX_IMPLEMENT_OBJECT_TYPE (View)
 NUX_IMPLEMENT_OBJECT_TYPE (VLayout)
 NUX_IMPLEMENT_OBJECT_TYPE (VSplitter)
gboolean nux_event_dispatch (GSource *source, GSourceFunc callback, gpointer user_data)
gboolean nux_timeout_dispatch (gpointer user_data)
 NUX_IMPLEMENT_OBJECT_TYPE (WindowThread)
unsigned int SpawnThread (NThread &thread)
TCHAR ToUpperCase (TCHAR c)
TCHAR ToLowerCase (TCHAR c)
bool IsUpperCase (TCHAR c)
bool IsLowerCase (TCHAR c)
bool IsAlphaChar (TCHAR c)
bool IsDigitChar (TCHAR c)
bool IsAlphanumericChar (TCHAR c)
bool IsWhitespaceChar (TCHAR c)
bool IsLinebreakChar (TCHAR c)
bool IsSpaceChar (TCHAR c)
 Returns nonzero if character is a space character.
ConversionResult ConvertUTF32toUTF16 (const t_UTF32 **sourceStart, const t_UTF32 *sourceEnd, t_UTF16 **targetStart, t_UTF16 *targetEnd, ConversionFlags flags)
ConversionResult ConvertUTF16toUTF32 (const t_UTF16 **sourceStart, const t_UTF16 *sourceEnd, t_UTF32 **targetStart, t_UTF32 *targetEnd, ConversionFlags flags)
ConversionResult ConvertUTF16toUTF8 (const t_UTF16 **sourceStart, const t_UTF16 *sourceEnd, t_UTF8 **targetStart, t_UTF8 *targetEnd, ConversionFlags flags)
bool isLegalUTF8Sequence (const t_UTF8 *source, const t_UTF8 *sourceEnd)
bool tr_utf8_validate (const char *str, int max_len, const char **end)
 This is a variation of isLegalUTF8Sequence() that behaves like g_utf8_validate().
ConversionResult ConvertUTF8toUTF16 (const t_UTF8 **sourceStart, const t_UTF8 *sourceEnd, t_UTF16 **targetStart, t_UTF16 *targetEnd, ConversionFlags flags)
ConversionResult ConvertUTF32toUTF8 (const t_UTF32 **sourceStart, const t_UTF32 *sourceEnd, t_UTF8 **targetStart, t_UTF8 *targetEnd, ConversionFlags flags)
ConversionResult ConvertUTF8toUTF32 (const t_UTF8 **sourceStart, const t_UTF8 *sourceEnd, t_UTF32 **targetStart, t_UTF32 *targetEnd, ConversionFlags flags)
TCHAR ConvertUnicodeCharToTCHAR (UNICHAR In)
UNICHAR ConvertTCHARToUnicodeChar (TCHAR In)
TCHAR ConvertAnsiCharToTCHAR (ANSICHAR In)
ANSICHAR ConvertTCHARToAnsiChar (TCHAR In)
ANSICHAR ConvertUnicodeCharToAnsiChar (UNICHAR In)
UNICHAR ConvertAnsiCharToUnicodeChar (ANSICHAR In)
bool LoadFileToArray (std::vector< BYTE > &Result, const TCHAR *Filename, NFileManager &FileManager)
bool LoadTextFileToAnsiArray (std::vector< ANSICHAR > &Result, const TCHAR *Filename, NFileManager &FileManager)
bool LoadTextFileToUnicodeArray (std::vector< UNICHAR > &Result, const TCHAR *Filename, NFileManager &FileManager)
bool LoadFileToString (NString &Result, const TCHAR *Filename, NFileManager &FileManager)
bool SaveArrayToFile (const std::vector< BYTE > &Array, const TCHAR *Filename, NFileManager &FileManager)
bool SaveStringToFile (const NString &String, const TCHAR *Filename, NFileManager &FileManager)
 NUX_IMPLEMENT_GLOBAL_OBJECT (NFileManagerGNU)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_char &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_bool &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_s8 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_u8 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_u16 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_s16 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_uint32 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_int32 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_long &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_ulong &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_float &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_double &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_u64 &v)
NUX_INLINE NSerializeroperator<< (NSerializer &Sr, t_s64 &v)
 NUX_IMPLEMENT_OBJECT_TYPE (InitiallyUnownedObject)
int PointInside2DPolygon (Point2 *polygon, int n, Point2 pt, const int onedge)
 Determine if a point lies inside a polygon.
NUX_DECLSPEC_DLL t_double * Bernstein (t_int n, t_double t)
 Evaluate the Bernstein polynomial of degree n, at parameter t.
NUX_DECLSPEC_DLL void Bezier_XY (t_int n, t_double t, t_double xcon[], t_double ycon[], t_double *xval, t_double *yval)
 Evaluate 2D Bezier curve of degree n.
NUX_DECLSPEC_DLL void Bezier_XYZ (t_int n, t_double t, t_double xcon[], t_double ycon[], t_double zcon[], t_double *xval, t_double *yval, t_double *zval)
 Evaluate 2D Bezier curve of degree n.
const ComplexNumber operator+ (const ComplexNumber &lhs, const ComplexNumber &rhs)
const ComplexNumber operator- (const ComplexNumber &lhs, const ComplexNumber &rhs)
const ComplexNumber operator* (const ComplexNumber &lhs, const ComplexNumber &rhs)
const ComplexNumber operator/ (const ComplexNumber &lhs, const ComplexNumber &rhs)
t_int Factorial (t_int n)
t_double BinomialCoefficient (t_int n, t_int k)
t_double Power (t_double x, t_double y)
t_double Log2 (t_double d)
t_double Floor (t_double d)
template<class T >
PowerInt (T _X, int _Y)
template<typename T >
Square (const T A)
template<typename T >
Clamp (const T X, const T min_value, const T max_value)
template<typename T >
ClampUp (const T X, const T min_value)
template<typename T >
ClampDown (const T X, const T max_value)
template<typename T >
Align (const T Ptr, int Alignment)
template<typename T >
const T Rol (const T &a, const unsigned int n=1)
template<typename T >
const T Ror (const T &a, const unsigned int n=1)
template<typename T >
const T Abs (const T &a)
 Return the absolute value of a.
template<typename T >
const T & Min (const T &a, const T &b)
 Return the minimum between a and b.
template<typename T >
const T & Min (const T &a, const T &b, const T &c)
 Return the minimum between a, b and c.
template<typename T >
const T & Min (const T &a, const T &b, const T &c, const T &d)
 Return the minimum between a, b, c and d.
template<typename T >
const T & Max (const T &a, const T &b)
 Return the maximum between a and b.
template<typename T >
const T & Max (const T &a, const T &b, const T &c)
 Return the maximum between a, b and c.
template<typename T >
const T & Max (const T &a, const T &b, const T &c, const T &d)
 Return the maximum between a,b,c and d.
template<typename T >
Max3 (const T A, const T B, const T C)
template<typename T >
Min3 (const T A, const T B, const T C)
template<typename T >
Sign (const T &x)
 Return the sign of x.
template<typename T >
Modulo (const T &x, const T &m)
int ModuloInt (const int x, const int m)
template<typename T >
MinMod (const T &a, const T &b)
double Random ()
 Return a random variable between [0,1[ (uniform distribution).
double CRandom ()
 Return a random variable between [-1,1[ (uniform distribution).
double RandomGaussian ()
 Return a random variable using a gaussian distribution and a variance of 1.
unsigned int RandomUInt ()
unsigned int RandomUInt (unsigned int max_random)
t_size DiffPointer (void *Ptr0, void *Ptr1)
template<typename T >
SubstractPointer (void *Ptr, t_size Value)
template<typename T >
AddPointer (void *Ptr, t_size Value)
template<typename T >
RoundUp (T Value, int Alignment)
 Round up to the nearest multiple of Alignment that is greater or equal to Value.
template<typename T >
RoundDown (T Value, int Alignment)
 Round down to the nearest multiple of Alignment that is smaller or equal to Value.
template<typename T >
bool IsAligned (T Value, int Alignment)
 Return true is Value is aligned on Alignment.
t_u16 ReverseByteOrdering (t_u16 value)
t_u32 ReverseByteOrdering (t_u32 value)
t_u64 ReverseByteOrdering (t_u64 value)
bool IsPowerOf2 (unsigned int n)
unsigned int NextPowerOfTwo (unsigned int x)
unsigned int GetLowerPowerOfTwoExponent (unsigned int x)
unsigned int PowerOfTwo (int i)
unsigned int Hak32_ClearLSBBit (unsigned int N)
unsigned int Hak32_CountNumBits (unsigned int N)
unsigned int Hak32_BitParity (unsigned int N)
bool Hak32_CPULittleEndian ()
unsigned int Hak32_Log2 (unsigned int N)
unsigned int Hak32_Log10 (unsigned int N)
unsigned int Hack32_TrailingZeroRight (unsigned int N)
template<typename T >
Matrix2x2< T > operator* (const T &lhs, const Matrix2x2< T > &rhs)
template<typename T >
Matrix3x3< T > operator* (const T &lhs, const Matrix3x3< T > &rhs)
template<typename T >
Matrix4x4< T > operator* (const T &lhs, const Matrix4x4< T > &rhs)
template<typename T >
bool operator== (const Point2D< T > &lhs, const Point2D< T > &rhs)
template<typename T >
bool operator!= (const Point2D< T > &lhs, const Point2D< T > &rhs)
Quaternion operator* (float f, const Quaternion &quat)
Quaternion Slerp (const float t, const Quaternion &lhs, const Quaternion &rhs)
double * d3_np_fs (int n, double a[], double b[])
double * spline_cubic_set (int n, double t[], double y[], int ibcbeg, double ybcbeg, int ibcend, double ybcend)
double spline_cubic_val (int n, double t[], double tval, double y[], double ypp[], double *ypval, double *yppval)
Vector3 SphericalToCartesianXBaseDeg (float r, float theta, float phi)
Vector3 SphericalToCartesianXBaseRad (float r, float theta, float phi)
Vector3 SphericalToCartesianZBaseDeg (float r, float theta, float phi)
Vector3 SphericalToCartesianZBaseRad (float r, float theta, float phi)
Vector3 CartesianToSphericalXBaseRad (float x, float y, float z)
Vector3 CartesianToSphericalZBaseDeg (float x, float y, float z)
double BackEaseIn (double t, double b, double c, double d, double s)
double BackEaseOut (double t, double b, double c, double d, double s)
double BackEaseInOut (double t, double b, double c, double d, double s)
double BounceEaseOut (double t, double b, double c, double d)
double BounceEaseIn (double t, double b, double c, double d)
double BounceEaseInOut (double t, double b, double c, double d)
double CircEaseIn (double t, double b, double c, double d)
double CircEaseOut (double t, double b, double c, double d)
double CircEaseInOut (double t, double b, double c, double d)
double CubicEaseIn (double t, double b, double c, double d)
double CubicEaseOut (double t, double b, double c, double d)
double CubicEaseInOut (double t, double b, double c, double d)
double ElasticEaseIn (double t, double b, double c, double d, double a, double p)
double ElasticEaseOut (double t, double b, double c, double d, double a, double p)
double ElasticEaseInOut (double t, double b, double c, double d, double a, double p)
double ExpoEaseIn (double t, double b, double c, double d)
double ExpoEaseOut (double t, double b, double c, double d)
double ExpoEaseInOut (double t, double b, double c, double d)
double LinearEaseNone (double t, double b, double c, double d)
double LinearEaseIn (double t, double b, double c, double d)
double LinearEaseOut (double t, double b, double c, double d)
double LinearEaseInOut (double t, double b, double c, double d)
double QuadEaseIn (double t, double b, double c, double d)
double QuadEaseOut (double t, double b, double c, double d)
double QuadEaseInOut (double t, double b, double c, double d)
double QuartEaseIn (double t, double b, double c, double d)
double QuartEaseOut (double t, double b, double c, double d)
double QuartEaseInOut (double t, double b, double c, double d)
double QuintEaseIn (double t, double b, double c, double d)
double QuintEaseOut (double t, double b, double c, double d)
double QuintEaseInOut (double t, double b, double c, double d)
double SineEaseIn (double t, double b, double c, double d)
double SineEaseOut (double t, double b, double c, double d)
double SineEaseInOut (double t, double b, double c, double d)
template<typename T >
DotProduct (const Vec2< T > &lhs, const Vec2< T > &rhs)
template<typename T >
CrossProduct (const Vec2< T > &lhs, const Vec2< T > &rhs)
template<typename U >
Vec2< U > operator* (const U &f, const Vec2< U > &v)
template<typename T >
DotProduct (const Vec3< T > &lhs, const Vec3< T > &rhs)
template<typename T >
const Vec3< T > CrossProduct (const Vec3< T > &lhs, const Vec3< T > &rhs)
template<typename U >
Vec3< U > operator* (const U &f, const Vec3< U > &v)
template<typename T >
Vec4< T > operator* (T f, const Vec4< T > &v)
template<typename U >
Vec4< U > operator* (const U &f, const Vec4< U > &v)
t_u32 Memcmp (const void *Buf1, const void *Buf2, t_u32 Count)
bool MemIsZero (const void *V, t_size Count)
void * Memmove (void *Dest, const void *Src, t_size Count)
void Memset (void *Dest, t_s32 C, t_size Count)
void Memzero (void *Dest, t_size Count)
void Memcpy (void *Dest, const void *Src, t_size Count)
void Memswap (void *Ptr1, void *Ptr2, t_size Size)
bool IsMemoryAligned (void *data, t_u32 alignment)
 Check that the alignment is a power of two.
void * Malloc (t_size Count, t_u32 Alignment)
void * Realloc (void *Original, t_size Count, t_u32 Alignment)
NString IntegerToChar (int value, int base)
 From: http://www.strudel.org.uk/itoa/ C++ version 0.4 char* style "itoa": Written by Lukás Chmela Released under GPLv3.
t_double CharToDouble (const TCHAR *digit)
 Convert a TCHAR string to a double value.
NString DoubleToChar (double d)
 Convert a double to an NString.
t_s32 CharToInteger (const TCHAR *digit)
 Convert a TCHAR string to a 32 bits long value.
t_u32 HexCharToInteger (const TCHAR *s)
 Convert an Hex TCHAR string to an integer value.
t_int IntegerToChar (const TCHAR *digit)
 Convert an string to an integer.
 NUX_IMPLEMENT_GLOBAL_OBJECT (UniqueIndex)
t_u32 GetVariableArgs (TCHAR *Dest, t_u32 Size, t_u32 Count, const TCHAR *&Fmt, va_list ArgPtr)
t_u32 GetVariableArgsAnsi (ANSICHAR *Dest, t_u32 Size, t_u32 Count, const ANSICHAR *&Fmt, va_list ArgPtr)
void PrintOutputDebugString (const TCHAR *Format,...)
 Log an outpout message to console or visual studio output. To be used while the log redirector is not initialized.
void LogOutputAssertMessage (const ANSICHAR *File, int Line, const TCHAR *Format=TEXT(""),...)
 Log an assertion failure to registered output.
void LogOutputErrorMessage (const ANSICHAR *File, int Line, const TCHAR *Format=TEXT(""),...)
 Log an error message to registered output.
void LogOutputDebugMessage (const TCHAR *Format,...)
 Log and output message with a severity factor to registered output. Print colored output in XTerm.
void LogOutputSeverityMessage (int Severity, const TCHAR *Format,...)
 Log and output message with a severity factor to registered output. Print colored output in XTerm.
bool OutputRedirectorReady ()
 NUX_IMPLEMENT_ROOT_OBJECT_TYPE (Trackable)
 NUX_IMPLEMENT_OBJECT_TYPE (Object)
 NUX_IMPLEMENT_GLOBAL_OBJECT (ObjectStats)
template<typename T >
bool operator== (T *ptr, const ObjectPtr< T > &a)
template<typename T >
bool operator!= (T *ptr, const ObjectPtr< T > &a)
template<typename T >
bool operator== (T *ptr, const ObjectWeakPtr< T > &a)
template<typename T >
bool operator!= (T *ptr, const ObjectWeakPtr< T > &a)
 NUX_IMPLEMENT_GLOBAL_OBJECT (NullOutput)
 NUX_IMPLEMENT_GLOBAL_OBJECT (LogOutputRedirector)
 NUX_IMPLEMENT_GLOBAL_OBJECT (LogFileOutput)
bool ParseCommand (const TCHAR **Stream, const TCHAR *Match)
 Parse a stream of characters and look for a string of TCHAR at the start of the stream.
bool Parse_tchar (const TCHAR *stream, const TCHAR *Match, TCHAR *value, t_int size, t_int MaxLen)
 Parses a string of N character from a character stream after a named token.
bool ParseParam (const TCHAR *Stream, const TCHAR *Param)
 Checks if a Token command-line parameter exists in the stream.
bool Parse_string (const TCHAR *Stream, const TCHAR *Match, NString &Value)
 Parse a NString after the named token.
bool Parse_u64 (const TCHAR *Stream, const TCHAR *Match, QWORD &Value)
 Parse a QUADWORD after the named token.
bool Parse_s64 (const TCHAR *Stream, const TCHAR *Match, SQWORD &Value)
 Parse a SIGNED QUADWORD after the named token.
bool Parse_u32 (const TCHAR *stream, const TCHAR *Match, DWORD &value)
 Parse a stream of characters and look for a t_32 value after the token string.
bool Parse_u8 (const TCHAR *Stream, const TCHAR *Match, BYTE &Value)
 Parse a BYTE after the named token.
bool Parse_s8 (const TCHAR *Stream, const TCHAR *Match, SBYTE &Value)
 Parse a signed BYTE after the named token.
bool Parse_u16 (const TCHAR *Stream, const TCHAR *Match, WORD &Value)
 Parse a WORD after the named token.
bool Parse_s16 (const TCHAR *Stream, const TCHAR *Match, SWORD &Value)
 Parse a signed WORD after the named token.
bool Parse_float (const TCHAR *Stream, const TCHAR *Match, float &Value)
 Parse a floating point value after the named token.
bool Parse_int (const TCHAR *Stream, const TCHAR *Match, t_int &Value)
 Parse a double WORD after the named token.
bool Parse_bool (const TCHAR *Stream, const TCHAR *Match, bool &OnOff)
 Parse a BOOLEAN after the named token.
void ParseToNextLine (const TCHAR **Stream, TCHAR CommentChar)
 Go to the next token in the stream.
bool ParseToken (const TCHAR *Str, TCHAR *TokenBuffer, t_int BufferSize)
 Parse the next space-delimited string from the input stream. If the next token starts with a quote, gets entire quoted string.
bool ParseToken (const TCHAR *Str, NString &TokenString)
 Parse the next space-delimited string from the input stream. If the next token starts with a quote, gets entire quoted string.
NString ParseToken (const TCHAR *Str, bool UseEscape)
bool ParseLine (const TCHAR **Stream, TCHAR *LineBuffer, t_int BufferSize)
 Extract a line of Stream (everything up to, but not including, CR/LF).
bool ParseLine (const TCHAR **Stream, NString &LineString)
 Extract a line of Stream (everything up to, but not including, CR/LF).
NString ParseToken (const TCHAR *Str)
 Parse the next space-delimited string from the input stream. If the next token starts with a quote, gets entire quoted string.
 NUX_IMPLEMENT_GLOBAL_OBJECT (NGlobalData)
void NuxCoreInitialize (const TCHAR *CommandLine)
void ExitSystem ()
void inlInitRandomGenerator ()
NString GetComputerName ()
 Get computer name.
NString GetProgramDirectory ()
 Get startup directory.
NString GetUserName ()
 Get user name.
NString GetCmdLine ()
 Get the program command line.
NString GetLogDirectory ()
 Return the logs directory.
void inlPreInitializePlatform ()
void inlInitializePlatform ()
void inlPostInitializePlatform ()
void inlExitSystem ()
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator== (TEST_TYPE const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
 This is a very boring file.
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator== (PROP_TYPE< VALUE_TYPE > const &lhs, TEST_TYPE const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator== (PROP_TYPE< VALUE_TYPE > const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator!= (TEST_TYPE const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator!= (PROP_TYPE< VALUE_TYPE > const &lhs, TEST_TYPE const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator!= (PROP_TYPE< VALUE_TYPE > const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator< (TEST_TYPE const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator< (PROP_TYPE< VALUE_TYPE > const &lhs, TEST_TYPE const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator< (PROP_TYPE< VALUE_TYPE > const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator<= (TEST_TYPE const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator<= (PROP_TYPE< VALUE_TYPE > const &lhs, TEST_TYPE const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator<= (PROP_TYPE< VALUE_TYPE > const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator> (TEST_TYPE const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator> (PROP_TYPE< VALUE_TYPE > const &lhs, TEST_TYPE const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator> (PROP_TYPE< VALUE_TYPE > const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator>= (TEST_TYPE const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator>= (PROP_TYPE< VALUE_TYPE > const &lhs, TEST_TYPE const &rhs)
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool operator>= (PROP_TYPE< VALUE_TYPE > const &lhs, PROP_TYPE< VALUE_TYPE > const &rhs)
bool operator== (const Size &lhs, const Size &rhs)
bool operator!= (const Size &lhs, const Size &rhs)
TCHAR * Strncpy (TCHAR *Dest, t_size Size, const TCHAR *Src, t_size MaxLen)
TCHAR * Strncat (TCHAR *Dest, t_size Size, const TCHAR *Src, t_size Max)
 Concatenate a string with length checking.
const TCHAR * Strfind (const TCHAR *Str, const TCHAR *Find)
bool IsLastChar (const TCHAR *CharString, const TCHAR Chr)
NString Itoa (int InNum)
TCHAR * Strdup (const TCHAR *str)
 Duplicate a null terminated string using new[]. The resulting string is NULL terminated. Use delete[] to destroy.
ANSICHAR * StrdupA (const ANSICHAR *str)
 Duplicate a null terminated ANSICHAR string using new[]. The resulting string is NULL terminated. Use delete[] to destroy.
UNICHAR * StrdupU (const UNICHAR *str)
 Duplicate a null terminated UNICHAR string using new[]. The resulting string is NULL terminated. Use delete[] to destroy.
t_size ValueToLiteralString (char *buffer, t_u32 len, t_u16 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_s16 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_u32 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_s32 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_ulong value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_long value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_u64 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_s64 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_float value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_double value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_u8 value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_char value)
t_size ValueToLiteralString (char *buffer, t_u32 len, t_s8 value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_u16 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_s16 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_u32 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_s32 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_ulong &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_long &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_u64 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_s64 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_float &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_double &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_u8 &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_char &value)
bool ValueFromLiteralString (const char *buffer, t_u32 len, t_s8 &value)
 VARARG_BODY (int, Snprintf, const TCHAR *, VARARG_EXTRA(TCHAR *Dest) VARARG_EXTRA(int Size) VARARG_EXTRA(int Count))
bool operator!= (const NString &left, const NString &right)
bool operator== (const NString &left, const NString &right)
bool operator< (const NString &left, const NString &right)
bool operator<= (const NString &left, const NString &right)
bool operator> (const NString &left, const NString &right)
bool operator>= (const NString &left, const NString &right)
NString operator+ (const NString &left, const NString &right)
NString operator+ (const NString &left, const TCHAR *right)
NString operator+ (const NString &left, const TCHAR right)
NString operator+ (const TCHAR *left, const NString &right)
NString operator+ (const TCHAR left, const NString &right)
tostream & operator<< (tostream &o, const NString &s)
 VARARG_BODY (NString, NString::Printf, const TCHAR *, VARARG_NONE)
template<typename T >
ToLowerCase (T c)
template<typename T >
ToUpperCase (T c)
template<class T >
t_size ToCharString (char *buffer, t_size bufferlen, const char *format, T value)
template<class T >
t_s32 ToTCharString (TCHAR *buffer, t_size bufferlen, const TCHAR *format, T value)
t_size ValueToLiteralString (char *buffer, t_size len, t_u16 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_s16 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_u32 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_s32 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_ulong value)
t_size ValueToLiteralString (char *buffer, t_size len, t_long value)
t_size ValueToLiteralString (char *buffer, t_size len, t_u64 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_s64 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_float value)
t_size ValueToLiteralString (char *buffer, t_size len, t_double value)
t_size ValueToLiteralString (char *buffer, t_size len, t_u8 value)
t_size ValueToLiteralString (char *buffer, t_size len, t_s8 value)
template<class T >
bool FromCharString (const char *buffer, t_size bufferlen, const char *format, T &value)
template<class T >
bool FromTCharString (const TCHAR *buffer, t_size bufferlen, const TCHAR *format, T &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_u16 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_s16 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_u32 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_s32 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_ulong &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_long &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_u64 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_s64 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_float &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_double &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_u8 &value)
bool ValueFromLiteralString (const char *buffer, t_size len, t_s8 &value)
TCHAR * inlStringCopy (TCHAR *Dest, t_size numberOfElements, const TCHAR *Src)
 Copy a string.
TCHAR * inlTCharStringConcat (TCHAR *Dest, t_size numberOfElements, const TCHAR *Src)
 Append a string.
TCHAR * inlStrupr (TCHAR *String, t_size numberOfElements)
 Convert a string to uppercase. Returns a pointer to the altered string. Return 0 if not successful.
TCHAR * Strstr (const TCHAR *String, const TCHAR *Find)
 Return a pointer to the first occurrence of a search string in a string.
TCHAR * Strchr (const TCHAR *String, int c)
 Find the first occurrence a character in a string. Returns a pointer to that character in the string or NULL if it is not found.
TCHAR * Strrchr (const TCHAR *String, int c)
 Find the last occurrence a character in a string. Returns a pointer to that character in the string or NULL if it is not found.
int TCharStringCompare (const TCHAR *String1, const TCHAR *String2)
 Performs a case-sensitive comparison. The return value indicates the lexicographic relation of String1 to String2.
int Stricmp (const TCHAR *String1, const TCHAR *String2)
 Performs a case-insensitive comparison. The return value indicates the lexicographic relation of String1 to String2.
int Strtoi (const TCHAR *Start, TCHAR **End, int Base)
int TCharStringNCompare (const TCHAR *A, const TCHAR *B, t_size Count)
int TCharStringNICompare (const TCHAR *A, const TCHAR *B, t_size Count)
 VARARG_DECL (int, static int, return, Snprintf, VARARG_NONE, const TCHAR *, VARARG_EXTRA(TCHAR *Dest) VARARG_EXTRA(int Size) VARARG_EXTRA(int Count), VARARG_EXTRA(Dest) VARARG_EXTRA(Size) VARARG_EXTRA(Count))
 Formatted Printf.
 NUX_IMPLEMENT_ROOT_OBJECT_TYPE (NThread)
NString GetFormattedLocalTime ()
 Returns the time formatted in a string.
void GetLocalTime (unsigned int &Year, unsigned int &Month, unsigned int &Day, unsigned int &Hour, unsigned int &Min, unsigned int &Sec, unsigned int &MicroSec)
void GetUTCTime (unsigned int &Year, unsigned int &Month, unsigned int &Day, unsigned int &Hour, unsigned int &Min, unsigned int &Sec, unsigned int &MicroSec)
t_long GetTimeZone ()
void SleepForMilliseconds (unsigned int Milliseconds)
double Seconds ()
 Returns the time that has passed in seconds. The origin is unknown.
double MilliSeconds ()
 Returns the time that has passed in milliseconds. The origin is unknown.
void inlCopyTextToClipboard (const TCHAR *text)
NString inlReadTextToClipboard ()
MouseButton GetEventButton (unsigned long button_state)
 Returns index of the mouse button that triggered an event.
bool GetButtonState (unsigned long button_state, MouseButton button)
 Returns the state of a mouse button: pressed or released.
bool GetKeyModifierState (unsigned long key_modifiers_states, KeyModifier key_modifier)
 Returns the state of a special key: CTRL, Shift, Alt, NumLock...
 NUX_IMPLEMENT_OBJECT_TYPE (FontTexture)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLResource)
int CheckGLError (const TCHAR *GLcall, const TCHAR *file, int line)
void DecomposeTypeDeclaraction (ATTRIB_DECL_TYPE Type, int &NumComponent, ATTRIB_COMPONENT_TYPE &ComponentType)
UINT GetVertexElementSize (VERTEXELEMENT vtxelement)
void AddVertexElement (std::vector< VERTEXELEMENT > &Elements, WORD Stream, WORD Offset, ATTRIB_DECL_TYPE Type, ATTRIB_USAGE_DECL Usage, BYTE UsageIndex)
unsigned int GetGLElementCount (PRIMITIVE_TYPE InPrimitiveType, unsigned int InPrimitiveCount)
void DecomposeTypeDeclaraction (ATTRIB_DECL_TYPE Type, BYTE &NumComponent, ATTRIB_COMPONENT_TYPE &ComponentType)
GLenum GetGLPrimitiveType (PRIMITIVE_TYPE InPrimitiveType)
 NUX_IMPLEMENT_OBJECT_TYPE (ResourceData)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedResourceData)
 NUX_IMPLEMENT_OBJECT_TYPE (BaseTexture)
 NUX_IMPLEMENT_OBJECT_TYPE (Texture2D)
 NUX_IMPLEMENT_OBJECT_TYPE (TextureRectangle)
 NUX_IMPLEMENT_OBJECT_TYPE (TextureCube)
 NUX_IMPLEMENT_OBJECT_TYPE (TextureVolume)
 NUX_IMPLEMENT_OBJECT_TYPE (TextureFrameAnimation)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedBaseTexture)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedTexture2D)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedTextureRectangle)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedTextureCube)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedTextureVolume)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedTextureFrameAnimation)
BaseTextureCreateTexture2DFromPixbuf (GdkPixbuf *pixbuf, bool premultiply)
BaseTextureCreateTexture2DFromFile (const TCHAR *filename, int max_size, bool premultiply)
BaseTextureCreateTextureFromPixbuf (GdkPixbuf *pixbuf)
BaseTextureCreateTextureFromFile (const TCHAR *TextureFilename)
BaseTextureCreateTextureFromBitmapData (const NBitmapData *BitmapData)
 NUX_IMPLEMENT_OBJECT_TYPE (VertexBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (IndexBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (VertexDeclaration)
 NUX_IMPLEMENT_OBJECT_TYPE (MeshBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedVertexBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedIndexBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedVertexDeclaration)
 NUX_IMPLEMENT_OBJECT_TYPE (CachedMeshBuffer)
void ClipOrCenterRectToMonitor (LPRECT prc, t_u32 flags)
unsigned int GetModifierKeyState ()
LRESULT CALLBACK WndProcManager (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
unsigned int GetModifierKeyState (unsigned int modifier_key_state)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLAnimatedTexture)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLAsmShader)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLAsmVertexShader)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLAsmPixelShader)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLAsmShaderProgram)
bool ExtractShaderString3 (const NString &ShaderToken, const NString &ShaderSource, NString &RetSource, NString ShaderPreprocessorDefines)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLBaseTexture)
t_s32 GetTextureSize (IOpenGLBaseTexture *pTexture)
void GetTextureDesc (IOpenGLBaseTexture *pTexture, t_u32 Level, TEXTURE_DESC *pDesc)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLCubeTexture)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLFrameBufferObject)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLShader)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLVertexShader)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLPixelShader)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLShaderProgram)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLIndexBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLPixelBufferObject)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLQuery)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLRectangleTexture)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLSurface)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLTexture2D)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLVertexBuffer)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLVertexDeclaration)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLVolume)
 NUX_IMPLEMENT_OBJECT_TYPE (IOpenGLVolumeTexture)
MeshDataLoadMeshFile_OBJ (const char *filename)
void NuxGraphicsInitialize ()
GraphicsDisplayGetGraphicsDisplay ()
 inlDeclareThreadLocalStorage (GraphicsDisplay *, 1, _TLS_GraphicsDisplay)
 NUX_IMPLEMENT_GLOBAL_OBJECT (NuxGraphicsResources)
GLenum TexWrapGLMapping (TexWrap tex_wrap_mode)
GLenum TexFilterGLMapping (TexFilter tex_filter_mode)
GLenum RopBlendGLMapping (RopBlend rop_blend_mode)
void QRP_Compute_Texture_Coord (t_int32 quad_width, t_int32 quad_height, ObjectPtr< IOpenGLBaseTexture > tex, TexCoordXForm &texxform)
 Compute texture coordinates and wrapping mode according to TexCoordXForm.
 NUX_IMPLEMENT_GLOBAL_OBJECT (RenderingStats)
void _expblur (guchar *pixels, gint width, gint height, gint channels, gint radius, gint aprec, gint zprec)
NBitmapDataLoadGdkPixbuf (GdkPixbuf *pixbuf)
NBitmapDataLoadImageFile (const TCHAR *filename)
bool HasOpenEXRSupport ()
void MakeCheckBoardImage (ImageSurface &Image, int width, int height, Color const &dark, Color const &light, int TileWidth, int TileHeight)

Variables

const int SizeGripWidth = 20
const int SizeGripHeight = 20
const int TitleBarHeight = 20
const int KNOT_SIZE = 2
const int KNOT_HIT_TEST = 4
unsigned long S_KEY = 0
Color FILESELECTOR_BUTTON_COLOR = Color (0xFF4D4D4D)
Color FILESELECTOR_BUTTON_MOUSEOVER_COLOR = Color (0xFF222222)
const int HSCROLLBAR_WIDTH = 10
const int HSCROLLBAR_HEIGHT = 10
AreaEventProcessorgFocusMouseHandler = 0
TypeString TypeToString []
const int BTN_WIDTH = 14
const int BTN_HEIGHT = 14
std::vector< NThread * > ThreadArray
const unsigned int STENCIL_TEST_REF = 0xFF
const unsigned int STENCIL_TEST_MASK = 0xFFFFFFFF
const unsigned int STENCIL_CLEAR = 0x0
const float ALPHA_TEST_REF = 0.0f
const int PROPERTY_BORDER_X = 2
const int PROPERTY_BORDER_Y = 2
Color GPropertyItemTextColor0 = Color (0xFFDEDEDE)
Color GPropertyItemTextColor1 = Color (0xFFE9E9E9)
const Color SPINBOX_BUTTON_COLOR = Color (0xFF4D4D4D)
const Color SPINBOX_BUTTON_MOUSEOVER_COLOR = Color (0xFF222222)
const Color SPINBOX_DOUBLE_BUTTON_COLOR = Color (0xFF4D4D4D)
const Color SPINBOX_DOUBLE_BUTTON_MOUSEOVER_COLOR = Color (0xFF222222)
unsigned long CTRL_KEY = 0
const int HANDLERSIZE = 6
const int ITEMDEFAULTWIDTH = 140
const int ITEMDEFAULTHEIGHT = 20
const Color HEADER_BACKGROUND_COLOR = Color (0xFF666666)
const int ROWHEADERWIDTH = 30
const int OPENCLOSE_BTN_WIDTH = 15
const int ITEM_DEPTH_MARGIN = 20
const int MIN_COLUMN_WIDTH = 10
const int TABLE_AREA_BOTTOM_SPACE = 0
const int COLUMNHEADERHEIGHT = 20
Color TABLE_HEADER_BASE_COLOR = Color (0xFF191919)
Color TABLE_HEADER_TEXT_COLOR = Color (0xFFFFFFFF)
UXStyle UXStyleArray []
const int VSCROLLBAR_WIDTH = 5
const int VSCROLLBAR_HEIGHT = 10
const Color COLOR_BLACK = Color(0xFF000000)
const Color COLOR_RED = Color(0xFFFF0000)
const Color COLOR_GREEN = Color(0xFF00FF00)
const Color COLOR_BLUE = Color(0xFF0000FF)
const Color COLOR_WHITE = Color(0xFFFFFFFF)
const Color COLOR_BACKGROUND_PRIMARY = Color(0xFF4D4D4D)
const Color COLOR_BACKGROUND_SECONDARY = Color(0xFF868686)
const Color COLOR_FOREGROUND_PRIMARY = Color(0xFF424242)
const Color COLOR_FOREGROUND_SECONDARY = Color(0xFFEFEFEF)
const Color COLOR_SELECTION_SECONDARY = Color(0xFFAAAAAA)
const Color COLOR_TEXTEDIT_BACKGROUNG = Color(0xFF9F9F9F)
const Color COLOR_TEXTSTATIC_BACKGROUNG = Color(0xFF909090)
const Color COLOR_WIDGET_BACKGROUND = Color(0xFF6E6E6E)
const Color COLOR_WIDGET_MOUSEOVER = Color(0xFF969664)
const Color COLOR_WINDOW_BACKGROUND = Color(0xFFa0a0a0)
const Color COLOR_PRIMARY_LEFT = Color(0xFFC0C0C0)
const Color COLOR_PRIMARY_RIGHT = Color(0xFF7D7D7D)
const Color COLOR_SCROLLBAR_TRACK = Color(0xFF636363)
const Color COLOR_SCROLLBAR_SLIDER = Color(0xFF373737)
const Color COLOR_DARK_0 = Color(0xFF575757)
const Color COLOR_LIGHT_0 = Color(0xFF737373)
const int AREA_MIN_WIDTH = 1
const int AREA_MAX_WIDTH = 0x7FFFFFFF
const int AREA_MIN_HEIGHT = 1
const int AREA_MAX_HEIGHT = 0x7FFFFFFF
const int DEFAULT_WIDGET_HEIGHT = 8
const int PRACTICAL_WIDGET_HEIGHT = 18
const int DEFAULT_WIDGET_WIDTH = 32
const int PRACTICAL_WIDGET_WIDTH = 32
const int DEFAULT_TEXT_X_MARGIN = 0
const int DEFAULT_TEXT_Y_MARGIN = 0
const float DEFAULT_REPEAT_DELAY = 150
TimerFunctorm_ScrollTimerFunctor
TimerHandle m_ScrollTimerHandler
EventToNameStruct EventToName []
const BYTE UTF32_BE [] = {0x04 , 0x00, 0x00, 0xFE, 0xFF }
const BYTE UTF32_LE [] = {0x04 , 0xFF, 0xFE, 0x00, 0x00 }
const BYTE UTF16_BE [] = {0x02 , 0xFE, 0xFF }
const BYTE UTF16_LE [] = {0x02 , 0xFF, 0xFE }
const BYTE UTF8 [] = {0x03 , 0xEF, 0xBB, 0xBF }
const unsigned int CRCTable [256]
const t_bool GNoDialog = false
const BYTE NUX_UTF32_BE [] = {0x04 , 0x00, 0x00, 0xFE, 0xFF }
const BYTE NUX_UTF32_LE [] = {0x04 , 0xFF, 0xFE, 0x00, 0x00 }
const BYTE NUX_UTF16_BE [] = {0x02 , 0xFE, 0xFF }
const BYTE NUX_UTF16_LE [] = {0x02 , 0xFF, 0xFE }
const BYTE NUX_UTF8 [] = {0x03 , 0xEF, 0xBB, 0xBF }
const t_s8 t_s8_min = -128
const t_s8 t_s8_max = 127
const t_u8 t_u8_min = 0
const t_u8 t_u8_max = 255
const t_s16 t_s16_min = -32768
const t_s16 t_s16_max = 32767
const t_u16 t_u16_min = 0
const t_u16 t_u16_max = 65535
const t_s32 t_s32_min = 0x80000000
const t_s32 t_s32_max = 0x7FFFFFFF
const t_u32 t_u32_min = 0x00000000
const t_u32 t_u32_max = 0xFFFFFFFF
const t_s64 t_s64_min = 0x8000000000000000LL
const t_s64 t_s64_max = 0x7FFFFFFFFFFFFFFFLL
const t_u64 t_u64_min = 0x0000000000000000ULL
const t_u64 t_u64_max = 0xFFFFFFFFFFFFFFFFULL
const t_f32 t_f32_min = 1.175494351E-38F
const t_f32 t_f32_max = 3.402823466E+38F
const t_f64 t_f64_min = 2.2250738585072014E-308
const t_f64 t_f64_max = 1.7976931348623158E+308
const t_f32 MinFloat = 1.175494351E-38F
const t_f32 MaxFloat = 3.402823466E+38F
const t_f64 MinDouble = 2.2250738585072014E-308
const t_f64 MaxDouble = 1.7976931348623158E+308
const long I_ExposureMask = (1L << 15)
const long I_StructureNotifyMask = (1L << 17)
const long I_SubstructureNotifyMask = (1L << 19)
const int CURSOR_OFFSET = 0
NString gFontVtxShader
NString gFontFragShader
NString FontAsmVtx
NString FontAsmFrg
NString FontAsmFrgRect
GLenum AttachmentBuffer []
PixelFormatInfo GPixelFormats []
struct nux::StateLookUpTable s_StateLUT
const TCHAR * OGLDeviceErrorMessages []
NString AsmRedFrgShader
NString AsmGreenFrgShader
NString AsmBlueFrgShader
NString AsmHueFrgShader
NString AsmSaturationFrgShader
NString AsmValueFrgShader
NString AsmFrgShader
struct nux::TextureStateLookUpTable s_TextureStateLUT
const TCHAR * WINDOW_CLASS_NAME
const float RASTERIZATION_OFFSET = 0.375f
struct TexWrapMapping TexWrapMappingArray []
struct TexFilterMapping TexFilterMappingArray []
struct RopBlendMapping RopBlendMappingArray []
ReadBackPixelFormatInfo GReadBackPixelFormats []

Detailed Description

The Writer singleton is responsible for controlling where the logging message go.

Much of this property work is based on the work by Lois Goldthwaite, SC22/WG21/N1615=04-0055 - C++ Properties -- a Library Solution.

For testing purposes it is able to define the logging stream, normally a std::stringstream.

The default behaviour is to output to std::cout.

As far as logging the timestamp goes, we only go to second precision in the logging format itself. If a high performance timer is needed it should be managed by the caller.

The basic ideas were extended to add update notifications, and serialisation and introspection.

FramebufferObject Class. This class encapsulates the FramebufferObject (FBO) OpenGL spec. See the official spec at: http://oss.sgi.com/projects/ogl-sample/registry/EXT/framebuffer_object.txt

for details.

A framebuffer object (FBO) is conceptually a structure containing pointers to GPU memory. The memory pointed to is either an OpenGL texture or an OpenGL RenderBuffer. FBOs can be used to render to one or more textures, share depth buffers between multiple sets of color buffers/textures and are a complete replacement for pbuffers.

Performance Notes: 1) It is more efficient (but not required) to call Bind() on an FBO before making multiple method calls. For example:

FramebufferObject fbo; fbo.Bind(); fbo.AttachTexture(GL_COLOR_ATTACHMENT0_EXT, texId0); fbo.AttachTexture(GL_COLOR_ATTACHMENT1_EXT, texId1); fbo.IsValid();

To provide a complete encapsulation, the following usage pattern works correctly but is less efficient:

FramebufferObject fbo; NOTE : No Bind() call fbo.AttachTexture(GL_COLOR_ATTACHMENT0_EXT, texId0); fbo.AttachTexture(GL_COLOR_ATTACHMENT1_EXT, texId1); fbo.IsValid();

The first usage pattern binds the FBO only once, whereas the second usage binds/unbinds the FBO for each method call.

2) Use FramebufferObject::Disable() sparingly. We have intentionally left out an "Unbind()" method because it is largely unnecessary and encourages rendundant Bind/Unbind coding. Binding an FBO is usually much faster than enabling/disabling a pbuffer, but is still a costly operation. When switching between multiple FBOs and a visible OpenGL framebuffer, the following usage pattern is recommended:

FramebufferObject fbo1, fbo2; fbo1.Bind(); ... Render ... NOTE : No Unbind/Disable here...

fbo2.Bind(); ... Render ...

Disable FBO rendering and return to visible window OpenGL framebuffer. FramebufferObject::Disable();


Typedef Documentation

typedef void(* nux::ConfigureNotifyCallback)(int, int, Geometry &, void *)

A user provided callback to assert the size and position of a floating area. The callback receives a proposed size and position for the floating area. Inside the callback, the size and position of the floating area can be modified.

Parameters:
intThe width of the window.
intThe height of the window.
Geometry&The tentative size of the window.

Definition at line 61 of file BaseWindow.h.

typedef int(* nux::EventInspector)(Area *area, Event *event, void *data)

Event Inspector function prototype.

If an event inspector return true, then the event is discarded.

Definition at line 55 of file WindowThread.h.


Enumeration Type Documentation

State of the mouse on an area.

Enumerator:
AREA_MOUSE_STATUS_DOWN 

A mouse down event is detected on the area. That last only for the duration of this event cycle.

AREA_MOUSE_STATUS_UP 

A mouse up event is detected on the area. That last only for the duration of this event cycle.

AREA_MOUSE_STATUS_FOCUS 

The mouse is pressed on the area. This status last as long as the mouse is douse on the area.

AREA_MOUSE_STATUS_MOVE 

The mouse is moving over the area.

AREA_MOUSE_STATUS_ENTER 

The mouse entered the area.

AREA_MOUSE_STATUS_LEAVE 

The mouse exited the area.

Definition at line 32 of file MouseHandler.h.

  {
    AREA_MOUSE_STATUS_NONE   = 0L,
    AREA_MOUSE_STATUS_DOWN   = (1L << 0),   
    AREA_MOUSE_STATUS_UP     = (1L << 1),   
    AREA_MOUSE_STATUS_FOCUS  = (1L << 2),   
    AREA_MOUSE_STATUS_MOVE   = (1L << 3),   
    AREA_MOUSE_STATUS_ENTER  = (1L << 4),   
    AREA_MOUSE_STATUS_LEAVE  = (1L << 5),   
  } AreaMouseStatus;
Enumerator:
EVENT_CYCLE_EXCLUSIVE 

Value of ProcessEventInfo when processing the event cycle of the input area that has the exclusivity.

EVENT_CYCLE_EXCLUSIVE_CONTINUE 

Return value of the cycle of the exclusive input area. If it is returned, allow other areas to process the event.

EVENT_CYCLE_RESET_AREA_STATE 

Reset the mouse event processor of an InputArea.

Definition at line 38 of file Utils.h.

  {
    eSolveNone                      = (0L),
    eMouseEventSolved               = (1L),
    eKeyEventSolved                 = (1L) << 1,
    eDoNotProcess                   = (1L) << 2,
    EVENT_CYCLE_EXCLUSIVE           = (1L) << 3,  
    EVENT_CYCLE_EXCLUSIVE_CONTINUE  = (1L) << 4,  
    EVENT_CYCLE_SOLVED              = (1L) << 5,
    EVENT_CYCLE_DO_NOT_PROCESS      = (1L) << 6,
    EVENT_CYCLE_RESET_AREA_STATE    = (1L) << 7,  
  } EventCycleStatus;

Control how a layout distribute its children position.

Applies to layouts that have more space than their children can use. These options control how a layouts places its children inside of itself.

Enumerator:
MAJOR_POSITION_TOP 

Stack elements at the top (for VLayout only).

MAJOR_POSITION_BOTTOM 

Stack elements at the bottom (for VLayout only).

MAJOR_POSITION_LEFT 

Stack elements at the left (for HLayout only).

MAJOR_POSITION_RIGHT 

Stack elements at the right (for HLayout only).

MAJOR_POSITION_CENTER 

Stack elements in the center of the layout (for HLayout and VLayout).

MAJOR_POSITION_EXPAND 

Spread elements evenly inside the layout (for HLayout and VLayout).

eStackTop 

Deprecated.

eStackBottom 

Deprecated.

eStackLeft 

Deprecated.

eStackRight 

Deprecated.

eStackCenter 

Deprecated.

eStackExpand 

Deprecated.

Definition at line 85 of file Area.h.

Policy for and element position in the minor dimension of a layout.

Enumerator:
MINOR_POSITION_TOP 

Place the element on the top side of the layout (Hlayout)

MINOR_POSITION_BOTTOM 

Place the element on the bottom side of the layout (Hlayout)

MINOR_POSITION_LEFT 

Place the element on the left side of the layout (Vlayout)

MINOR_POSITION_RIGHT 

Place the element on the right side of the layout (Hlayout)

MINOR_POSITION_CENTER 

Place the element at the center of the layout (Hlayout and VLayout)

eAbove 

Deprecated.

eBelow 

Deprecated.

eLeft 

Deprecated.

eRight 

Deprecated.

eCenter 

Deprecated.

Definition at line 66 of file Area.h.

  {
    MINOR_POSITION_TOP,           
    MINOR_POSITION_BOTTOM,        
    MINOR_POSITION_LEFT,          
    MINOR_POSITION_RIGHT,         
    MINOR_POSITION_CENTER,        
    eAbove = MINOR_POSITION_TOP,      
    eBelow = MINOR_POSITION_BOTTOM,   
    eLeft = MINOR_POSITION_LEFT,      
    eRight = MINOR_POSITION_RIGHT,    
    eCenter = MINOR_POSITION_CENTER,  
  } MinorDimensionPosition;
Enumerator:
eFull 

Deprecated.

ePercentage 

Deprecated.

eFix 

Deprecated.

eMatchContent 

Deprecated.

Definition at line 53 of file Area.h.

  {
    MINOR_SIZE_FULL,
    MINOR_SIZE_PERCENTAGE,
    MINOR_SIZE_FIX,
    MINOR_SIZE_MATCHCONTENT,
    eFull = MINOR_SIZE_FULL,                  
    ePercentage = MINOR_SIZE_PERCENTAGE,      
    eFix  = MINOR_SIZE_FIX,                   
    eMatchContent = MINOR_SIZE_MATCHCONTENT,  
  } MinorDimensionSize;
Enumerator:
NUX_MOUSEWHEEL 

Deprecated. Use NUX_MOUSE_WHEEL.

NUX_DND_ENTER 

Synthetic event generated when the dnd action enters an InputArea. This is not the event sent when the dnd action enters the window.

NUX_DND_LEAVE 

Synthetic event generated when the dnd action leaves an InputArea. This is not the event sent when the dnd action leaves the window.

NUX_DND_ENTER_WINDOW 

Emitted when the DND action goes inside (XdndLeave) a window.

NUX_DND_LEAVE_WINDOW 

Emitted when the DND action goes outside (XdndEnter) a window.

Definition at line 187 of file Events.h.

  {
    // events
    NUX_NO_EVENT         = 0,
    NUX_MOUSE_PRESSED,
    NUX_MOUSE_RELEASED,
    NUX_MOUSE_MOVE,
    NUX_MOUSE_DOUBLECLICK,
    NUX_MOUSE_WHEEL,
    NUX_MOUSEWHEEL = NUX_MOUSE_WHEEL, 
    NUX_KEYDOWN,
    NUX_KEYUP,
    NUX_SIZE_CONFIGURATION,
    NUX_WINDOW_MAP,
    NUX_WINDOW_UNMAP,
    NUX_WINDOW_CONFIGURATION,
    NUX_WINDOW_ENTER_FOCUS,
    NUX_WINDOW_EXIT_FOCUS,
    NUX_WINDOW_DIRTY,
    NUX_WINDOW_MOUSELEAVE,
    NUX_DESTROY_WINDOW,
    NUX_TERMINATE_APP,
    NUX_TAKE_FOCUS, // ClientMessage for window with WM_TAKE_FOCUS protocol-atom set
    NUX_DND_MOVE,
    NUX_DND_DROP,
    NUX_DND_ENTER,  
    NUX_DND_LEAVE,  
    NUX_DND_ENTER_WINDOW,  
    NUX_DND_LEAVE_WINDOW,   
  };

Graphics blend modes.

Defines the blending modes. The values are matched to openGL blending modes.

Definition at line 72 of file RenderingPipe.h.

  {
    ROPBLEND_UNKNOWN = 0,
    ROPBLEND_ZERO,
    ROPBLEND_ONE,
    ROPBLEND_SRC_COLOR,
    ROPBLEND_ONE_MINUS_SRC_COLOR,
    ROPBLEND_DST_COLOR,
    ROPBLEND_ONE_MINUS_DST_COLOR,
    ROPBLEND_SRC_ALPHA,
    ROPBLEND_ONE_MINUS_SRC_ALPHA,
    ROPBLEND_DST_ALPHA,
    ROPBLEND_ONE_MINUS_DST_ALPHA,
    ROPBLEND_CONSTANT_COLOR,
    ROPBLEND_ONE_MINUS_CONSTANT_COLOR,
    ROPBLEND_CONSTANT_ALPHA,
    ROPBLEND_ONE_MINUS_CONSTANT_ALPHA,
    ROPBLEND_SRC_ALPHA_SATURATE,
  } RopBlend;

For internal use only.

Enumerator:
eCompliantWidth 

Deprecated.

eCompliantHeight 

Deprecated.

eSmallerWidth 

Deprecated.

eSmallerHeight 

Deprecated.

eLargerWidth 

Deprecated.

eLargerHeight 

Deprecated.

eForceComply 

Deprecated.

Definition at line 106 of file Area.h.

  {
    SIZE_EQUAL_WIDTH     = (1L),
    SIZE_EQUAL_HEIGHT    = (1L) << 1,
    SIZE_SMALLER_WIDTH   = (1L) << 2,
    SIZE_SMALLER_HEIGHT  = (1L) << 3,
    SIZE_LARGER_WIDTH    = (1L) << 4,
    SIZE_LARGER_HEIGHT   = (1L) << 5,
    SIZE_FORCE_COMPLY    = (1L) << 6,

    eCompliantWidth     = SIZE_EQUAL_WIDTH,     
    eCompliantHeight    = SIZE_EQUAL_HEIGHT,    
    eSmallerWidth       = SIZE_SMALLER_WIDTH,   
    eSmallerHeight      = SIZE_SMALLER_HEIGHT,  
    eLargerWidth        = SIZE_LARGER_WIDTH,    
    eLargerHeight       = SIZE_LARGER_HEIGHT,   
    eForceComply        = SIZE_FORCE_COMPLY,    
  } SizeCompliance;

Graphics filtering modes.

Defines the filtering modes of TexCoordXForm. The values are matched to openGL filtering modes.

See also:
TexCoordXForm.

Definition at line 56 of file RenderingPipe.h.

  {
    TEXFILTER_UNKNOWN = 0,
    TEXFILTER_LINEAR,
    TEXFILTER_NEAREST,
    TEXFILTER_NEAREST_MIPMAP_NEAREST,
    TEXFILTER_LINEAR_MIPMAP_NEAREST,
    TEXFILTER_NEAREST_MIPMAP_LINEAR,
    TEXFILTER_LINEAR_MIPMAP_LINEAR,
  } TexFilter;

Graphics wraping modes.

Defines the wraping modes of TexCoordXForm. The values are matched to OpenGL wraping modes.

See also:
TexCoordXForm.

Definition at line 37 of file RenderingPipe.h.

  {
    TEXWRAP_UNKNOWN = 0,
    TEXWRAP_REPEAT,
    TEXWRAP_CLAMP,
    TEXWRAP_CLAMP_TO_EDGE,
    TEXWRAP_CLAMP_TO_BORDER,
    TEXWRAP_MIRRORED_REPEAT,
    TEXWRAP_MIRROR_CLAMP_EXT,
    TEXWRAP_MIRROR_CLAMP_TO_EDGE_EXT,
    TEXWRAP_MIRROR_CLAMP_TO_BORDER_EXT,
  } TexWrap;

Function Documentation

NUX_DECLSPEC_DLL t_double * nux::Bernstein ( t_int  n,
t_double  t 
)

Evaluate the Bernstein polynomial of degree n, at parameter t.

Evaluate the Bernstein polynomial of degree n, at parameter t.

Parameters:
nThe degree of the Bernstein basis polynomials.
tThe evaluation point.
Returns:
the values of the n+1 Bernstein basis of degree n.

Definition at line 30 of file Bezier.cpp.

Referenced by Bezier_XY(), and Bezier_XYZ().

  {
    if (n < 0)
    {
      NUX_BREAK_ASM_INT3;
    }

    t_double *bernstein;
    t_int i;

    bernstein = new t_double[n+1];

    for (i = 0; i <= n; i++ )
    {
      bernstein[i] = BinomialCoefficient (n, i) * PowerInt<t_double> (t, i) * PowerInt<t_double> (1.0 - t, n - i);
    }

    return bernstein;
  }
NUX_DECLSPEC_DLL void nux::Bezier_XY ( t_int  n,
t_double  t,
t_double  xcon[],
t_double  ycon[],
t_double *  xval,
t_double *  yval 
)

Evaluate 2D Bezier curve of degree n.

Evaluate 2D Bezier curve of degree n.

Parameters:
nThe degree of the Bezier curve.
tParameter.
xconArray of n+1 x coordinates of control points.
yconArray of n+1 y coordinates of control points.
xvalReturn the x coordinates of the Bezier curve at parameter t.
yvalReturn the y coordinates of the Bezier curve at parameter t.

Definition at line 50 of file Bezier.cpp.

References Bernstein().

  {
    if (n < 0)
    {
      NUX_BREAK_ASM_INT3;
    }

    double *bval;
    int i;

    bval = Bernstein ( n, t );

    *xval = 0.0;

    for ( i = 0; i <= n; i++ )
      *xval = *xval + xcon[i] * bval[i];

    *yval = 0.0;

    for ( i = 0; i <= n; i++ )
      *yval = *yval + ycon[i] * bval[i];

    delete [] bval;
  }
NUX_DECLSPEC_DLL void nux::Bezier_XYZ ( t_int  n,
t_double  t,
t_double  xcon[],
t_double  ycon[],
t_double  zcon[],
t_double *  xval,
t_double *  yval,
t_double *  zval 
)

Evaluate 2D Bezier curve of degree n.

Evaluate 2D Bezier curve of degree n.

Parameters:
nThe degree of the Bezier curve.
tParameter.
xconArray of n+1 x coordinates of control points.
yconArray of n+1 y coordinates of control points.
yconArray of n+1 z coordinates of control points.
xvalReturn the x coordinates of the Bezier curve at parameter t.
yvalReturn the y coordinates of the Bezier curve at parameter t.
yvalReturn the z coordinates of the Bezier curve at parameter t.

Definition at line 75 of file Bezier.cpp.

References Bernstein().

  {
    if (n < 0)
      NUX_BREAK_ASM_INT3;

    double *bval;
    int i;

    bval = Bernstein ( n, t );

    *xval = 0.0;

    for ( i = 0; i <= n; i++ )
      *xval = *xval + xcon[i] * bval[i];

    *yval = 0.0;

    for ( i = 0; i <= n; i++ )
      *yval = *yval + ycon[i] * bval[i];

    *zval = 0.0;

    for ( i = 0; i <= n; i++ )
      *zval = *zval + zcon[i] * bval[i];

    delete [] bval;
  }
t_double nux::CharToDouble ( const TCHAR *  digit)

Convert a TCHAR string to a double value.

Parameters:
digitA TCHAR string.
Returns:
A double value translated from a TCHAR string.

Definition at line 74 of file NumberConversion.cpp.

Referenced by Parse_float().

  {
    char *endptr = NULL;
    NString str = TCHAR_TO_ANSICHAR (digit);
    errno = 0;
    t_double ret = std::strtod (str.GetTCharPtr(), &endptr);
    t_u32 error = errno;

    if (error == ERANGE)
    {
      nuxDebugMsg ("[CharToDouble] Out for range value");
    }

    return ret;
  }
t_s32 nux::CharToInteger ( const TCHAR *  digit)

Convert a TCHAR string to a 32 bits long value.

Parameters:
digitA TCHAR string.
Returns:
A 32 bits long value translated from a TCHAR string.

Definition at line 102 of file NumberConversion.cpp.

Referenced by Parse_int(), Parse_s16(), Parse_s8(), Parse_u16(), and Parse_u8().

  {
    NString str = TCHAR_TO_ANSICHAR (digit);
    t_s64 ret = std::atoi (str.GetTCharPtr() );
    return ret;
  }
Geometry nux::ComputeGeometryPositioning ( const Geometry &  container_geo,
const Geometry &  content_geo,
GeometryPositioning  gctx 
)

Compute the position of one geometry inside an other.

Compute the position of one geometry inside an other.

The container geometry The content geometry The parameter to use to compute the position of the content.

Returns:
the computed geometry.

Definition at line 72 of file Painter.cpp.

Referenced by nux::BasePainter::PaintCheckBox(), and nux::TableCtrl::PaintDecoration().

  {
    int x_pos, y_pos;
    int w, h;

    if (gctx.m_stretch_horizontal)
    {
      w = container_geo.GetWidth() - 2 * gctx.m_horizontal_margin;
    }
    else
    {
      w = content_geo.GetWidth();
    }

    if (gctx.m_stretch_horizontal)
    {
      h = container_geo.GetHeight() - 2 * gctx.m_vertical_margin;
    }
    else
    {
      h = content_geo.GetHeight();
    }

    if (gctx.m_horizontal_aligment == eHACenter)
    {
      int offset = (container_geo.GetWidth() - w) / 2.0f;
      //offset = (offset < 0) ? 0 : offset;
      x_pos = container_geo.x + offset;
    }
    else if (gctx.m_horizontal_aligment == eHALeft)
    {
      x_pos = container_geo.x + gctx.m_horizontal_margin;

      if (x_pos > container_geo.x + container_geo.GetWidth() )
        x_pos = container_geo.x;
    }
    else if (gctx.m_horizontal_aligment == eHARight)
    {
      x_pos = container_geo.x + container_geo.GetWidth() - w - gctx.m_horizontal_margin;

      if (x_pos < container_geo.x)
        x_pos = container_geo.x;
    }
    else
    {
      x_pos = container_geo.x + gctx.m_horizontal_margin;
    }

    if (gctx.m_vertical_aligment == eVACenter)
    {
      int offset = (container_geo.GetHeight() - h) / 2.0f;
      //offset = (offset < 0) ? 0 : offset;
      y_pos = container_geo.y + offset;
    }
    else if (gctx.m_vertical_aligment == eVATop)
    {
      y_pos = container_geo.y + gctx.m_vertical_margin;

      if (y_pos > container_geo.y + container_geo.GetHeight() )
        y_pos = container_geo.y;
    }
    else if (gctx.m_vertical_aligment == eVABottom)
    {
      y_pos = container_geo.y + container_geo.GetHeight() - h - gctx.m_vertical_margin;

      if (y_pos < container_geo.y)
        y_pos = container_geo.y;
    }
    else
    {
      y_pos = container_geo.y + gctx.m_vertical_margin;
    }

    return Geometry (x_pos, y_pos, w, h);
  }
UNICHAR nux::ConvertAnsiCharToUnicodeChar ( ANSICHAR  In) [inline]

Convert a single ANSICHAR to UNICHAR.

Definition at line 165 of file NUnicode.h.

Referenced by LoadTextFileToUnicodeArray().

  {
    UNICHAR output;
    const t_UTF8 *source_start = reinterpret_cast<const t_UTF8 *> (&In);
    const t_UTF8 *source_end = source_start + 1;
    t_UTF16 *target_start = reinterpret_cast<t_UTF16 *> (&output);
    t_UTF16 *target_end = target_start + sizeof (wchar_t);

    ConversionResult res = ConvertUTF8toUTF16 (&source_start, source_end, &target_start, target_end, lenientConversion);

    if (res != conversionOK)
    {
      output = 0;
    }

    return output;
  }
ANSICHAR nux::ConvertUnicodeCharToAnsiChar ( UNICHAR  In) [inline]

Convert a single UNICHAR to ANSICHAR.

Definition at line 144 of file NUnicode.h.

  {
    TCHAR output;
    const t_UTF16 *source_start = &In;
    const t_UTF16 *source_end = source_start + 1;
    t_UTF8 *target_start = reinterpret_cast<t_UTF8 *> (&output);
    t_UTF8 *target_end = target_start + sizeof (wchar_t);

    ConversionResult res = ConvertUTF16toUTF8 (&source_start, source_end, &target_start, target_end, lenientConversion);

    if (res != conversionOK)
    {
      output = 0;
    }

    return output;
  }
double nux::CRandom ( ) [inline]

Return a random variable between [-1,1[ (uniform distribution).

Returns:
a random double value in the range [-1, 1[.

Definition at line 153 of file MathUtility.h.

  {
    return 1 - 2 * (std::rand() / RAND_MAX);
  }
BaseTexture * nux::CreateTexture2DFromFile ( const char *  filename,
int  max_size,
bool  premultiply 
)

Create and load a 2D texture filled with RGBA pixels loaded from the image file pointed by filename. The loading uses the GdkPixbuf library which implies that the supported formats depend on the GdkPixbuf loaders installed on the client system.

Specifies the maximal required size for the image to be loaded, if the width or height exceeds that value, the image is scaled down respecting the aspect ratio. A value of -1 means that no maximal value is required. Specifies if the R, G and B color channels must be premultiplied by the alpha channel before being uploaded to the texture. Note that if there's no alpha channel, the argument is ignored.

Returns:
The resulting texture.

Definition at line 147 of file GLTextureResourceManager.cpp.

References CreateTexture2DFromPixbuf().

  {
    GError *error = NULL;
    GdkPixbuf *pixbuf =
      gdk_pixbuf_new_from_file_at_size (filename, max_size, max_size, &error);
    if (error == NULL)
    {
      BaseTexture *texture = CreateTexture2DFromPixbuf (pixbuf, premultiply);
      g_object_unref (pixbuf);
      return texture;
    }
    else
    {
      nuxDebugMsg ("%s", error->message);
      return NULL;
    }
  }
BaseTexture * nux::CreateTexture2DFromPixbuf ( GdkPixbuf *  pixbuf,
bool  premultiply 
)

Create and load a 2D texture filled with RGBA pixels loaded from the GdkPixbuf pointed by pixbuf.

Specifies if the R, G and B color channels must be premultiplied by the alpha channel before being uploaded to the texture. Note that if there's no alpha channel, the argument is ignored.

Returns:
The resulting texture.

Definition at line 61 of file GLTextureResourceManager.cpp.

References nux::GpuDevice::CreateSystemCapableTexture().

Referenced by CreateTexture2DFromFile().

  {
    const unsigned int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
    const unsigned int width = gdk_pixbuf_get_width (pixbuf);
    const unsigned int height = gdk_pixbuf_get_height (pixbuf);

    // Put the RGB or RGBA pixels in a RGBA texture data object taking care
    // of alpha premultiplication if requested.
    // FIXME(loicm) Implies a useless copy. NTextureData should be able to
    //     take ownership of pre-allocated memory.
    // FIXME(loicm) Add support for big-endian systems. For performance
    //     reasons, pixels are loaded by block of 4 bytes with the color
    //     components bit-shifted considering little-endian ordering. Nux
    //     doesn't seem to be big-endian aware anyway.
    // FIXME(loicm) Surface::Write32b does branching, splits the 32-bit value
    //     as four 8-bit values (using bit-shifts) that are then stored
    //     separately, that's slow considering it's meant to be used a lot in
    //     deep loops.
    NTextureData *data = new NTextureData (BITFMT_R8G8B8A8, width, height, 1);
    ImageSurface &surface = data->GetSurface (0);
    if (gdk_pixbuf_get_has_alpha (pixbuf) == TRUE)
    {
      unsigned char *pixels_u8 = gdk_pixbuf_get_pixels (pixbuf);
      unsigned int *pixels_u32 = reinterpret_cast<unsigned int *> (pixels_u8);

      if (premultiply == true)
      {
        // Copy from pixbuf (RGBA) to surface (premultiplied RGBA).
        for (unsigned int i = 0; i < height; i++)
        {
          for (unsigned int j = 0; j < width; j++)
          {
            const unsigned int pixel = pixels_u32[j];
            const unsigned int a = pixel >> 24;
            if (a == 0)
              surface.Write32b (j, i, 0);
            else
            {
              const unsigned int b = (((pixel >> 16) & 0xff) * a) / 255;
              const unsigned int g = (((pixel >> 8) & 0xff) * a) / 255;
              const unsigned int r = ((pixel & 0xff) * a) / 255;
              const unsigned int p = a << 24 | b << 16 | g << 8 | r;
              surface.Write32b (j, i, p);
            }
          }
          pixels_u8 += rowstride;
          pixels_u32 = reinterpret_cast<unsigned int *> (pixels_u8);
        }
      }
      else
      {
        // Copy from pixbuf (RGBA) to surface (RGBA).
        for (unsigned int i = 0; i < height; i++)
        {
          for (unsigned int j = 0; j < width; j++)
            surface.Write32b (j, i, pixels_u32[j]);
          pixels_u8 += rowstride;
          pixels_u32 = reinterpret_cast<unsigned int *> (pixels_u8);
        }
      }
    }
    else
    {
      // Copy from pixbuf (RGB) to surface (RGBA).
      unsigned char *pixels = gdk_pixbuf_get_pixels (pixbuf);
      for (unsigned int i = 0; i < height; i++)
      {
        for (unsigned int j = 0; j < width; j++)
        {
          const unsigned char r = pixels[j*3];
          const unsigned char g = pixels[j*3+1];
          const unsigned char b = pixels[j*3+2];
          surface.Write (j, i, r, g, b, 0xff);
        }
        pixels += rowstride;
      }
    }

    // Create a 2D texture and upload the pixels.
    BaseTexture *texture = GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableTexture ();
    texture->Update (data);
    
    delete data; // data is deleted as texture->Update () copies it.
    return texture;
  }
NString nux::DoubleToChar ( double  d)

Convert a double to an NString.

Parameters:
dA double value.
Returns:
An NString.

Definition at line 90 of file NumberConversion.cpp.

References nux::NString::TrimRight().

  {
    TCHAR *buffer = new TCHAR[64];
    Memset (buffer, 0, 64);
    SPRINTF_S (buffer, 64, "%.39f", d);
    NString str = buffer;
    str = str.TrimRight (TEXT ("0") );

    delete[] buffer;
    return str;
  }
bool nux::GetButtonState ( unsigned long  button_state,
MouseButton  button 
)

Returns the state of a mouse button: pressed or released.

Given the mouse button states of and event, returns the state of a mouse button. True is the button is pressed. False otherwise.

Parameters:
button_stateThe mouse button states of an event.
buttonButton to query (1 for left mouse button).
Returns:
True is the button is pressed. False otherwise.

Definition at line 42 of file Events.cpp.

  {
    if (button == NUX_MOUSE_BUTTON1)
      return (button_state & NUX_STATE_BUTTON1_DOWN) ? true : false;
    else if (button == NUX_MOUSE_BUTTON2)
      return (button_state & NUX_STATE_BUTTON2_DOWN) ? true : false;
    else if (button == NUX_MOUSE_BUTTON3)
      return (button_state & NUX_STATE_BUTTON3_DOWN) ? true : false;
    else if (button == NUX_MOUSE_BUTTON4)
      return (button_state & NUX_STATE_BUTTON4_DOWN) ? true : false;

    return false;    
  }
NString nux::GetCmdLine ( )

Get the program command line.

Get the program command line.

Returns:
The program command line.

Definition at line 221 of file Platform.cpp.

  {
    return NUX_GLOBAL_OBJECT_INSTANCE (NGlobalData).m_CommandLine;
  }
NString nux::GetComputerName ( )

Get computer name.

Get computer name.

Returns:
The computer name.

Definition at line 206 of file Platform.cpp.

  {
    return NUX_GLOBAL_OBJECT_INSTANCE (NGlobalData).m_ComputerName;
  }
MouseButton nux::GetEventButton ( unsigned long  button_state)

Returns index of the mouse button that triggered an event.

Given the mouse button states of and event, returns the index of the button that triggered an event. The index of the left mouse button is 1 and the index for the right mouse button is 2. If 0 is returned, then a mouse button didn't triggered the event.

Parameters:
button_stateThe mouse button states of an event.
Returns:
The button that triggered the event.

Definition at line 28 of file Events.cpp.

  {
    if ((button_state & NUX_EVENT_BUTTON1_DOWN) || (button_state & NUX_EVENT_BUTTON1_UP))
      return NUX_MOUSE_BUTTON1;
    else if ((button_state & NUX_EVENT_BUTTON2_DOWN) || (button_state & NUX_EVENT_BUTTON2_UP))
      return NUX_MOUSE_BUTTON2;
    else if ((button_state & NUX_EVENT_BUTTON3_DOWN) || (button_state & NUX_EVENT_BUTTON3_UP))
      return NUX_MOUSE_BUTTON3;
    else if ((button_state & NUX_EVENT_BUTTON4_DOWN) || (button_state & NUX_EVENT_BUTTON4_UP))
      return NUX_MOUSE_BUTTON4;

    return NUX_INVALID_MOUSE_BUTTON;
  }
NString nux::GetFormattedLocalTime ( )

Returns the time formatted in a string.

Returns:
The time formatted in a string.

Definition at line 130 of file TimeFunctions.cpp.

  {
    TCHAR buffer[1024];
    Memset(buffer, 0, 1024);

    unsigned int Year;
    unsigned int Month;
    unsigned int Day;
    unsigned int Hour;
    unsigned int Minute;
    unsigned int Second;
    unsigned int MicroSec;

    GetLocalTime (Year, Month, Day, Hour, Minute, Second, MicroSec);
#ifdef _WIN32
    _stprintf_s (buffer, 1024 - 1, TEXT ("%d:%d:%d: %d/%d/%d"), Hour, Minute, Second, Day, Month, Year);
    NString result = buffer;
#else
    _stprintf (buffer, TEXT ("%d:%d:%d: %d/%d/%d"), Hour, Minute, Second, Day, Month, Year);
    NString result = buffer;
#endif

    return result;
  }
bool nux::GetKeyModifierState ( unsigned long  key_modifiers_states,
KeyModifier  key_modifier 
)

Returns the state of a special key: CTRL, Shift, Alt, NumLock...

Given the key modifiers states of and event, returns the state of a key modifier. True is the key is pressed. False otherwise.

Parameters:
key_modifiers_stateThe key modifiers states of an event.
key_modifierKey modifier be query.
Returns:
True is the key is pressed. False otherwise.

Definition at line 56 of file Events.cpp.

  {
    return ((key_modifiers_states & key_modifier) != 0);
  }
NString nux::GetLogDirectory ( )

Return the logs directory.

Returns the directory where logs files are output. This cannot be in a .ini files as the system may start logging before the .ini files are read.

Returns:
The logs directory

Definition at line 226 of file Platform.cpp.

  {
    return TEXT ("Logs");
  }
NString nux::GetProgramDirectory ( )

Get startup directory.

Get startup directory.

Returns:
The computer name.

Definition at line 211 of file Platform.cpp.

  {
    return NUX_GLOBAL_OBJECT_INSTANCE (NGlobalData).m_ProgramDirectory;
  }
NString nux::GetUserName ( )

Get user name.

Get the user name.

Returns:
The user name.

Definition at line 216 of file Platform.cpp.

  {
    return NUX_GLOBAL_OBJECT_INSTANCE (NGlobalData).m_UserName;
  }
t_u32 nux::HexCharToInteger ( const TCHAR *  s)

Convert an Hex TCHAR string to an integer value.

Parameters:
valueA TCHAR string.
Returns:
An integer value.

Definition at line 110 of file NumberConversion.cpp.

  {
    int n = 0;         // position in string
    int m = 0;         // position in digit[] to shift
    int count;         // loop index
    unsigned long intValue = 0;  // integer value of hex string
    int digit[16];      // hold values to convert

    const TCHAR *hexStg = s;

    if ( (s[0] == TEXT ('0') ) && ( (s[1] == TEXT ('X') ) || (s[1] == TEXT ('x') ) ) )
    {
      hexStg = s + 2;
    }

    while (n < 16)
    {
      if (hexStg[n] == TEXT ('\0') )
        break;

      if (hexStg[n] > 0x29 && hexStg[n] < 0x40 ) //if 0 to 9
        digit[n] = hexStg[n] & 0x0f;            //convert to int
      else if (hexStg[n] >= TEXT ('a') && hexStg[n] <= TEXT ('f') ) //if a to f
        digit[n] = (hexStg[n] & 0x0f) + 9;      //convert to int
      else if (hexStg[n] >= TEXT ('A') && hexStg[n] <= TEXT ('F') ) //if A to F
        digit[n] = (hexStg[n] & 0x0f) + 9;      //convert to int
      else break;

      n++;
    }

    count = n;
    m = n - 1;
    n = 0;

    while (n < count)
    {
      // digit[n] is value of hex digit at position n
      // (m << 2) is the number of positions to shift
      // OR the bits into return value
      intValue = intValue | (digit[n] << (m << 2) );
      m--;   // adjust the position to set
      n++;   // next digit to process
    }

    return (intValue);
  }
NString nux::IntegerToChar ( int  value,
int  base = 10 
)

From: http://www.strudel.org.uk/itoa/ C++ version 0.4 char* style "itoa": Written by Lukás Chmela Released under GPLv3.

Convert an integer to a tstring.

Parameters:
valueAn integer value.
baseBase of the integer representation.
Returns:
A string.

Definition at line 34 of file NumberConversion.cpp.

  {
    char result[65];

    // check that the base if valid
    if (base < 2 || base > 36)
    {
      //*result = '\0';
      NString str = TEXT ('\0');
      return str;
    }

    char *ptr = result, *ptr1 = result, tmp_char;
    int tmp_value;

    do
    {
      tmp_value = value;
      value /= base;
      *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base) ];
    }
    while ( value );

    // Apply negative sign
    if (tmp_value < 0)
      *ptr++ = '-';

    *ptr-- = '\0';

    while (ptr1 < ptr)
    {
      tmp_char = *ptr;
      *ptr-- = *ptr1;
      *ptr1++ = tmp_char;
    }

    NString str = result;
    return str;
  }
t_int nux::IntegerToChar ( const TCHAR *  digit)

Convert an string to an integer.

Parameters:
digitA TCHAR string.
Returns:
An integer value.
template<typename T >
bool nux::IsAligned ( Value,
int  Alignment 
) [inline]

Return true is Value is aligned on Alignment.

Parameters:
AlignmentMust be a power of 2

Definition at line 215 of file MathUtility.h.

  {
    return (((Value) & ~ (Alignment - 1)) == 0);
  }
bool nux::IsSpaceChar ( TCHAR  c) [inline]

Returns nonzero if character is a space character.

Definition at line 68 of file NTChar.h.

  {
#ifdef NUX_UNICODE
    return ( std::iswspace (c) != 0 );
#else
    return ( std::isspace (c) != 0 );
#endif
  }
bool nux::LoadFileToString ( NString &  Result,
const TCHAR *  Filename,
NFileManager &  FileManager 
)

Load a text file to an NString. The file maybe ANSI or Unicode. The resulting string is TCHAR.

Definition at line 235 of file FileIO.cpp.

  {
    NSerializer *Reader = FileManager.CreateFileReader (Filename);

    if ( !Reader )
    {
      nuxDebugMsg (TEXT ("[LoadFileToString] Cannot read from file: %s"), Filename);
      return false;
    }

    t_u32 Size = Reader->GetFileSize();
    std::vector<ANSICHAR> ByteArray (Size + 2);
    Reader->Serialize (&ByteArray[0], Size);
    bool Success = Reader->Close();
    delete Reader;
    ByteArray[Size+0] = 0;
    ByteArray[Size+1] = 0;
    std::vector<TCHAR> ResultArray;

    // Detect Unicode Byte Order Mark
    //      EF BB BF        UTF-8
    //      FF FE               UTF-16, little endian
    //      FE FF               UTF-16, big endian
    //      FF FE 00 00         UTF-32, little endian
    //      00 00 FE FF         UTF-32, big-endian
    // Note: Microsoft uses UTF-16, little endian byte order.

    // Little Endian UTF-16: size should be >=2, even, and the first two bytes should be 0xFF followed by 0xFE
    if ( (Size >= 2) && ! (Size & 1) && ( (BYTE) ByteArray[0] == 0xff) && ( (BYTE) ByteArray[1] == 0xfe) )
    {
      // UTF16 - Little Endian
      int numElement = Size / sizeof (TCHAR);
      ResultArray.clear();
      ResultArray.resize (numElement);

      for ( int i = 0; i < numElement - 1; i++ )
        ResultArray[i] = ConvertUnicodeCharToTCHAR ( (WORD) (ANSIUCHAR) ByteArray[i*2+2] + (WORD) (ANSIUCHAR) ByteArray[i*2+3] * 256 );

      ResultArray[numElement] = 0;
    }
    else if ( (Size >= 2) && ! (Size & 1) && ( (BYTE) ByteArray[0] == 0xfe) && ( (BYTE) ByteArray[1] == 0xff) )
    {
      // UTF16 - Big Endian.
      int numElement = Size / sizeof (TCHAR);
      ResultArray.clear();
      ResultArray.resize (numElement);

      for (int i = 0; i < numElement - 1; i++)
        ResultArray[i] = ConvertUnicodeCharToTCHAR ( (WORD) (ANSIUCHAR) ByteArray[i*2+3] + (WORD) (ANSIUCHAR) ByteArray[i*2+2] * 256 );

      ResultArray[numElement] = 0;
    }
    else
    {
      // ANSI.
      ResultArray.clear();
      ResultArray.resize (Size + 1);

      for (t_u32 i = 0; i < Size; i++)
        ResultArray[i] = ConvertAnsiCharToTCHAR (ByteArray[i]);

      ResultArray[Size] = 0;
    }

    Result = &ResultArray[0];
    return Success;
  }
NBitmapData * nux::LoadGdkPixbuf ( GdkPixbuf *  pixbuf)

Return and object that has to be destroyed with delete.

Returns:
A bitmap source. Destroy it with delete.

Definition at line 46 of file ImageSurface.cpp.

  {
    unsigned int width = gdk_pixbuf_get_width (pixbuf);
    unsigned int height = gdk_pixbuf_get_height (pixbuf);
    unsigned int row_bytes = gdk_pixbuf_get_rowstride (pixbuf);

    NTextureData *Texture = new NTextureData (BITFMT_R8G8B8A8, width, height, 1);

    guchar *img = gdk_pixbuf_get_pixels (pixbuf);

    for (unsigned int i = 0; i < width; i++)
      for (unsigned int j = 0; j < height; j++)
      {
        guchar *pixels = img + ( j * row_bytes + i * 4);
        UINT value =
          (* (pixels + 3) << 24) |  // a
          (* (pixels + 2) << 16) |  // b
          (* (pixels + 1) << 8)  |  // g
          * (pixels + 0);           // r

        Texture->GetSurface (0).Write32b (i, j, value);
      }

    return Texture;
  }
NBitmapData * nux::LoadImageFile ( const TCHAR *  Filename)

Return and object that has to be destroyed with delete.

Returns:
A bitmap source. Destroy it with delete.

Definition at line 72 of file ImageSurface.cpp.

Referenced by nux::TextureFrameAnimation::Update(), nux::TextureVolume::Update(), nux::TextureCube::Update(), nux::TextureRectangle::Update(), and nux::Texture2D::Update().

  {
    if (!GFileManager.FileExist (filename) )
    {
      nuxAssertMsg (0, TEXT ("[LoadImageFile] Can't find file: %s"), filename);
      return 0;
    }

    NBitmapData *BitmapData = 0;

#if defined(NUX_OS_WINDOWS)
    BitmapData = GdiLoadImageFile (filename);
    if (BitmapData) return BitmapData;

    BitmapData = read_tga_file (filename);
    if (BitmapData) return BitmapData;

    BitmapData = LoadFileFormat_DDS(filename);
    if (BitmapData) return BitmapData;

#elif defined(NUX_OS_LINUX)
    GdkGraphics gdkgraphics;
    gdkgraphics.LoadImage (filename);
    BitmapData = gdkgraphics.GetBitmap();
    if (BitmapData) return BitmapData;
#endif

    // Unsupported format
    LOG_DEBUG(logger) << "Unknown file format: " << filename;
    return 0;
  }
MeshData * nux::LoadMeshFile_OBJ ( const char *  filename)

Load file, parse it Lines beginning with: '#' are comments can be ignored 'v' are vertices positions (3 floats that can be positive or negative) 'vt' are vertices texcoords (2 floats that can be positive or negative) 'vn' are vertices normals (3 floats that can be positive or negative) 'f' are faces, 3 values that contain 3 values which are separated by / and <space>

Definition at line 42 of file MeshFileLoader-OBJ.cpp.

  {
    std::vector<nux::Vector4>           positions;
    std::vector<nux::Vector2>           texcoords;
    std::vector<nux::Vector3>           normals;
    std::vector<_ObjMeshFaceIndex>  faces;
    std::ifstream filestream;
    filestream.open(filename);

    std::string line_stream;    // No longer depending on char arrays thanks to: Dale Weiler

    while(std::getline(filestream, line_stream))
    {
      std::stringstream str_stream(line_stream);
      std::string type_str;
      str_stream >> type_str;

      if(type_str == TOKEN_VERTEX_POS)
      {
        nux::Vector4 pos;
        str_stream >> pos.x >> pos.y >> pos.z;
        pos.w = 1.0f;
        positions.push_back(pos);
      }
      else if(type_str == TOKEN_VERTEX_TEX)
      {
        nux::Vector2 tex;
        str_stream >> tex.x >> tex.y;
        texcoords.push_back(tex);
      }
      else if(type_str == TOKEN_VERTEX_NOR)
      {
        nux::Vector3 nor;
        str_stream >> nor.x >> nor.y >> nor.z;
        normals.push_back(nor);
      }
      else if(type_str == TOKEN_FACE)
      {
        _ObjMeshFaceIndex face_index;
        char interupt;
        for(int i = 0; i < 3; ++i)
        {
          str_stream >> face_index.pos_index[i] >> interupt
                       >> face_index.tex_index[i]  >> interupt
                       >> face_index.nor_index[i];
        }
        faces.push_back(face_index);
      }
    }
    // Explicit closing of the file
    filestream.close();

    nux::MeshData* md = new nux::MeshData;
    md->Allocate(faces.size(), nux::NUX_MESH_TRIANGLE, 3*faces.size(), 16 + 12 + 8);

    //md->_mesh_primitive_type = nux::NuxMeshPrimitiveType::NUX_MESH_TRIANGLE;

    size_t i = 0;

    float* vertex_buffer = (float*)md->_vertex_data;
//     for(i = 0; i < positions.size(); i++)
//     {
//       vertex_buffer[9*i + 0] = positions[i].x;
//       vertex_buffer[9*i + 1] = positions[i].y;
//       vertex_buffer[9*i + 2] = positions[i].z;
//       vertex_buffer[9*i + 3] = positions[i].w;
// 
//       vertex_buffer[9*i + 4] = normals[i].x;
//       vertex_buffer[9*i + 5] = normals[i].y;
//       vertex_buffer[9*i + 6] = normals[i].z;
// 
//       vertex_buffer[9*i + 7] = texcoords[i].x;
//       vertex_buffer[9*i + 8] = texcoords[i].y;
//     }

    int* index_buffer = (int*)md->_index_data;
    for(i = 0; i < faces.size(); i++)
    {
      index_buffer[3*i + 0] = 3*i + 0;  //faces[i].pos_index[0]-1;
      index_buffer[3*i + 1] = 3*i + 1;  //faces[i].pos_index[1]-1;
      index_buffer[3*i + 2] = 3*i + 2;  //faces[i].pos_index[2]-1;

      for(int j = 0; j < 3; j++)
      {
        int vi    = faces[i].pos_index[j]-1;
        int ni    = faces[i].nor_index[j]-1;
        int ti    = faces[i].tex_index[j]-1;

        vertex_buffer[27*i + 9*j + 0] = positions[vi].x;
        vertex_buffer[27*i + 9*j + 1] = positions[vi].y;
        vertex_buffer[27*i + 9*j + 2] = positions[vi].z;
        vertex_buffer[27*i + 9*j + 3] = positions[vi].w;

        vertex_buffer[27*i + 9*j + 4] = normals[ni].x;
        vertex_buffer[27*i + 9*j + 5] = normals[ni].y;
        vertex_buffer[27*i + 9*j + 6] = normals[ni].z;

        vertex_buffer[27*i + 9*j + 7] = texcoords[ti].x;
        vertex_buffer[27*i + 9*j + 8] = texcoords[ti].y;
      }
    }

    return md;
  }
bool nux::LoadTextFileToAnsiArray ( std::vector< ANSICHAR > &  Result,
const TCHAR *  Filename,
NFileManager &  FileManager 
)

Load a text file the a ANSICHAR array. The Array is null terminated. Useful for loading shader files.

Definition at line 56 of file FileIO.cpp.

  {
    Result.clear();
    NSerializer *Reader = FileManager.CreateFileReader ( Filename );

    if ( !Reader )
      return FALSE;

    int Size = Reader->GetFileSize();

    if (Size < 0)
    {
      Reader->Close();
      delete Reader;
      return FALSE;
    }

    std::vector<BYTE> ByteArray;
    ByteArray.clear();
    ByteArray.resize (Size);
    Reader->Serialize (&ByteArray[0], Result.size() );
    bool Success = Reader->Close();
    delete Reader;

    if ( Size >= 2 && ! (Size & 1) && Memcmp (&Result[0], &NUX_UTF16_LE[1], NUX_UTF16_LE[0]) == 0) // (BYTE)ByteArray[0]==0xff && (BYTE)ByteArray[1]==0xfe )
    {
      // UTF16 - Little Endian
      int numElement = Size / sizeof (UNICHAR) + 1; // +1 for null char
      Result.resize (numElement);

      for ( int i = 0; i < numElement - 1; i++ )
        Result[i] = ConvertUnicodeCharToTCHAR ( (WORD) (ANSIUCHAR) ByteArray[i*2+2] + (WORD) (ANSIUCHAR) ByteArray[i*2+3] * 256 );

      Result[numElement] = 0;
    }
    else if ( Size >= 2 && ! (Size & 1) && Memcmp (&Result[0], &NUX_UTF16_LE[1], NUX_UTF16_LE[0]) == 0)
    {
      // UTF16 - Big Endian.
      int numElement = Size / sizeof (TCHAR) + 1; // +1 for null char
      Result.resize (numElement);

      for ( int i = 0; i < numElement - 1; i++ )
        Result[i] = ConvertUnicodeCharToTCHAR ( (WORD) (ANSIUCHAR) ByteArray[i*2+3] + (WORD) (ANSIUCHAR) ByteArray[i*2+2] * 256 );

      Result[numElement] = 0;
    }
    else
    {
      // ANSI.
      Result.clear();
      Result.resize (Size + 1); // +1 for null char

      for (int i = 0; i < Size; i++)
        Result[i] = ByteArray[i];

      Result[Size] = 0;
    }

    return Success;
  }
bool nux::LoadTextFileToUnicodeArray ( std::vector< UNICHAR > &  Result,
const TCHAR *  Filename,
NFileManager &  FileManager 
)

Load a text file in an ANSICHAR array. The Array is null terminated.

Definition at line 120 of file FileIO.cpp.

References ConvertAnsiCharToUnicodeChar().

  {
    Result.clear();
    NSerializer *Reader = FileManager.CreateFileReader ( Filename );

    if ( !Reader )
      return FALSE;

    int Size = Reader->GetFileSize();

    if (Size < 0)
    {
      Reader->Close();
      delete Reader;
      return FALSE;
    }

    std::vector<BYTE> ByteArray;
    ByteArray.clear();
    ByteArray.resize (Size);
    Reader->Serialize ( &ByteArray[0], Result.size() );
    bool Success = Reader->Close();
    delete Reader;

    if ( Size >= 2 && ! (Size & 1) && Memcmp (&Result[0], &NUX_UTF16_LE[1], NUX_UTF16_LE[0]) == 0) // (BYTE)ByteArray[0]==0xff && (BYTE)ByteArray[1]==0xfe )
    {
      // UTF16 - Little Endian
      int numElement = Size + 1; // +1 for null char
      Result.resize (numElement);

      for ( int i = 0; i < numElement - 1; i++ )
        Result[i] = ( (WORD) (ANSIUCHAR) ByteArray[i*2+2] + (WORD) (ANSIUCHAR) ByteArray[i*2+3] * 256 );

      Result[numElement] = 0;
    }
    else if ( Size >= 2 && ! (Size & 1) && Memcmp (&Result[0], &NUX_UTF16_LE[1], NUX_UTF16_LE[0]) == 0)
    {
      // UTF16 - Big Endian.
      int numElement = Size + 1; // +1 for null char
      Result.resize (numElement);

      for ( int i = 0; i < numElement - 1; i++ )
        Result[i] = ConvertUnicodeCharToTCHAR ( (WORD) (ANSIUCHAR) ByteArray[i*2+3] + (WORD) (ANSIUCHAR) ByteArray[i*2+2] * 256 );

      Result[numElement] = 0;
    }
    else
    {
      // There is no way to detect that a file really contains ascii. Or is there?
      // Make sure this file is really ascii.
      /*
      However as an additional check to
      the heuristic of looking for unprintable characters, another trick is to
      check if the newline string is consistent. It should always be either "\n"
      (for UNIX-like systems), "\r" (for Mac-like systems) or "\r\n" (for
      Windows-like systems). If the file starts switching around between these, it
      probably isn't a valid ASCII file on any of the above three platforms.
      */

      BOOL isASCII = TRUE;

      for ( int i = 0; i < Size; i++ )
      {
        if (Result[i] == 0 && (i != Size - 1) )
        {
          isASCII = FALSE;
        }

        if ( (Result[i] < 0x20 || Result[i] >= 0xFF) && ( (Result[i] != 0x0A/*New Line, Line feed*/) && (Result[i] != 0x0D/*Carriage return*/) ) )
        {
          isASCII = FALSE;
        }

        // http://www.websiterepairguy.com/articles/os/crlf.html
        /*
            The carriage return is often referred to by the capital letters CR.
            On a Macintosh, every line has a CR at the end.

            Under Linux (a variant of Unix), the end of a line is indicated by
            a line feed. Every line ends with a line feed or LF.

            Calling the end of a line an LF versus a CR is not just semantics.
            These are 2 very real characters with 2 very real and very separate
            numeric representations on a computer. A CR is a 13 in the ASCII table
            of characters and an LF is a 10 in the ASCII table of characters.

            Contributing to the confusion is that fact that Microsoft Windows does
            things yet another way. Under Microsoft Windows, lines end with a combination
            of 2 characters -- a CR followed by a LF. Symbolically, this is represented
            as CRLF or carriage return, line feed.
        */
        // Todo. Check if the file mixes a combination of \n (Linux) \r (Mac) and \r\n (Windows).
        // If it does, the file is not ASCII.

        if (isASCII == FALSE)
          return FALSE;
      }

      Result.clear();
      Result.resize (Size + 1);

      for ( int i = 0; i < Size; i++ )
        Result[i] = ConvertAnsiCharToUnicodeChar (ByteArray[i]);

      Result[Size] = 0;
    }


    return Success;
  }
double nux::MilliSeconds ( )

Returns the time that has passed in milliseconds. The origin is unknown.

Returns the time that has passed in milliseconds. The origin is unknown.

Returns:
the time passed in milliseconds.
template<template< typename T > class PROP_TYPE, typename VALUE_TYPE , typename TEST_TYPE , typename VT = typename PROP_TYPE<VALUE_TYPE>::ValueType>
bool nux::operator== ( TEST_TYPE const &  lhs,
PROP_TYPE< VALUE_TYPE > const &  rhs 
) [inline]

This is a very boring file.

It adds boolean operators for properties. The challenge has been making operators that work for properties and only properties. Since we don't want to add explicit methods for each type of property we have, we have the default template arguement VT which gets the ValueType from the Property definition. Since things like std::_list_iterator<foo> doesn't have a ValueType typedef, these functions are discarded from the possible choices, but since the Property templates do, they are valid, and get chosen.

However as much as I'd like to have more generic operators for !=, <=, > and >=, we can't really without making these functions choosable for types that we don't want, so we have three functions defined for each operator.

Definition at line 54 of file PropertyOperators.h.

{
  return lhs == rhs();
}
bool nux::Parse_bool ( const TCHAR *  Stream,
const TCHAR *  Match,
bool &  OnOff 
)

Parse a BOOLEAN after the named token.

Parse a BOOLEAN after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed BOOLEAN value
Returns:
TRUE if the token is found inside the stream.

Definition at line 258 of file Parsing.cpp.

References Parse_tchar(), and Stricmp().

  {
    TCHAR TempStr[16];

    if (Parse_tchar (Stream, Match, TempStr, NUX_ARRAY_COUNT (TempStr), NUX_ARRAY_COUNT (TempStr) - 1) )
    {
      OnOff =   !Stricmp (TempStr, TEXT ("On") ) || !Stricmp (TempStr, TEXT ("True") ) || !Stricmp (TempStr, TEXT ("1") );
      return true;
    }
    else
      return false;
  }
bool nux::Parse_float ( const TCHAR *  Stream,
const TCHAR *  Match,
float &  Value 
)

Parse a floating point value after the named token.

Parse a floating point value after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed floating point value
Returns:
TRUE if the token is found inside the stream.

Definition at line 236 of file Parsing.cpp.

References CharToDouble().

  {
    const TCHAR *Temp = Strfind (Stream, Match);

    if (Temp == NULL)
      return false;

    Value = CharToDouble (Temp + StringLength (Match) );
    return true;
  }
bool nux::Parse_int ( const TCHAR *  Stream,
const TCHAR *  Match,
t_int &  Value 
)

Parse a double WORD after the named token.

Parse a double WORD after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed double WORD
Returns:
TRUE if the token is found inside the stream.

Definition at line 247 of file Parsing.cpp.

References CharToInteger().

  {
    const TCHAR *Temp = Strfind (Stream, Match);

    if (Temp == NULL)
      return false;

    Value = CharToInteger (Temp + StringLength (Match) );
    return true;
  }
bool nux::Parse_s16 ( const TCHAR *  Stream,
const TCHAR *  Match,
SWORD &  Value 
)

Parse a signed WORD after the named token.

Parse a signed WORD after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed signed WORD
Returns:
TRUE if the token is found inside the stream.

Definition at line 224 of file Parsing.cpp.

References CharToInteger().

  {
    const TCHAR *Temp = Strfind (Stream, Match);

    if (Temp == NULL)
      return false;

    Temp += StringLength (Match);
    Value = (t_s16) CharToInteger (Temp);
    return Value != 0 || IsDigitChar (Temp[0]);
  }
bool nux::Parse_s64 ( const TCHAR *  Stream,
const TCHAR *  Match,
SQWORD &  Value 
)

Parse a SIGNED QUADWORD after the named token.

Parse a SIGNED QUADWORD after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed SIGNED QUADWORD
Returns:
TRUE if the token is found inside the stream.

Definition at line 153 of file Parsing.cpp.

References Parse_tchar().

Referenced by Parse_u64().

  {
    TCHAR Temp[4096] = TEXT (""), *Ptr = Temp;

    if (Parse_tchar (Stream, Match, Temp, NUX_ARRAY_COUNT (Temp), NUX_ARRAY_COUNT (Temp) ) )
    {
      Value = 0;
      bool Negative = (*Ptr == TEXT ('-') );
      Ptr += Negative;

      while ( (*Ptr >= TEXT ('0') ) && (*Ptr <= TEXT ('9') ) )
        Value = Value * 10 + *Ptr++ - TEXT ('0');

      if (Negative)
        Value = -Value;

      return true;
    }
    else
      return false;
  }
bool nux::Parse_s8 ( const TCHAR *  Stream,
const TCHAR *  Match,
SBYTE &  Value 
)

Parse a signed BYTE after the named token.

Parse a signed BYTE after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed signed BYTE
Returns:
TRUE if the token is found inside the stream.

Definition at line 200 of file Parsing.cpp.

References CharToInteger().

  {
    const TCHAR *Temp = Strfind (Stream, Match);

    if (Temp == NULL)
      return false;

    Temp += StringLength (Match);
    Value = CharToInteger (Temp);
    return Value != 0 || IsDigitChar (Temp[0]);
  }
bool nux::Parse_string ( const TCHAR *  Stream,
const TCHAR *  Match,
NString &  Value 
)

Parse a NString after the named token.

Parse a NString after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed NString
Returns:
TRUE if the token is found inside the stream.

Definition at line 136 of file Parsing.cpp.

References Parse_tchar().

  {
    TCHAR Temp[4096] = TEXT ("");

    if (Parse_tchar (Stream, Match, Temp, NUX_ARRAY_COUNT (Temp), NUX_ARRAY_COUNT (Temp) ) )
    {
      Value = Temp;
      return true;
    }
    else return false;
  }
bool nux::Parse_tchar ( const TCHAR *  stream,
const TCHAR *  Match,
TCHAR *  value,
t_int  size,
t_int  MaxLen 
)

Parses a string of N character from a character stream after a named token.

Parses a string from a character stream.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
ValueBuffer containing the parsed value.
SizeThe size of the Value buffer, in characters.
MaxLenMax number of character to return.
Returns:
TRUE if the token is found inside the stream.

Definition at line 60 of file Parsing.cpp.

References Strstr().

Referenced by Parse_bool(), Parse_s64(), and Parse_string().

  {
    const TCHAR *Found = Strfind (Stream, Match);
    const TCHAR *Start;

    if (Found)
    {
      Start = Found + StringLength (Match);

      if (*Start == '\x22') // Character '"'
      {
        // The value begins with the quotation mark character: ". We skip it.
        Strncpy (Value, Size, Start + 1, MaxLen);
        Value[MaxLen - 1] = 0;
        TCHAR *Temp = Strstr (Value, TEXT ("\x22") );

        if (Temp != NULL)
        {
          // We read in the termination quotation mark. Set it t0 0 to null terminate the Value buffer.
          *Temp = 0;
        }
      }
      else
      {
        // Non-quoted string without spaces.
        Strncpy (Value, Size, Start, MaxLen);
        Value[MaxLen - 1] = 0;
        TCHAR *Temp;
        Temp = Strstr (Value, TEXT (" ") );

        if (Temp) *Temp = 0;

        Temp = Strstr (Value, TEXT ("\r") );

        if (Temp) *Temp = 0;

        Temp = Strstr (Value, TEXT ("\n") );

        if (Temp) *Temp = 0;

        Temp = Strstr (Value, TEXT ("\t") );

        if (Temp) *Temp = 0;

        Temp = Strstr (Value, TEXT (",") );

        if (Temp) *Temp = 0;
      }

      return true;
    }
    else
      return false;
  }
bool nux::Parse_u16 ( const TCHAR *  Stream,
const TCHAR *  Match,
WORD &  Value 
)

Parse a WORD after the named token.

Parse a WORD after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed WORD
Returns:
TRUE if the token is found inside the stream.

Definition at line 212 of file Parsing.cpp.

References CharToInteger().

  {
    const TCHAR *Temp = Strfind (Stream, Match);

    if (Temp == NULL)
      return false;

    Temp += StringLength (Match);
    Value = (t_u16) CharToInteger (Temp);
    return Value != 0 || IsDigitChar (Temp[0]);
  }
bool nux::Parse_u32 ( const TCHAR *  stream,
const TCHAR *  Match,
DWORD &  value 
)

Parse a stream of characters and look for a t_32 value after the token string.

Parse a t_u32 after the named token.

Parameters:
streamCharacter stream to search.
tokenToken to match.
Returns:
True if the character string is found at the start of the stream (excluding space and tab characters).

Definition at line 175 of file Parsing.cpp.

  {
    const TCHAR *Temp = Strfind (Stream, Match);
    TCHAR *End;

    if (Temp == NULL)
      return false;

    Value = Strtoi (Temp + StringLength (Match), &End, 10);

    return true;
  }
bool nux::Parse_u64 ( const TCHAR *  Stream,
const TCHAR *  Match,
QWORD &  Value 
)

Parse a QUADWORD after the named token.

Parse a QUADWORD after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Valueparsed QUADWORD
Returns:
TRUE if the token is found inside the stream.

Definition at line 148 of file Parsing.cpp.

References Parse_s64().

  {
    return Parse_s64 (Stream, Match, * (SQWORD *) &Value);
  }
bool nux::Parse_u8 ( const TCHAR *  Stream,
const TCHAR *  Match,
BYTE &  Value 
)

Parse a BYTE after the named token.

Parse a BYTE after the named token.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
ValueBuffer containing the parsed value.
Returns:
TRUE if the token is found inside the stream.

Definition at line 188 of file Parsing.cpp.

References CharToInteger().

  {
    const TCHAR *Temp = Strfind (Stream, Match);

    if (Temp == NULL)
      return false;

    Temp += StringLength (Match);
    Value = (BYTE) CharToInteger (Temp);
    return (Value != 0) || IsDigitChar (Temp[0]);
  }
bool nux::ParseCommand ( const TCHAR **  Stream,
const TCHAR *  Match 
)

Parse a stream of characters and look for a string of TCHAR at the start of the stream.

If the string is found, Stream points to the next character after the string. Space and tab characters at the beginning of the stream are ignored.

Parameters:
StreamCharacter stream to search.
MatchToken to match.
Returns:
TRUE if the character string is found at the start of the stream (excluding space and tab characters).

Definition at line 35 of file Parsing.cpp.

  {
    while ( (**Stream == TEXT (' ') ) || (**Stream == CHAR_TAB) )
      (*Stream) ++;

    if (TCharStringNICompare (*Stream, Match, StringLength (Match) ) == 0)
    {
      *Stream += StringLength (Match);

      if (!IsAlphanumericChar (**Stream) )
      {
        while ( (**Stream == TEXT (' ') ) || (**Stream == CHAR_TAB) )
          (*Stream) ++;

        return true; // Success.
      }
      else
      {
        *Stream -= StringLength (Match);
        return false; // Only found partial match.
      }
    }
    else return false; // No match.
  }
bool nux::ParseLine ( const TCHAR **  Stream,
TCHAR *  LineBuffer,
t_int  BufferSize 
)

Extract a line of Stream (everything up to, but not including, CR/LF).

Parameters:
StreamCharacter stream to search.
LineBufferThe first line in Stream.
BufferSizeSize of LineBuffer.
GoToNextLineIf true, advanced the pointer after the first CR/LF character at the end of the string. If FALSE advanced the pointer past all the CR/LF character at the end of the string.
Returns:
True i a line was copied to LineString;

Definition at line 387 of file Parsing.cpp.

  {
    TCHAR *tmp = LineBuffer;
    *tmp = 0;

    while ( (**Stream != 0) && (**Stream != CHAR_NEW_LINE) && (**Stream != CHAR_CR) && (**Stream != CHAR_FF) && (--BufferSize > 0) )
    {
      * (tmp++) = * ( (*Stream) ++);
    }

    *tmp = 0;
    return LineBuffer[0] != 0;
  }
bool nux::ParseLine ( const TCHAR **  Stream,
NString &  LineString 
)

Extract a line of Stream (everything up to, but not including, CR/LF).

Parameters:
StreamCharacter stream to search.
LineStringThe first line in Stream.
GoToNextLineIf true, advanced the pointer after the first CR/LF character at the end of the string. If FALSE advanced the pointer past all the CR/LF character at the end of the string.
Returns:
True i a line was copied to LineString;

Definition at line 401 of file Parsing.cpp.

  {
    LineString.Clear();

    while ( (**Stream != 0) && (**Stream != CHAR_NEW_LINE) && (**Stream != CHAR_CR) && (**Stream != CHAR_FF) )
    {
      LineString += **Stream++;
    }

    return LineString.Size() > 0;
  }
bool nux::ParseParam ( const TCHAR *  Stream,
const TCHAR *  Param 
)

Checks if a Token command-line parameter exists in the stream.

Checks if a Token command-line parameter exists in the stream

Parameters:
Streamstream of characters to search
tokento match
Returns:
True if found.

Definition at line 115 of file Parsing.cpp.

  {
    const TCHAR *Start = Stream;

    if (*Stream)
    {
      while ( (Start = Strfind (Start + 1, Param) ) != NULL)
      {
        if (Start > Stream && ( (Start[-1] == TEXT ('-') ) || (Start[-1] == TEXT ('/') ) ) )
        {
          const TCHAR *End = Start + StringLength (Param);

          if (End == NULL || *End == 0 || IsWhitespaceChar (*End) )
            return true;
        }
      }
    }

    return false;
  }
bool nux::ParseToken ( const TCHAR *  Str,
TCHAR *  TokenBuffer,
t_int  BufferSize 
)

Parse the next space-delimited string from the input stream. If the next token starts with a quote, gets entire quoted string.

Parameters:
Strstream of characters to search.
TokenBufferThe parsed token string.
BufferSizeSize of the TokenBuffer.
Returns:
True if a token was found.

Definition at line 299 of file Parsing.cpp.

  {
    t_int sz = 0;

    while ( (*Str == TEXT (' ') ) || (*Str == CHAR_TAB) )
    {
      // Skip spaces and tabs.
      Str++;
    }

    if (*Str == CHAR_QUOTE)
    {
      // Get quoted string.
      Str++;

      while (*Str && (*Str != CHAR_QUOTE) && (sz + 1 < BufferSize) )
      {
        TCHAR c = *Str++;

        if (sz + 1 < BufferSize)
          TokenBuffer[sz++] = c;
      }

      if (*Str == CHAR_QUOTE)
        Str++;
    }
    else
    {
      // Get unquoted string.
      for (; *Str && (*Str != TEXT (' ') ) && (*Str != CHAR_TAB); Str++)
      {
        if (sz + 1 < BufferSize)
          TokenBuffer[sz++] = *Str;
      }
    }

    TokenBuffer[sz] = 0;
    return sz != 0;
  }
bool nux::ParseToken ( const TCHAR *  Str,
NString &  TokenString 
)

Parse the next space-delimited string from the input stream. If the next token starts with a quote, gets entire quoted string.

Parameters:
Strstream of characters to search.
TokenBufferThe parsed token string.
Returns:
True if a token was found.

Definition at line 339 of file Parsing.cpp.

  {
    TokenString.Clear();

    // Skip spaces and tabs.
    while (IsWhitespaceChar (*Str) )
      Str++;

    if (*Str == CHAR_QUOTE)
    {
      // Get quoted string.
      Str++;

      while (*Str && *Str != CHAR_QUOTE)
      {
        TCHAR c = *Str++;
        TokenString += c;
      }

      if (*Str == CHAR_QUOTE)
        Str++;
    }
    else
    {
      // Get unquoted string.
      for (; *Str && !IsWhitespaceChar (*Str); Str++)
      {
        TokenString += *Str;
      }
    }

    return TokenString.Length() > 0;
  }
NString nux::ParseToken ( const TCHAR *  Str)

Parse the next space-delimited string from the input stream. If the next token starts with a quote, gets entire quoted string.

Parameters:
Strstream of characters to parse.
Returns:
The next token in a NString.
void nux::ParseToNextLine ( const TCHAR **  Stream,
TCHAR  CommentChar 
)

Go to the next token in the stream.

Skip tabs, and space at the beginning of each line. Skip everything on a line that follows the given comment char token If there is a valid token in the input, Stream will point to it.

Parameters:
Streamstream of characters
CommentCharCharacter representing the beginning of a comment on a line. ie ';' '#".

Definition at line 271 of file Parsing.cpp.

  {
    // Skip over spaces, tabs, cr's, and linefeeds.

    while (1)
    {
      while ( (**Stream == TEXT (' ') ) || (**Stream == CHAR_TAB) || (**Stream == CHAR_CR) || (**Stream == CHAR_NEW_LINE)  || (**Stream == CHAR_FF) )
      {
        // Skip tabs, cr, new line, form feed
        ++*Stream;
      }

      if (**Stream == CommentChar)
      {
        // Start of a comment
        while ( (**Stream != 0) && (**Stream != CHAR_NEW_LINE) && (**Stream != CHAR_CR) )
        {
          // Advance to a new line
          ++*Stream;
        }
      }
      else
      {
        break;
      }
    }
  }
int nux::PointInside2DPolygon ( Point2 *  polygon,
int  n,
Point2  pt,
const int  onedge 
)

Determine if a point lies inside a polygon.

If the point is on an edge or a point of the polygon, return the parameter "OnEdge" The polygon to test.
Number of points in the polygon
pt The point to test. Value to return if the point lies on an edge or a vertex of the polygon

Returns:
1 if the point is inside, 0 if it is outside, onedge if it is on the edges of the polygon.

Definition at line 29 of file Algo.cpp.

  {
    nuxAssert(n > 3);
    if(n < 3)
      return 0;
    //cross points count of x
    int __count = 0;

    //neighbor bound vertices
    Point2D<float> p1, p2;

    //left vertex
    p1 = polygon[0];

    //check all rays
    for(int i = 1; i <= n; ++i)
    {
      //point is an vertex
      if(pt == p1) return onedge;

      //right vertex
      p2 = polygon[i % n];

      //ray is outside of our interests
      if(pt.y < Min<float>(p1.y, p2.y) || pt.y > Max<float>(p1.y, p2.y))
      {
        //next ray left point
        p1 = p2; continue;
      }

      //ray is crossing over by the algorithm (common part of)
      if(pt.y > Min<float>(p1.y, p2.y) && pt.y < Max<float>(p1.y, p2.y))
      {
        //x is before of ray
        if(pt.x <= Max<float>(p1.x, p2.x))
        {
          //overlies on a horizontal ray
          if(p1.y == p2.y && pt.x >= Min<float>(p1.x, p2.x)) return onedge;

          //ray is vertical
          if(p1.x == p2.x)
          {
            //overlies on a ray
            if(p1.x == pt.x) return onedge;
            //before ray
            else ++__count;
          }

          //cross point on the left side
          else
          {
            //cross point of x
            double xinters = (pt.y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y) + p1.x;

            //overlies on a ray
            if(fabs(pt.x - xinters) < Const::dbl_epsilon) return onedge;

            //before ray
            if(pt.x < xinters) ++__count;
          }
        }
      }
      //special case when ray is crossing through the vertex
      else
      {
        //p crossing over p2
        if(pt.y == p2.y && pt.x <= p2.x)
        {
          //next vertex
          const Point2& p3 = polygon[(i+1) % n];

          //pt.y lies between p1.y & p3.y
          if(pt.y >= Min<float>(p1.y, p3.y) && pt.y <= Max<float>(p1.y, p3.y))
          {
            ++__count;
          }
          else
          {
            __count += 2;
          }
        }
      }

      //next ray left point
      p1 = p2;
    }

    //EVEN
    if(__count % 2 == 0) return(0);
    //ODD
    else return(1);
  }
template<class T >
T nux::PowerInt ( _X,
int  _Y 
) [inline]

Template power function. The exponent is an integer.

Definition at line 41 of file MathFunctions.h.

  {
    unsigned int _N;

    if (_Y >= 0)
      _N = _Y;
    else
      _N = -_Y;

    for (T _Z = T (1); ; _X *= _X)
    {
      if ( (_N & 1) != 0)
        _Z *= _X;

      if ( (_N >>= 1) == 0)
        return (_Y < 0 ? T (1) / _Z : _Z);
    }
  }
void nux::QRP_Compute_Texture_Coord ( t_int32  quad_width,
t_int32  quad_height,
ObjectPtr< IOpenGLBaseTexture >  tex,
TexCoordXForm &  texxform 
)

Compute texture coordinates and wrapping mode according to TexCoordXForm.

Parameters:
quad_widthQuad width.
quad_heightQuad height.
texDevice texture.
texxformTexture coordinates computation mode.

Definition at line 198 of file RenderingPipe.cpp.

References nux::TexCoordXForm::FIXED_COORD, nux::TexCoordXForm::NORMALIZED_COORD, nux::TexCoordXForm::OFFSET_COORD, nux::TexCoordXForm::OFFSET_SCALE_COORD, nux::TexCoordXForm::u0, and nux::TexCoordXForm::UNNORMALIZED_COORD.

  {
    float tex_width = tex->GetWidth();
    float tex_height = tex->GetHeight();

    if (tex->Type().IsDerivedFromType (IOpenGLTexture2D::StaticObjectType) )
    {
      if (texxform.m_tex_coord_type == TexCoordXForm::OFFSET_SCALE_COORD)
      {
        texxform.u0 = texxform.uoffset;
        texxform.v0 = texxform.voffset;
        texxform.u1 = texxform.u0 + texxform.uscale;
        texxform.v1 = texxform.v0 + texxform.vscale;
      }
      else if (texxform.m_tex_coord_type == TexCoordXForm::OFFSET_COORD)
      {
        texxform.u0 = texxform.uoffset;
        texxform.v0 = texxform.voffset;
        texxform.u1 = texxform.u0 + (float) quad_width / tex_width;
        texxform.v1 = texxform.v0 + (float) quad_height / tex_height;
      }
      else if (texxform.m_tex_coord_type == TexCoordXForm::UNNORMALIZED_COORD)
      {
        texxform.u0 /= (float) tex_width;
        texxform.v0 /= (float) tex_height;
        texxform.u1 /= (float) tex_width;
        texxform.v1 /= (float) tex_height;
      }
      else if (texxform.m_tex_coord_type == TexCoordXForm::NORMALIZED_COORD || texxform.m_tex_coord_type == TexCoordXForm::FIXED_COORD)
      {
        // Use provided texture coordinates as is.
      }
    }
    else if (tex->Type().IsDerivedFromType (IOpenGLRectangleTexture::StaticObjectType) )
    {
      if (texxform.m_tex_coord_type == TexCoordXForm::OFFSET_SCALE_COORD)
      {
        texxform.u0 = t_int32 (texxform.uoffset * tex_width);
        texxform.v0 = t_int32 (texxform.voffset * tex_height);
        texxform.u1 = texxform.u0 + tex_width * texxform.uscale;
        texxform.v1 = texxform.v0 + tex_height * texxform.vscale;
      }
      else if (texxform.m_tex_coord_type == TexCoordXForm::OFFSET_COORD)
      {
        texxform.u0 = texxform.uoffset;
        texxform.v0 = texxform.voffset;
        texxform.u1 = texxform.u0 + quad_width;
        texxform.v1 = texxform.v0 + quad_height;
      }
      else if (texxform.m_tex_coord_type == TexCoordXForm::NORMALIZED_COORD)
      {
        texxform.u0 *= (float) tex_width;
        texxform.v0 *= (float) tex_height;
        texxform.u1 *= (float) tex_width;
        texxform.v1 *= (float) tex_height;
      }
      else if (texxform.m_tex_coord_type == TexCoordXForm::UNNORMALIZED_COORD || texxform.m_tex_coord_type == TexCoordXForm::FIXED_COORD)
      {
        // Use provided texture coordinates as is.
      }
    }

    if (texxform.flip_u_coord)
    {
      float temp = texxform.u0;
      texxform.u0 = texxform.u1;
      texxform.u1 = temp;
    }

    if (texxform.flip_v_coord)
    {
      float temp = texxform.v0;
      texxform.v0 = texxform.v1;
      texxform.v1 = temp;
    }

    if (tex->Type().IsDerivedFromType (IOpenGLRectangleTexture::StaticObjectType) )
    {
      // A chance to avoid some potential errors! Rectangle textures support only GL_CLAMP, GL_CLAMP_TO_EDGE, and GL_CLAMP_TO_BORDER.
      // See http://www.opengl.org/registry/specs/ARB/texture_rectangle.txt
      if(texxform.uwrap != TEXWRAP_CLAMP ||
        texxform.uwrap != TEXWRAP_CLAMP_TO_EDGE ||
        texxform.uwrap != TEXWRAP_CLAMP_TO_BORDER ||
        texxform.vwrap != TEXWRAP_CLAMP ||
        texxform.vwrap != TEXWRAP_CLAMP_TO_EDGE ||
        texxform.vwrap != TEXWRAP_CLAMP_TO_BORDER)
      {
        texxform.uwrap = TEXWRAP_CLAMP;
        texxform.vwrap = TEXWRAP_CLAMP;
      }
    }
    tex->SetWrap (TexWrapGLMapping (texxform.uwrap), TexWrapGLMapping (texxform.vwrap), GL_CLAMP);
    tex->SetFiltering (TexFilterGLMapping (texxform.min_filter), TexFilterGLMapping (texxform.mag_filter) );
  }
double nux::Random ( ) [inline]

Return a random variable between [0,1[ (uniform distribution).

Returns:
a random double value in the range [0, 1[

Definition at line 144 of file MathUtility.h.

  {
    return (double) std::rand() / RAND_MAX;
  }
double nux::RandomGaussian ( ) [inline]

Return a random variable using a gaussian distribution and a variance of 1.

Returns:
a random double value in the range [-1, 1[.

Definition at line 162 of file MathUtility.h.

  {
    return std::sqrt (-2 * std::log ((double) (1e-10 + (1 - 2e-10) * std::rand()))) * std::cos ((double) (2 * 3.14f/*Const::pi*/*std::rand()));
  }
t_u64 nux::ReverseByteOrdering ( t_u64  value) [inline]

Revert Byte order 0x0011223344556677 -> 0x7766554433221100

Definition at line 258 of file MathUtility.h.

  {
    t_u64 temp;
    t_u8 *src = (t_u8 *) &value;
    t_u8 *dest = (t_u8 *) &temp;

    dest[0] = src[7];
    dest[1] = src[6];
    dest[2] = src[5];
    dest[3] = src[4];
    dest[4] = src[3];
    dest[5] = src[2];
    dest[6] = src[1];
    dest[7] = src[0];

    return temp;
  }
t_u16 nux::ReverseByteOrdering ( t_u16  value) [inline]

Revert Byte order 0x0011 -> 0x1100

Definition at line 224 of file MathUtility.h.

  {
    t_u16 temp;
    t_u8 *src = (t_u8 *) &value;
    t_u8 *dest = (t_u8 *) &temp;

    dest[0] = src[1];
    dest[1] = src[0];

    return temp;
  }
t_u32 nux::ReverseByteOrdering ( t_u32  value) [inline]

Revert Byte order 0x00112233 -> 0x33221100

Definition at line 240 of file MathUtility.h.

  {
    t_u32 temp;
    t_u8 *src = (t_u8 *) &value;
    t_u8 *dest = (t_u8 *) &temp;

    dest[0] = src[3];
    dest[1] = src[2];
    dest[2] = src[1];
    dest[3] = src[0];

    return temp;
  }
template<typename T >
T nux::RoundDown ( Value,
int  Alignment 
) [inline]

Round down to the nearest multiple of Alignment that is smaller or equal to Value.

Parameters:
AlignmentMust be a power of 2

Definition at line 206 of file MathUtility.h.

  {
    return ((Value) & ~ (Alignment - 1));
  }
template<typename T >
T nux::RoundUp ( Value,
int  Alignment 
) [inline]

Round up to the nearest multiple of Alignment that is greater or equal to Value.

Parameters:
AlignmentMust be a power of 2

Definition at line 197 of file MathUtility.h.

  {
    return (Value + (Alignment - 1)) & ~ (Alignment - 1);
  }
bool nux::SaveArrayToFile ( const std::vector< BYTE > &  Array,
const TCHAR *  Filename,
NFileManager &  FileManager 
)

Save BYTE array to file.

Definition at line 306 of file FileIO.cpp.

  {
    NSerializer *Ar = FileManager.CreateFileWriter ( Filename );

    if ( !Ar )
      return 0;

    Ar->Serialize ( const_cast<BYTE *> (&Array[0]), Array.size() );
    delete Ar;
    return 1;
  }
bool nux::SaveStringToFile ( const NString &  String,
const TCHAR *  Filename,
NFileManager &  FileManager 
)

Save string to File. Attempt to write it as ASCII if possible. If not write as UTF16-BE.

Definition at line 321 of file FileIO.cpp.

  {
    if ( !String.Length() )
      return 0;

    NSerializer *Ar = FileManager.CreateFileWriter ( Filename );

    if ( !Ar )
      return 0;

    bool SaveAsUnicode = false, Success = true;
#if UNICODE

    for ( int i = 0; i < String.Length(); i++ )
    {
      // Test if the UNICODE 0xABCD is the same as the ASCII 0x00CB.
      if ( (*String) [i] != (TCHAR) (ANSIUCHAR) ConvertTCHARToAnsiChar ( (*String) [i]) )
      {
        //The string need to be written in ASCII. We write the string as UTF16-BigEndian
        Ar->Serialize (NUX_CONST_CAST (BYTE *, &UTF16_BE[1]), UTF16_BE[0] /*size*/);
        SaveAsUnicode = true;
        break;
      }
    }

#endif

    if ( SaveAsUnicode || (sizeof (TCHAR) == 1) )
    {
      t_u32 s = (t_u32) String.Length() * sizeof (TCHAR);
      Ar->Serialize ( NUX_CONST_CAST (TCHAR *, String.GetTCharPtr() ), (t_u32) s);
    }
    else
    {
      t_u32 s = (t_u32) String.Length();
      std::vector<ANSICHAR> AnsiBuffer ( (t_u32) s);

      // Cast all character down from UTF16 to ANSI
      for (t_u32 i = 0; i < (t_u32) String.Length(); i++ )
        AnsiBuffer[i] = ConvertTCHARToAnsiChar ( (t_u32) String[i]);

      // serialize
      s = (t_u32) String.Length();
      Ar->Serialize ( NUX_CONST_CAST (ANSICHAR *, &AnsiBuffer[0]), s);
    }

    delete Ar;

    if ( !Success )
      GFileManager.Delete ( Filename );

    return Success;
  }
double nux::Seconds ( )

Returns the time that has passed in seconds. The origin is unknown.

Returns the time that has passed in seconds. The origin is unknown.

Returns:
the time passed in seconds.
void nux::SleepForMilliseconds ( unsigned int  Milliseconds)

Suspend thread execution for an interval measured in microseconds.

duration in Milliseconds.

Definition at line 243 of file TimeFunctions.cpp.

  {
#if defined(NUX_OS_WINDOWS)
    Sleep (Milliseconds);

#elif defined(NUX_OS_LINUX)
    int ret = usleep (Milliseconds * 1000);

    if (ret != 0)
    {
      nuxDebugMsg (TEXT ("[SleepForMilliseconds] usleep has failed.") );
    }

#else
#error Sleep(milliseconds) is not implemented for this platform.
#endif
  }
TCHAR * nux::Strncat ( TCHAR *  Dest,
t_size  Size,
const TCHAR *  Src,
t_size  Max 
)

Concatenate a string with length checking.

Definition at line 42 of file TextString.cpp.

  {
    t_size Len = StringLength (Dest);
    nuxAssert (Size >= Len);
    TCHAR *NewDest = Dest + Len;

    if ( (MaxLen -= Len) > 0)
    {
      Strncpy (NewDest, Size - Len, Src, MaxLen);
      NewDest[MaxLen-1] = 0;
    }

    return Dest;
  }
bool nux::tr_utf8_validate ( const char *  str,
int  max_len,
const char **  end 
)

This is a variation of isLegalUTF8Sequence() that behaves like g_utf8_validate().

In addition to knowing if the sequence is legal, it also tells you the last good character.

Definition at line 509 of file NUni.cpp.

  {
    const t_UTF8 *source = (const t_UTF8 *) str;
    const t_UTF8 *sourceEnd;

    if ( max_len == 0 )
      return true;

    if ( str == NULL )
      return false;

    sourceEnd = source + ( (max_len < 0) ? strlen (str) : (size_t) max_len);

    if ( source == sourceEnd )
    {
      if ( end != NULL )
        *end = (const char *) source;

      return true;
    }

    for ( ;; )
    {
      const int length = trailingBytesForUTF8[*source] + 1;

      if (source + length > sourceEnd)
      {
        if ( end != NULL )
          *end = (const char *) source;

        return false;
      }

      if (!isLegalUTF8 (source, length) )
      {
        if ( end != NULL )
          *end = (const char *) source;

        return false;
      }

      source += length;

      if (source >= sourceEnd)
      {
        if ( end != NULL )
          *end = (const char *) source;

        return true;
      }
    }


  }
nux::VARARG_BODY ( NString  ,
NString::Printf  ,
const TCHAR *  ,
VARARG_NONE   
)

Behave like printf. Use an internal buffer of 1024 characters. Do not use this function if you are expecting the result to be more that 1024-1 characters.

Returns:
A string with formated arguments in a NString.

Definition at line 1346 of file TextString.cpp.

  {
    t_u32  BufferSize  = 1024;
    TCHAR *Buffer      = NULL;
    t_size Result      = tstring::npos;

    while (Result == tstring::npos)
    {
      Buffer = (TCHAR *) Realloc (Buffer, BufferSize * sizeof (TCHAR) );
      GET_VARARGS_RESULT (Buffer, BufferSize, BufferSize - 1, Fmt, Result);
      BufferSize *= 2;
    };

    Buffer[Result] = 0;

    NString ResultString (Buffer);

    free (Buffer);

    return ResultString;
  }

Variable Documentation

NString nux::AsmBlueFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                \n\
       PARAM RectPosition = program.local[0];              \n\
       PARAM RectDimension = program.local[1];             \n\
       PARAM Color = program.local[2];                     \n\
       TEMP temp0;                                         \n\
       TEMP temp1;                                         \n\
       SUB temp0.x, fragment.position.x, RectPosition.x;   \n\
       SUB temp0.y, fragment.position.y, RectPosition.y;   \n\
       RCP temp1.x, RectDimension.x;                       \n\
       RCP temp1.y, RectDimension.y;                       \n\
       MUL temp0.xy, temp0, temp1;                         \n\
       MOV temp1.z, Color;                                 \n\
       MOV temp1.xy, temp0.xyxx;                           \n\
       MOV temp1.w, {1, 1, 1, 1};                          \n\
       MOV result.color, temp1;                            \n\
       END")

Definition at line 192 of file GLSh_ColorPicker.cpp.

NString nux::AsmFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                  \n\
        PARAM RectPosition = program.local[0];              \n\
        PARAM RectDimension = program.local[1];             \n\
        PARAM Color = program.local[2];                     \n\
        TEMP temp0;                                         \n\
        TEMP temp1;                                         \n\
        TEMP tex0;                                          \n\
        SUB temp0.x, fragment.position.x, RectPosition.x;   \n\
        SUB temp0.y, fragment.position.y, RectPosition.y;   \n\
        RCP temp1.x, RectDimension.x;                       \n\
        RCP temp1.y, RectDimension.y;                       \n\
        MUL temp1.xy, temp0, temp1;                         \n\
        TEX tex0, temp1, texture[0], 2D;       \n\
        SUB temp0, tex0.xxxx, temp1.yyyy;                   \n\
        KIL temp0;              \n\
        MOV result.color, Color;                            \n\
        END")

Definition at line 79 of file GLSh_DrawFunction.cpp.

NString nux::AsmGreenFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                  \n\
       PARAM RectPosition = program.local[0];              \n\
       PARAM RectDimension = program.local[1];             \n\
       PARAM Color = program.local[2];                     \n\
       TEMP temp0;                                         \n\
       TEMP temp1;                                         \n\
       SUB temp0.x, fragment.position.x, RectPosition.x;   \n\
       SUB temp0.y, fragment.position.y, RectPosition.y;   \n\
       RCP temp1.x, RectDimension.x;                       \n\
       RCP temp1.y, RectDimension.y;                       \n\
       MUL temp0.xy, temp0, temp1;                         \n\
       MOV temp1.y, Color;                                 \n\
       MOV temp1.xz, temp0.yyxx;                           \n\
       MOV temp1.w, {1, 1, 1, 1};                          \n\
       MOV result.color, temp1;                            \n\
       END")

Definition at line 175 of file GLSh_ColorPicker.cpp.

NString nux::AsmHueFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                  \n\
        MOV result.color, {0, 0, 0, 0};                     \n\
        END")

Definition at line 210 of file GLSh_ColorPicker.cpp.

NString nux::AsmRedFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                  \n\
        PARAM RectPosition = program.local[0];              \n\
        PARAM RectDimension = program.local[1];             \n\
        PARAM Color = program.local[2];                     \n\
        TEMP temp0;                                         \n\
        TEMP temp1;                                         \n\
        SUB temp0.x, fragment.position.x, RectPosition.x;   \n\
        SUB temp0.y, fragment.position.y, RectPosition.y;   \n\
        RCP temp1.x, RectDimension.x;                       \n\
        RCP temp1.y, RectDimension.y;                       \n\
        MUL temp0.xy, temp0, temp1;                         \n\
        MOV temp1.x, Color;                                 \n\
        MOV temp1.yz, temp0.yyxx;                           \n\
        MOV temp1.w, {1, 1, 1, 1};                          \n\
        MOV result.color, temp1;                            \n\
        END")

Definition at line 158 of file GLSh_ColorPicker.cpp.

NString nux::AsmSaturationFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                  \n\
       MOV result.color, {0, 0, 0, 0};                      \n\
       END")

Definition at line 214 of file GLSh_ColorPicker.cpp.

NString nux::AsmValueFrgShader
Initial value:
 TEXT ("!!ARBfp1.0                  \n\
       MOV result.color, {0, 0, 0, 0};                      \n\
       END")

Definition at line 218 of file GLSh_ColorPicker.cpp.

GLenum nux::AttachmentBuffer[]
Initial value:
  {
    GL_COLOR_ATTACHMENT0_EXT
    , GL_COLOR_ATTACHMENT1_EXT
    , GL_COLOR_ATTACHMENT2_EXT
    , GL_COLOR_ATTACHMENT3_EXT
  }

Definition at line 37 of file GLDeviceFrameBufferObject.cpp.

EventToNameStruct nux::EventToName
Initial value:
  {
    {NUX_NO_EVENT,               TEXT ("NUX_NO_EVENT") },
    {NUX_MOUSE_PRESSED,          TEXT ("NUX_MOUSE_PRESSED") },
    {NUX_MOUSE_RELEASED,         TEXT ("NUX_MOUSE_RELEASED") },
    {NUX_KEYDOWN,                TEXT ("NUX_KEYDOWN") },
    {NUX_KEYUP,                  TEXT ("NUX_KEYUP") },
    {NUX_MOUSE_MOVE,             TEXT ("NUX_MOUSE_MOVE") },
    {NUX_SIZE_CONFIGURATION,     TEXT ("NUX_SIZE_CONFIGURATION") },
    {NUX_WINDOW_CONFIGURATION,   TEXT ("NUX_WINDOW_CONFIGURATION") },
    {NUX_WINDOW_ENTER_FOCUS,     TEXT ("NUX_WINDOW_ENTER_FOCUS") },
    {NUX_WINDOW_EXIT_FOCUS,      TEXT ("NUX_WINDOW_EXIT_FOCUS") },
    {NUX_WINDOW_DIRTY,           TEXT ("NUX_WINDOW_DIRTY") },
    {NUX_WINDOW_MOUSELEAVE,      TEXT ("NUX_WINDOW_MOUSELEAVE") },
    {NUX_TERMINATE_APP,          TEXT ("NUX_TERMINATE_APP") }
  }

Definition at line 87 of file GraphicsDisplayWin.cpp.

NString nux::FontAsmFrg
Initial value:
 TEXT ("!!ARBfp1.0            \n\
  PARAM color = program.local[0];                   \n\
  TEMP temp;                                        \n\
  TEMP tex0;                                        \n\
  TEX tex0, fragment.texcoord[0], texture[0], 2D;   \n\
  MOV temp, color;                                  \n\
  MUL temp.w, color, tex0;                          \n\
  MOV result.color, temp;                           \n\
  END")

Definition at line 84 of file FontRenderer.cpp.

NString nux::FontAsmFrgRect
Initial value:
 TEXT ("!!ARBfp1.0        \n\
  PARAM color = program.local[0];                   \n\
  TEMP temp;                                        \n\
  TEMP tex0;                                        \n\
  TEX tex0, fragment.texcoord[0], texture[0], RECT; \n\
  MOV temp, color;                                  \n\
  MUL temp.w, color, tex0;                          \n\
  MOV result.color, temp;                           \n\
  END")

Definition at line 94 of file FontRenderer.cpp.

NString nux::FontAsmVtx
Initial value:
 TEXT ("!!ARBvp1.0          \n\
  ATTRIB iScale       = vertex.attrib[9];         \n\
  ATTRIB iOffset      = vertex.attrib[10];        \n\
  OUTPUT oPos         = result.position;          \n\
  OUTPUT oTexCoord0   = result.texcoord[0];       \n\
  # Transform the vertex to clip coordinates.     \n\
  TEMP temp;                                      \n\
  MAD   temp, vertex.position, iScale, iOffset;   \n\
  DP4   oPos.x, state.matrix.mvp.row[0], temp;    \n\
  DP4   oPos.y, state.matrix.mvp.row[1], temp;    \n\
  DP4   oPos.z, state.matrix.mvp.row[2], temp;    \n\
  DP4   oPos.w, state.matrix.mvp.row[3], temp;    \n\
  MOV   oTexCoord0, vertex.attrib[8];             \n\
  END")

Definition at line 69 of file FontRenderer.cpp.

NString nux::gFontFragShader
Initial value:
 TEXT ("#version 110                             \n\
  #extension GL_ARB_texture_rectangle : enable                              \n\
  uniform sampler2DRect FontTexture;                                        \n\
  uniform vec4 TextColor;                                                   \n\
  varying vec4 oTexCoord0;                                                  \n\
  void main()                                                               \n\
  {                                                                         \n\
    vec4 diffuse = texture2DRect(FontTexture, oTexCoord0.st);               \n\
    gl_FragColor = vec4(TextColor.x, TextColor.y, TextColor.z, diffuse.w);  \n\
  }")

Definition at line 58 of file FontRenderer.cpp.

NString nux::gFontVtxShader
Initial value:
 TEXT ("#version 110      \n\
  attribute vec4 _Position;                         \n\
  attribute vec4 iOffset;                           \n\
  attribute vec4 iScale;                            \n\
  attribute vec4 iTexUV;                            \n\
  uniform mat4 ViewProjectionMatrix;                \n\
  varying vec4 oTexCoord0;                          \n\
  void main()                                       \n\
  {                                                 \n\
  oTexCoord0   = iTexUV;                            \n\
  vec4 myvertex = _Position * iScale + iOffset;     \n\
  gl_Position  = ViewProjectionMatrix * myvertex;   \n\
  }")

Definition at line 44 of file FontRenderer.cpp.

PixelFormatInfo nux::GPixelFormats
Initial value:
  {
    
    
    { TEXT ("BITFMT_UNKNOWN"),           0,          0,          0,      0,              0,          0,      0,       0,      0,          0,            false       },  
    { TEXT ("BITFMT_R8G8B8A8"),         1,                      1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_A8B8G8R8"),         1,                      1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_B8G8R8A8"),         1,                      1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_A8R8G8B8"),         1,                      1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_R8G8B8"),            1,          1,         1,      3,              3,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_B8G8R8"),            1,          1,         1,      3,              3,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_R5G6B5"),            1,          1,          1,      2,              3,          0,      0,       0,      1,          0,            true        },  
    { TEXT ("BITFMT_RGBA16F"),           1,          1,          1,      8,              4,          0,      0,       0,      1,          0,            true        },  
    { TEXT ("BITFMT_RGB32F"),            1,          1,          1,      12,             3,          0,      0,       0,      1,          0,            true        },  
    { TEXT ("BITFMT_RGBA32F"),           1,          1,          1,      16,             4,          0,      0,       0,      1,          0,            true        },  
    { TEXT ("BITFMT_D24S8"),             1,          1,          1,      4,              2,          0,      0,       0,      1,          0,            true        },  
    { TEXT ("BITFMT_DXT1"),              4,                     4,              1,      8,              3,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_DXT2"),              4,                     4,              1,      16,             4,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_DXT3"),              4,                     4,              1,      16,             4,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_DXT4"),              4,                     4,              1,      16,             4,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_DXT5"),              4,                     4,              1,      16,             4,          0,      0,       0,      1,          0,             true        },  
    { TEXT ("BITFMT_R10G10B10A2"),          1,                  1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_A2B10G10R10"),          1,                  1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_B10G10R10A2"),          1,                  1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  
    { TEXT ("BITFMT_A2R10G10B10"),          1,                  1,              1,      4,              4,          0,      0,       0,      4,          0,             true        },  

    { TEXT ("BITFMT_A8"),                   1,                  1,              1,          1,          1,          0,      0,       0,      1,          0,             true        },  

    { TEXT ("BITFMT_END_GFX_FORMATS"),  0,          0,          0,          0,          0,          0,      0,       0,      0,          0,             false       }, 
  }

Definition at line 33 of file GLResourceManager.cpp.

ReadBackPixelFormatInfo nux::GReadBackPixelFormats
Initial value:
  {
    

    { TEXT ("BITFMT_UNKNOWN"),           0,          0,                         0,              0,         0,           false       },  
    { TEXT ("BITFMT_R8G8B8A8"),         4,          4,                          0,              0,         0,           true        },  
    { TEXT ("BITFMT_A8B8G8R8"),         4,          4,                          0,              0,         0,           true        },  
    { TEXT ("BITFMT_B8G8R8A8"),         4,          4,                          0,              0,         0,           true        },  
    { TEXT ("BITFMT_A8R8G8B8"),         4,          4,                          0,              0,         0,           true        },  
    { TEXT ("BITFMT_R8G8B8"),            3,          3,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_B8G8R8"),            3,          3,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_R5G6B5"),            2,          3,              0,          0,         0,           true        }, 
    { TEXT ("BITFMT_RGBA16F"),           8,          4,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_RGBA32F"),           16,         4,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_D24S8"),             4,          2,              0,          0,         0,           true        }, 
    { TEXT ("BITFMT_DXT1"),              8,          3,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_DXT2"),              16,         4,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_DXT3"),              16,         4,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_DXT4"),              16,         4,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_DXT5"),              16,         4,                         0,              0,         0,           true        },  
    { TEXT ("BITFMT_R10G10B10A2"),          4,          4,                              0,              0,         0,           true        },  
    { TEXT ("BITFMT_A2B10G10R10"),          4,          4,                              0,              0,         0,           true        },  
    { TEXT ("BITFMT_B10G10R10A2"),          4,          4,                              0,              0,         0,           true        },  
    { TEXT ("BITFMT_A2R10G10B10"),          4,          4,                              0,              0,         0,           true        },  

    { TEXT ("BITFMT_A8"),                   1,          1,                              0,              0,         0,           true        },  

    { TEXT ("BITFMT_END_GFX_FORMATS"),   0,          0,                         0,              0,         0,               false       }, 
  }

Definition at line 61 of file BitmapFormats.cpp.

const TCHAR * nux::OGLDeviceErrorMessages
Initial value:
  {
    TEXT ("OGL_OK"),
    TEXT ("OGL_ERROR_UNKNOWN"),
    TEXT ("OGL_INVALID_SURFACE_LEVEL"),
    TEXT ("OGL_INVALID_CALL"),
    TEXT ("OGL_INVALID_LOCK"),
    TEXT ("OGL_INVALID_UNLOCK"),
    TEXT ("OGL_INVALID_TEXTURE"),
  }

Definition at line 29 of file GLResource.cpp.

struct RopBlendMapping nux::RopBlendMappingArray[]
Initial value:
  {
    {ROPBLEND_ZERO,                             GL_ZERO},
    {ROPBLEND_ONE,                              GL_ONE},
    {ROPBLEND_SRC_COLOR,                        GL_SRC_COLOR},
    {ROPBLEND_ONE_MINUS_SRC_COLOR,              GL_ONE_MINUS_SRC_COLOR},
    {ROPBLEND_DST_COLOR,                        GL_DST_COLOR},
    {ROPBLEND_ONE_MINUS_DST_COLOR,              GL_ONE_MINUS_DST_COLOR},
    {ROPBLEND_SRC_ALPHA,                        GL_SRC_ALPHA},
    {ROPBLEND_ONE_MINUS_SRC_ALPHA,              GL_ONE_MINUS_SRC_ALPHA},
    {ROPBLEND_DST_ALPHA,                        GL_DST_ALPHA},
    {ROPBLEND_ONE_MINUS_DST_ALPHA,              GL_ONE_MINUS_DST_ALPHA},
    {ROPBLEND_CONSTANT_COLOR,                   GL_CONSTANT_COLOR},
    {ROPBLEND_ONE_MINUS_CONSTANT_COLOR,         GL_ONE_MINUS_CONSTANT_COLOR},
    {ROPBLEND_CONSTANT_ALPHA,                   GL_CONSTANT_ALPHA},
    {ROPBLEND_ONE_MINUS_CONSTANT_ALPHA,         GL_ONE_MINUS_CONSTANT_ALPHA},
    {ROPBLEND_SRC_ALPHA_SATURATE,               GL_SRC_ALPHA_SATURATE},
    {ROPBLEND_UNKNOWN,                          0},
  }

Definition at line 111 of file RenderingPipe.cpp.

struct TexFilterMapping nux::TexFilterMappingArray[]
Initial value:
  {
    {TEXFILTER_LINEAR,                  GL_LINEAR},
    {TEXFILTER_NEAREST,                 GL_NEAREST},
    {TEXFILTER_NEAREST_MIPMAP_NEAREST,  GL_NEAREST_MIPMAP_NEAREST},
    {TEXFILTER_LINEAR_MIPMAP_NEAREST,   GL_LINEAR_MIPMAP_NEAREST},
    {TEXFILTER_NEAREST_MIPMAP_LINEAR,   GL_NEAREST_MIPMAP_LINEAR},
    {TEXFILTER_LINEAR_MIPMAP_LINEAR,    GL_LINEAR_MIPMAP_LINEAR},
    {TEXFILTER_UNKNOWN,                 0},
  }

Definition at line 76 of file RenderingPipe.cpp.

struct TexWrapMapping nux::TexWrapMappingArray[]
Initial value:
  {
    {TEXWRAP_REPEAT,                        GL_REPEAT},
    {TEXWRAP_CLAMP,                         GL_CLAMP},
    {TEXWRAP_CLAMP_TO_EDGE,                 GL_CLAMP_TO_EDGE},
    {TEXWRAP_CLAMP_TO_BORDER,               GL_CLAMP_TO_BORDER},
    {TEXWRAP_MIRRORED_REPEAT,               GL_MIRRORED_REPEAT},
    {TEXWRAP_MIRROR_CLAMP_EXT,              GL_MIRROR_CLAMP_EXT},
    {TEXWRAP_MIRROR_CLAMP_TO_EDGE_EXT,      GL_MIRROR_CLAMP_TO_EDGE_EXT},
    {TEXWRAP_MIRROR_CLAMP_TO_BORDER_EXT,    GL_MIRROR_CLAMP_TO_BORDER_EXT},
    {TEXWRAP_UNKNOWN,                       0}
  }

Definition at line 39 of file RenderingPipe.cpp.

TypeString nux::TypeToString[]
Initial value:
  {
    {NODE_TYPE_UNDEFINED,       "ROOT_NODE"},
    {NODE_TYPE_FOLDER,          "Folder"},
    {NODE_TYPE_BOOL,            "Bool"},
    {NODE_TYPE_CHECKBOX,        "Check"},
    {NODE_TYPE_SPINBOX,         "SpinBox"},
    {NODE_TYPE_DOUBLESPINBOX,   "DoubleSpinBox"},
    {NODE_TYPE_COMBOSIMPLE,     "ComboBoxSimple"},
    {NODE_TYPE_COMBOCOMPLEX,    "ComboBoxComplex"},
    {NODE_TYPE_VECTOR3,         "Vector3"},
    {NODE_TYPE_VECTOR4,         "Vector4"},
    {NODE_TYPE_RGB,             "RGB"},
    {NODE_TYPE_RGBA,            "RGBA"},
    {NODE_TYPE_STATICTEXT,      "StaticText"},
    {NODE_TYPE_SPLINE,          "Spline"},
    {NODE_TYPE_EDITTEXT,        "EditText"},
    {NODE_TYPE_RANGE,           "RangeValue"},
    {NODE_TYPE_RANGEINTEGER,    "RangeValueInteger"},
    {NODE_TYPE_INTVALUATOR,     "IntValuator"},
    {NODE_TYPE_DOUBLEVALUATOR,  "DoubleValuator"},
    {NODE_TYPE_VECTORVALUATOR,  "Vector3Valuator"},
    {NODE_TYPE_COLORPREVIEW,    "ColorPreview"},
    {NODE_TYPE_MATRIX4PREVIEW,  "Matrix4Preview"},
    {NODE_TYPE_MATRIX3PREVIEW,  "Matrix3Preview"},

    {0,                 0},
  }

Definition at line 60 of file NodeNetProtocol.cpp.

 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends