CMGDK r49-rc2
名字空间 | 组合类型 | 类型定义 | 枚举 | 函数 | 变量
hgl名字空间参考

__MAKE_HGL__&&!__MAKE_PLUGIN__ 更多...

名字空间

namespace  affect
namespace  apr
namespace  cdb
 

Chinese DataBase用名字空间


namespace  ctrl
namespace  endian
namespace  findpath
namespace  GraphicsEffect
namespace  gui
namespace  info
namespace  io
namespace  loginfo
namespace  loginfo_plugins
namespace  network
 

网络相关处理模块名字空间


namespace  os
 

操作系统相关功能名字空间


namespace  platform
namespace  sql
namespace  texture_filter_def
namespace  texture_type_def
namespace  texture_wrap_def
namespace  util
namespace  wide
 

宽字符串相关处理函数所占名字空间


组合类型

class  Font
 字体数据结构 更多...
class  HGP
 HGP图片管理类 更多...
class  HGPLayer
 HGP图层类 更多...
class  HGPSame
class  HTP
class  HTPBase
class  HTPBaseLayer
class  HTPBuffer
class  HTPResManage
class  HTPLayer
class  HTPMerge
class  HTPPart
class  HTPPartLayer
class  HTPTile
class  TexFont
class  TileAnime
 Tile动画控制 更多...
struct  TileObject
 Tile对象 更多...
class  TileData
 Tile数据管理 更多...
struct  Makeup
class  TileFont
 Tile字体 更多...
class  TileGroup
class  TileLibrary
class  TilePicture
 Tile图片 更多...
class  VS16Bitmap
class  VSLumAlpha
class  VS24Bitmap
class  VSRGB
class  VSBGR
class  VS32Bitmap
class  VSRGBA
class  VSBGRA
class  VS8Bitmap
class  VSLum
class  VSAlpha
class  VSBase
 虚拟屏幕基类 更多...
class  AffectorControl
class  AffectorObject
class  AudioBuffer
 音频数据缓冲区类 更多...
class  AudioManage
class  AudioPlayer
 音频播放器基类 更多...
class  AudioSource
 音频源类 更多...
class  ConeAngle
 锥形角度数据类 更多...
class  AudioListener
 收听者管理类 更多...
struct  ReferenceValue
 参考量 更多...
class  CompressStream
class  DecompressStream
class  ExternalModule
 外部模块调用类 更多...
struct  FileInfo
 文件信息 更多...
struct  VolumeInfo
class  AnimeTexture
class  BlendMode
 混合模式类 更多...
class  CubeMap
class  DisplayList
 显示列表类 更多...
class  DrawArray
 批量绘制处理类 更多...
class  DrawArrayBufferInterface
class  EnvMap
 环境映射 更多...
class  FBO
 帧缓冲对象 更多...
class  MultiTexture
 多重贴图 更多...
struct  OpenGLHardwareSupport
class  PBO
 Pixel Buffer Object. 更多...
class  PointSprite
 点精灵类 更多...
class  GLSL
 GLSL实现类 更多...
class  Shader
class  Texture
 贴图基类 更多...
class  Texture1D
 一维贴图 更多...
class  Texture2D
 2D贴图处理类 更多...
class  TextureAnime
class  HAC
 HAC-3包裹文件支持类 更多...
struct  HacResIndex
class  MemManage
 内存管理 更多...
class  MemoryPool
class  TheoraMovie
class  HTTPDownload
class  _Object
 最终基类 更多...
struct  MethodPtr
class  ConsoleFlowControl
 流程对象控制类 更多...
class  IAOFlowControl
class  ConsoleFlowObject
 流程对象基类 更多...
class  ConsoleObjectControl
 对象控制器 更多...
class  DataObject
class  EnumObject
class  EventObject
 事件对象 更多...
class  FlowControl
 流程对象控制类 更多...
class  FlowObject
 流程对象基类 更多...
class  GUIObject
 GUI对象 更多...
class  MultiFlowControl
 多页控制控件 更多...
class  Object
 对象基类 更多...
class  ObjectControl
 对象控制器 更多...
class  VisualObject
 可视对象基类 更多...
class  BaseApplication
struct  EventFunc
class  Property
class  PropertyObject
class  ConsoleApplication
class  GraphicsApplication
 图形应用序基类 更多...
class  OpenGLApplication
struct  CpuInfo
struct  MemInfo
struct  CMGDKPATH
struct  SystemInfo
 系统信息结构 更多...
class  SystemInitInfo
 系统初始化信息类 更多...
class  Window
class  WinGLWindow
class  WinOpenGLApplication
class  WinWindow
class  PlugIn
 插件 更多...
class  ExternalPlugIn
struct  PlugInFlagData
class  Process
class  ProcMutex
class  SharedMemory
class  PseudoRandom
 假随机数 更多...
class  DevilVM
 《魔鬼》虚拟机类 更多...
struct  vm_method_ptr
class  FileStream
 文件流操作类 更多...
class  MemStream
 内存流操作类 更多...
class  PartStream
 小块流 更多...
class  Stream
 流式数据访问基类 更多...
class  atom_uint
 原子uint32数据 更多...
class  CondVar
class  Loader
 加载器 更多...
class  RWLock
class  Semaphore
 信号 更多...
class  Thread
 线程类 更多...
class  ThreadMutex
 排斥访问类(仅当前进程) 更多...
class  BitArray
 位队列 更多...
class  CircleList
 环形链表类 更多...
class  ClasList
 分类对象模板 更多...
struct  COLOR_DEF
class  Color3f
 RGB三原色类 更多...
class  Color4f
 RGBA四原色类 更多...
class  CryptInt
 加密型int变量类 更多...
class  Time
 时间类 更多...
class  Date
 日期类 更多...
struct  FudItem
class  FinUseData
 缓冲区管理模板(以最终使用时间为基准) 更多...
class  FixedList
 定长列表 更多...
class  FixedObjectList
 定长对象列表 更多...
class  MTFixedList
 <多线程定长数据列表 更多...
class  MTFixedObjectList
 <多线程定长对象列表 更多...
struct  IndexFlagData
class  _IndexData
class  IndexData
class  _IndexObject
class  CusIndexObject
class  IndexObject
class  int128
 int128位整型数 更多...
class  Limit
 限制型数据模板类 更多...
class  List
 列表处理类 更多...
class  CusObjectList
 对象列表处理类 更多...
class  ObjectList
class  ObjectBuffer
class  ObjectBufferFromHAC
class  OnlyList
class  Pool
 数据池 更多...
class  MultiThreadPool
 多线程数据池 更多...
class  ObjectPool
 对象池 更多...
class  MTObjectPool
 多线程对象池 更多...
class  MemBlockPool
 内存块池 更多...
class  MTMemBlockPool
 多线程内存块池 更多...
class  IndexObjectPool
class  MTIndexObjectPool
class  ProbSelect
 机率选择器 更多...
class  Queue
 队列顺序数据访问类 更多...
class  QueueObject
 堆栈对象 更多...
class  RandSelect
 随机选择 更多...
class  RectScope2
 矩形范围类 更多...
struct  RefFlagData
class  ResManage
class  ResManageByName
class  ResManageHAC
class  RingBuffer
 多线程环形数据流 更多...
class  Set
class  ShadeNumber
 渐变数模板 更多...
struct  RefCount
struct  SmartData
struct  SmartArrayData
class  _Smart
class  SharedPtr
 共享指针数据类 更多...
class  SharedArray
 共享阵列数据类 更多...
class  WeakPtr
class  WeakArray
class  Stack
 堆栈顺序数据访问类 更多...
class  StackObject
 堆栈对象 更多...
class  StringList
 字符串列表处理类 更多...
class  StringProperty
class  Table
class  TDFNode
 HyzTDF节点类 更多...
class  TreeNode
 树型数据节点类 更多...
class  Vertex2
 XY 2D顶点坐标类模板 更多...
class  WideString
 宽字符串处理类 更多...
class  PropertyString
struct  PrivateString
class  Comparator
class  FindPath
 寻路模块基类 更多...
class  KeyMapping
 <按键映射类 更多...
class  PList
 属性列表 更多...
class  ShortCut
class  SortBase
class  HeapSort
class  TaskManager
 任务管理器 更多...
class  Timer
 计时器类 更多...
class  VCLBitmap
struct  CheckInterface
struct  Hac3File
class  HAC3
struct  FileMapping
struct  FolderMapping
class  HacMapping
struct  HacFolder
class  HacTemplate
struct  LogInterface
class  LogPlugIn
 日志插件 更多...
class  CondVarAPR
class  CondVarNT6
class  RWLockNT6
struct  CompressPlugInInterface
struct  CharBitmap
class  FontUnit
class  WinFont
class  HGPLayerNPOT
class  HGPLayerPOT
class  HGPLoader
struct  BitmapLA
struct  BitmapRGBA
struct  ImageLayer
class  Image
struct  image_layer
class  HGPSameLayer
class  TileLibraryManage
class  FullTileLibrary
class  TileBuffer
class  FUDTileLibrary
struct  ImagePlugInInterface
struct  TARGB32
struct  TPicRegion
struct  bmdata
class  DrawArrayBuffer
class  Texture2DLoader
struct  AudioPlugInInterface
union  DevilSystemFuncParam
struct  DevilFuncMap
struct  DevilPropertyMap
class  DevilCommand
class  DevilFuncCall
class  DevilValueInterface
class  DevilValue
class  DevilCompInterface
class  DevilValueProperty
class  DevilValueFuncMap
class  DevilScriptValue
class  DevilSystemFuncCall
class  DevilSystemFuncCallFixed
class  DevilScriptFuncCall
class  DevilGoto
class  DevilCompGoto
class  DevilReturn
class  DevilSystemValueEqu
struct  ScriptFuncRunState
class  DevilEngine
class  DevilEnum
 枚举定义基类,用于在DevilEngine中定义 更多...
class  DevilEnumTypedef
 枚举数据类型定义基类 更多...
class  DevilEnumSigned
 有符号整数型枚举定义基类 更多...
class  DevilEnumUnsigned
 无符号整数型枚举定义基类 更多...
class  DevilEnumFloat
 浮点数枚举定义基类 更多...
class  DevilEnumString
 字符串枚举定义基类 更多...
class  DevilFunc
class  DevilParse
class  DevilVariable
struct  DirectShowMovieInterface
struct  th_img_plane
struct  TheoraMovieInterface
class  MovieDecode
struct  JoystickInterface

类型定义

typedef ObjectBuffer< HGPHGPBuffer
 HGP图片缓冲管理器
typedef ObjectBufferFromHAC< HGPHGPBufferHAC
 HGP图片缓冲管理器(从HAC名中取得文件)
typedef ResManageByName< HGPHGPResManage
 HGP图片资源管理器
typedef ResManageHAC< HGPHGPResManageHAC
 HGP图片资源管理器(从HAC名中取得文件)
typedef ObjectBuffer< HGPSameHGPSameBuffer
 HGPSame图片缓冲管理器
typedef ObjectBufferFromHAC
< HGPSame
HGPSameBufferHAC
 HGPSame图片缓冲管理器(从HAC名中取得文件)
typedef AudioFileType AFT
typedef ObjectBuffer< AudioBufferAudioBufferBuffer
 AudioBuffer缓冲管理器
typedef ObjectBufferFromHAC
< AudioBuffer
AudioBufferHAC
 AudioBuffer缓冲管理器(从HAC名中取得文件)
typedef unsigned int CCP
typedef CompressAlgorithm CA
 压缩算法枚举定义
typedef PointDataCompoment PDC
 点数据成份
typedef ObjectBuffer< Texture2DTexBuffer
 Texture2D图片缓冲管理器
typedef ObjectBufferFromHAC
< Texture2D
TexBufferHAC
 Texture2D图片缓冲管理器(从HAC包中取得文件)
typedef ResManageByName
< Texture2D
TexResManage
 Texture2D图片资源管理器
typedef ResManageHAC< Texture2DTexResManageHAC
 Texture2D图片资源管理器(从HAC名中取得文件)
typedef void(_Object::* ObjectMemberFunc )()
typedef unsigned char uchar
 无符号字符型
typedef unsigned int uint
 无符号整型
typedef signed __int8 int8
 有符号 8位整型
typedef unsigned __int8 uint8
 无符号 8位整型
typedef signed __int16 int16
 有符号16位整型
typedef unsigned __int16 uint16
 无符号16位整型
typedef signed __int32 int32
 有符号32位整型
typedef unsigned __int32 uint32
 无符号32位整型
typedef signed __int64 int64
 有符号64位整型
typedef unsigned __int64 uint64
 无符号64位整型
typedef volatile uint avuint
typedef const avuint cavuint
typedef RectScope2< double > RectScope2d
typedef RectScope2< float > RectScope2f
typedef RectScope2< intRectScope2i
typedef Vertex2< intVertex2i
typedef Vertex2< uintVertex2ui
typedef Vertex2< float > Vertex2f
typedef Vertex2< double > Vertex2d
typedef Vertex2< int8Vertex2b
typedef Vertex2< uint8Vertex2ub
typedef Vertex2< int16Vertex2s
typedef Vertex2< uint16Vertex2us
typedef FindPathAlgorithml FPA
typedef cml::vector2i Vector2i
typedef cml::vector3i Vector3i
typedef cml::vector4i Vector4i
typedef cml::vector2f Vector2f
typedef cml::vector3f Vector3f
typedef cml::vector4f Vector4f
typedef cml::matrix33f_c Matrix3f
typedef cml::matrix44f_c Matrix4f
typedef void(* PIMClearFunc )()
typedef unsigned char TUInt8
typedef void MovieInterface
typedef void MOVIE
typedef void int

枚举

enum  VAlign {
  alNone, alTop, alBottom, alLeft,
  alRight, alClient, alLeftTop, alRightTop,
  alLeftBottom, alRightBottom, alTopCenter, alLeftCenter,
  alRightCenter, alBottomCenter, alCenter, alEnd
}
enum  TextAlignment {
  taNone = 0, taLeft, taCenter, taRight,
  taVRight, taEnd
}
 文本排列方式 更多...
enum  AudioFileType { aftNone = 0, aftWAV, aftOGG, aftEnd }
enum  CharacterCodePage {
  ccpNone = 0, ccpGBK = 936, ccpBig5 = 950, ccpGB2312 = 20936,
  ccpHZGB2312 = 52936, ccpGB18030 = 54936, ccpShiftJIS = 932, ccpJISX = 50222,
  ccpUTF7 = 65000, ccpUTF8 = 65001, ccpEnd
}
 代码页枚举 更多...
enum  DrawArrayDataState { dasTemp = 0, dasStatic = GL_STATIC_DRAW, dasDynamic = GL_DYNAMIC_DRAW, dasStream = GL_STREAM_DRAW }
enum  DrawArrayDataAccess { daaWrite = GL_WRITE_ONLY, daaRead = GL_READ_ONLY, daaReadWrite = GL_READ_WRITE }
enum  PointDataCompoment {
  pdcColor3f = 1<<0, pdcColor4f = 1<<1, pdcVertex2f = 1<<2, pdcVertex3f = 1<<3,
  pdcVertex2i = 1<<6, pdcVertex3i = 1<<7, pdcTexCoord1f = 1<<8, pdcTexCoord2f = 1<<9,
  pdcTexCoord3f = 1<<10, pdcTexCoord4f = 1<<11, pdcTexCoord1i = 1<<16, pdcTexCoord2i = 1<<17,
  pdcTexCoord3i = 1<<18, pdcTexCoord4i = 1<<19, pdcNormal3f = 1<<20, pdc2Color3f = 1<<22,
  pdcFogCoord1f = 1<<23, pdcIndex1i = 1<<25
}
enum  OpenGLChipVendor {
  ocvNone = 0, ocvATI, ocvNVidia, ocvIntel,
  ocv3DLabs, ocvPowerVR, ocvSiS, ocvVIA,
  ocvMatrox, ocvXGI, ocvMesa, ocvQuake2,
  ocvDirect3D, ocvVoodoo, ocvMicrosoft, ocvSciTech,
  ocvEnd
}
 显卡OpenGL芯片生产商枚举 更多...
enum  GraphicsClientState {
  gcsNone = 0, gcsVertex, gcsTextureCoord, gcsColor,
  gcsNormal, gcsSecondaryColor, gcsFogCoord, gcsIndex,
  gcsEnd
}
enum  HacStatus {
  hsNone = 0, hsNotFind, hsOpenError, hsRead,
  hsReadError, hsEnd
}
enum  InputState {
  isNone = 0, isMove = 0x00000001, isLeft = 0x00000010, isLeftDown = 0x00000020,
  isLeftUp = 0x00000040, isLeftDoubleClick = 0x00000080, isMid = 0x00000100, isMidDown = 0x00000200,
  isMidUp = 0x00000400, isMidDoubleClick = 0x00000800, isRight = 0x00001000, isRightDown = 0x00002000,
  isRightUp = 0x00004000, isRightDoubleClick = 0x00008000, isShift = 0x10000000, isCtrl = 0x20000000
}
enum  KeyButton {
  kb_NONE = 0, kbEsc, kbF1, kbF2,
  kbF3, kbF4, kbF5, kbF6,
  kbF7, kbF8, kbF9, kbF10,
  kbF11, kbF12, kbGrave, kb0,
  kb1, kb2, kb3, kb4,
  kb5, kb6, kb7, kb8,
  kb9, kbMinus, kbEquals, kbBackSlash,
  kbBackSpace, kbTab, kbQ, kbW,
  kbE, kbR, kbT, kbY,
  kbU, kbI, kbO, kbP,
  kbLeftBracket, kbRightBracket, kbCapsLock, kbA,
  kbS, kbD, kbF, kbG,
  kbH, kbJ, kbK, kbL,
  kbSemicolon, kbApostrophe, kbEnter, kbLeftShift,
  kbZ, kbX, kbC, kbV,
  kbB, kbN, kbM, kbComma,
  kbPeriod, kbSlash, kbRightShift, kbLeftCtrl,
  kbLeftOS, kbLeftAlt, kbSpace, kbRightAlt,
  kbRightOS, kbRightCtrl, kbPrintScreen, kbScrollLock,
  kbPause, kbInsert, kbDelete, kbHome,
  kbEnd, kbPageUp, kbPageDown, kbUp,
  kbDown, kbLeft, kbRight, kbNumLock,
  kbNumDivide, kbNumMultiply, kbNumSubtract, kbNum7,
  kbNum8, kbNum9, kbNum4, kbNum5,
  kbNum6, kbNumAdd, kbNum1, kbNum2,
  kbNum3, kbNum0, kbNumDecimal, kbNumEnter,
  kb_END
}
enum  JoyButton {
  jbNone = 0, jbUp, jbDown, jbLeft,
  jbRight, jb0, jb1, jb2,
  jb3, jb4, jb5, jb6,
  jb7, jb8, jb9, jb10,
  jb11, jb12, jb13, jb14,
  jb15, jb16, jb17, jb18,
  jb19, jb20, jb21, jb22,
  jb23, jb24, jb25, jb26,
  jb27, jb28, jb29, jb30,
  jb31, jbEnd, jbTriangle = jb0, jbCircle = jb1,
  jbFork = jb2, jbRectangle = jb3, jbL1 = jb6, jbL2 = jb4,
  jbR1 = jb7, jbR2 = jb5, jbSelect = jb8, jbStart = jb9
}
enum  FlowObjectState {
  fosNotInit = 0, fosOK, fosExitNotClear, fosExitToBack,
  fosReturn, fosExit, fosExitFlow, fosExitGame
}
enum  AppRunMode {
  armNone = 0, armASync, armSync, armFast,
  armExternal, armServer, armEnd
}
enum  DevilVMState { dvsRun, dvsPause, dvsStop }
enum  FileOpenMode {
  fomCreate = 0x01, fomOpenRead = 0x02, fomOpenWrite = 0x04, fomOpenReadWrite = fomOpenRead|fomOpenWrite,
  fomRead = fomOpenRead, fomWrite = fomOpenWrite, fomReadWrite = fomOpenReadWrite
}
 文件访问模式枚举 更多...
enum  SeekOrigin { soBegin, soCurrent, soEnd }
 资源偏移方向枚举 更多...
enum  COLOR_ENUM {
  ceNone, ceAliceBlue, ceAntiqueWhite, ceAqua,
  ceAquaMarine, ceAzure, ceBeige, ceBisque,
  ceBlack, ceBlanchedAlmond, ceBlue, ceBlueViolet,
  ceBrown, ceBurlyWood, ceCadetBlue, ceChartreuse,
  ceChocolate, ceCoral, ceCornflowerBlue, ceCornsilk,
  ceCrimson, ceCyan, ceDarkBlue, ceDarkCyan,
  ceDarkGoldenrod, ceDarkGray, ceDarkGreen, ceDarkGrey,
  ceDarkKhaki, ceDarkMagenta, ceDarkOliveGreen, ceDarkOrange,
  ceDarkOrchid, ceDarkRed, ceDarkSalmon, ceDarkSeaGreen,
  ceDarkSlateBlue, ceDarkSlateGray, ceDarkSlateGrey, ceDarkTurquoise,
  ceDarkViolet, ceDeepPink, ceDeepSkyBlue, ceDimGray,
  ceDimGrey, ceDodgerBlue, ceFireBrick, ceFloralWhite,
  ceForestGreen, ceFuchsia, ceGainsboro, ceGhostWhite,
  ceGold, ceGoldenrod, ceGray, ceGreen,
  ceGreenYellow, ceGrey, ceHoneydew, ceHotPink,
  ceIndianRed, ceIndigo, ceIvory, ceKhaki,
  ceLavender, ceLavenderBlush, ceLawnGreen, ceLemonChiffon,
  ceLightBlue, ceLightCoral, ceLightCyan, ceLightGoldenrodYellow,
  ceLightGray, ceLightGreen, ceLightGrey, ceLightPink,
  ceLightSalmon, ceLightSeaGreen, ceLightSkyBlue, ceLightSlateGray,
  ceLightSlateGrey, ceLightSteelBlue, ceLightYellow, ceLime,
  ceLimeGreen, ceLinen, ceMagenta, ceMaroon,
  ceMediumAquamarine, ceMediumBlue, ceMediumOrchid, ceMediumPurple,
  ceMediumSeaGreen, ceMediumSlateBlue, ceMediumSpringGreen, ceMediumTurquoise,
  ceMediumVioletRed, ceMidNightBlue, ceMintCream, ceMistyRose,
  ceMoccasin, ceNavajoWhite, ceNavy, ceOldLace,
  ceOlive, ceOlivedrab, ceOrange, ceOrangeRed,
  ceOrchid, cePaleGoldenrod, cePaleGreen, cePaleTurquoise,
  cePaleVioletRed, cePapayawhip, cePeachpuff, cePeru,
  cePink, cePlum, cePowderBlue, cePurple,
  ceRed, ceRosyBrown, ceRoyalBlue, ceSaddleBrown,
  ceSalmon, ceSandyBrown, ceSeaGreen, ceSeaShell,
  ceSienna, ceSilver, ceSkyBlue, ceSlateBlue,
  ceSlateGray, ceSlateGrey, ceSnow, ceSpringGreen,
  ceSteelBlue, ceTan, ceTeal, ceThistle,
  ceTomato, ceTurquoise, ceViolet, ceWheat,
  ceWhite, ceWhiteSmoke, ceYellow, ceYellowGreen,
  ceEnd
}
enum  FindPathAlgorithml {
  fpaNone = 0, fpaAStar, fpaAStar8, fpaLine,
  fpaEnd
}

函数

HGPCopyScreenToHGP (int, int, int, int, uint=GL_RGB8)
 根据当前屏幕图像生成一个HGP
bool SaveBitmapToHGP (const wchar_t *, int, int, ColorType, void *, const wchar_t *ca=L"RLE", float=1)
 保存一个位图数据成HGP文件
bool SaveScreenToHGP (const wchar_t *, int, int, int, int, const wchar_t *ca=L"RLE", float=1)
 保存当前屏幕图像成HGP文件
bool SaveScreenToHGP (const wchar_t *, int, int, int, int, int, int, const wchar_t *ca=L"RLE", float=1)
 保存当前屏幕图像成HGP文件
void SetSameColor (int)
void SetClearSimplePixel (bool)
 设置色差容差
bool ConvertMultiLayerImageToHGP (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float=1)
 转换多层图片到HGP
bool ConvertMonoLayerImageToHGP (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float=1)
 转换单层图片到HGP
bool ConvertSameLayerImageToHGP (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float=1)
 转换多层图片到HGP(并自动裁剪掉每一层与底层相同内容的部分)
bool ConvertSameLayerImageToHGPTest (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float=1)
 转换多层图片到HGP(并自动裁剪掉每一层与底层相同内容的部分)
bool ConvertPSDToMapHGP (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float=1)
 转换PSD到地图用HGP
void * LoadHGP (TDFNode *, uint &, int &, int &, int8 &)
void * LoadHGP (Stream *, uint &, int &, int &, int8 &)
void * LoadHGP (const wchar_t *, uint &, int &, int &, int8 &)
void * LoadHGP (HAC *, const wchar_t *, uint &, int &, int &, int8 &)
LoaderASyncLoadHGP (HGP **, HAC *, const wchar_t *)
 异步加载HGP图片
LoaderASyncLoadHGPSame (HGP **, HAC *, const wchar_t *)
 异步加载HGPSame图片
TileFontCreateTileFont (Font &, Font &, int=-1)
 创建一个字体,使用系统字体
__inline TileFontCreateTileFont (const wchar_t *chs_fontname, const wchar_t *eng_fontname, int width, int height, bool bold, bool italic, int count)
__inline TileFontCreateTileFont (const wchar_t *fontname, int width, int height, bool bold=false, bool italic=false, int num=-1)
__inline TileFontCreateTileFont (const wchar_t *chs_fontname, const wchar_t *eng_fontname, int width, int height, int num=-1)
void FillBlock (uchar *dst, uchar value, int width, int height, int color, int stride)
void FillBlock (uchar *dst, const uchar *src, int width, int height, int color, int stride)
VSBaseCreateVS (ColorType)
 根据色彩类型创建一个虚拟屏幕
VSBaseCreateVS (int, int, ColorType)
 根据尺寸和色彩类型创建一个虚拟屏幕
VSBaseCreateVSFromFile (const wchar_t *, bool=true, bool=true)
 从贴图文件(*.TEX)加载一个虚拟屏幕
VSBaseCreateVSFromFile (HAC *, const wchar_t *)
 从贴图文件(*.TEX)加载一个虚拟屏幕
VSBaseCreateVSFromPixelBuffer (uint8 *, int, int, ColorType)
 关联象素缓冲区为虚拟屏幕
 enum_uint (CompressAlgorithm)
 压缩算法
const WideString CAToName (CA)
 压缩法算枚举到名称转换
CA NameToCA (const WideString &)
 名称到压缩算法枚举转换
uint32 Compress (const WideString &, void *, uint32, void *, uint32, float=1)
 压缩数据
uint32 Decompress (const WideString &, void *, uint32, void *, uint32)
 解压缩数据
uint32 ImageCompress (const WideString &, void *, uint32, void *, int, int, int, float=1)
 压缩图像数据
uint32 ImageDecompress (const WideString &, void *, void *, uint32, int, int, int)
 解压缩图像数据
uint32 __inline Compress (CA ca, void *data, uint32 size, void *compressdata, uint32 out_max, float level=1)
uint32 __inline Decompress (CA ca, void *compressdata, uint32 size, void *out_data, uint32 out_max)
uint32 __inline ImageCompress (CA ca, void *buffer, uint32 buffer_size, void *data, int width, int height, int channels, int level)
uint32 __inline ImageDecompress (CA ca, void *data, void *buffer, uint32 size, int width, int height, int channels)
bool InitCore (SystemInfo &si, bool create_log)
 初始化核心
void CloseCore ()
 关闭核心
void CreateTempFileName (const wchar_t *)
 创建临时文件名称
wchar_t * MergeFilename (const wchar_t *, const wchar_t *)
 组合路径名与文件名
bool MergeFilename (wchar_t *, int, const wchar_t *, const wchar_t *)
 组合路径名与文件名
bool FileCopy (const wchar_t *, const wchar_t *)
 文件复制
bool FileDelete (const wchar_t *)
 文件删除
bool FileMove (const wchar_t *, const wchar_t *)
 文件移动
bool FileRename (const wchar_t *, const wchar_t *)
 文件改名
bool FileConfirm (const wchar_t *)
 文件确认是否存在
bool FileComp (const wchar_t *, const wchar_t *)
 文件比较
bool FileCheckOpen (const wchar_t *)
 尝试打开文件
bool FileCheckOpen (const wchar_t *, const wchar_t *)
 尝试打开文件
int FileCanRead (const wchar_t *)
 检测文件是否可读
int FileCanWrite (const wchar_t *)
 检测文件是否可写
int64 LoadFileToMemory (const wchar_t *, void **)
 加载一个文件到内存
int64 SaveMemoryToFile (const wchar_t *, void *, int64)
 保存一块内存成文件
void * LoadFileToMemory (const wchar_t *, unsigned int, unsigned int, void *buf=0)
 加载一个文件的一部分到内存
bool SaveMemoryToFile (const wchar_t *, unsigned int, unsigned int, void *)
 保存一块内存到一个文件
int64 LoadTxtToMemory (Stream *, const int64, wchar_t **, int code_page=0)
 加载文本文件到内存
int64 LoadTxtToMemory (const wchar_t *, wchar_t **, int code_page=0)
 加载文本文件到内存
bool IsDirectory (const wchar_t *)
 判断这个名称是否是目录
bool MakePath (const wchar_t *)
 创建一个路径
bool DeletePath (const wchar_t *)
 删除一个路径
void DeleteTree (const wchar_t *)
 删除一个路径(包含所有文件)
wchar_t * GetCurrentPath ()
 取得当前路径,结果请自行delete[]
bool GetFileInfo (const wchar_t *filename, struct FileInfo &)
 取得文件信息
int EnumFile (const wchar_t *folder_name, const wchar_t *find_name, void *data, bool proc_folder, bool proc_file, bool sub_folder, void(__cdecl *func)(void *, hgl::FileInfo &))
int EnumFile (const wchar_t *folder_name, const wchar_t *find_name, void *data, void(__cdecl *func)(void *, hgl::FileInfo &))
int EnumVolume (void *data, void(__cdecl *func)(void *, hgl::VolumeInfo &), bool check_removable=false, bool check_remote=false, bool check_cd=false)
 enum_uint (BlendModeEnum)
 混合模式枚举
void CheckOpenGLExt ()
 检测和处理OpenGL扩展
int GetScreenWidth ()
 取得屏幕宽度
int GetScreenHeight ()
 取得屏幕高度
int GetCanvasWidth ()
 取游戏画布宽度
int GetCanvasHeight ()
 取游戏画布高度
void SetScreen (int, int)
 设置屏幕大小
void SetCanvas (int, int)
 设置画布大小
void To2DMode ()
void To2DMode (float, float)
void To2DMode (float, float, float, float, float, float)
void To3DMode (float, float, float, float)
void __inline To3DMode (float fov, float n, float f)
void __inline To3DMode (float fov)
void To3DOrtho (float=1, float=1)
void Set3DOrigin (GLdouble, GLdouble)
void FastUnProject (GLdouble, GLdouble, GLdouble *, GLdouble *)
bool SaveScreenToBMP (const wchar_t *fn=0, int=-1, int=-1)
bool SaveScreenToTGA (const wchar_t *fn=0, int=-1, int=-1)
int PowerTo2 (int)
int PowerTo2 (int, int)
int SplitPowerTo2 (int, int *, int=4)
void FlipBitmap (uint8 *, uint8 *, int, int, int)
void GetPixel (int, int, uint8 *)
void ScaleImage (void *, int, int, void *, int, int, ColorType)
void ToHalf (uchar *dst, const uchar *src, int width, int height, int color)
 int (__stdcall *hglSwapBuffers)(void *)
void ClearScreen ()
void RestartOpenGL ()
 重置渲染控制器
void SetMatrix (GLenum)
 设置矩阵堆栈
void PushMatrix (GLenum)
 压入矩阵堆栈
void PopMatrix (GLenum)
 弹出指定矩阵
void ClearMatrix (GLenum)
 清除矩阵
void LoadMatrix (GLenum, float *)
 加载矩阵
void ClearMatrixStack ()
 清除矩阵堆栈
uint GetMaxMatrixBufferSize ()
 最得取大矩阵缓冲长度
uint SaveMatrixStack (void *)
bool LoadMatrixStack (void *, uint)
void __inline glColor (float r, float g, float b)
 根据RGB设置颜色
void __inline glColor (float r, float g, float b, float a)
 根据RGBA设置颜色
void __inline glColor (const Color3f &v)
 根据RGB设置颜色
void __inline glColor (const Color3f &v, float a)
 根据RGBA设置颜色
void __inline glColor (const Color4f &v)
 根据RGBA设置颜色
void __inline glColor (const Color4f &v, float a)
 根据RGBA设置颜色(alpha再乘上一个系数)
void __inline glColor256 (int r, int g, int b)
 根据RGB设置颜色(颜色范围值为0-255)
void __inline glColor256 (int r, int g, int b, int a)
 根据RGBA设置颜色(颜色范围值为0-255)
void __inline glColor (float lum)
 根据亮度设置颜色
void __inline glColor (float lum, float a)
 根据亮度设置颜色
void __inline glColor256 (int lum)
 根据亮度设置颜色
void __inline glColor256 (int lum, int a)
 根据亮度设置颜色
void OpenLineSmooth ()
 开启线条平滑
void CloseLineSmooth ()
 关闭线条平滑
void SetLineWidth (GLfloat)
 设置线宽
void SetLineStipple (GLuint, GLushort)
 设置点划线
void CloseLineStipple ()
 关闭点划线
void OpenColorMaterial (GLenum, GLenum)
void CloseColorMaterial ()
void SetPixelStore (GLenum, int)
void DeleteTexture (Texture *)
 删除一张贴图
void ChangeActiveTexture (int)
 更改到当前贴图
void ChangeTexture (Texture *)
 更改到当前贴图设置
void ChangeTexture (int, Texture *)
 更改到当前贴图设置
void OpenTexture (TextureType)
 开启贴图渲染
void CloseTexture ()
 关闭贴图渲染
void CloseTexture (int)
 关闭贴图渲染
void OpenTextureGen (GLenum, GLenum, GLint)
void CloseTextureGen (GLenum)
void CloseTextureGen ()
void ChangeBlend (BlendMode &)
 更改到当前混合设置
void OpenBlend (BlendModeEnum)
 开启混合效果
void OpenBlend (GLuint, GLuint)
 开启混合效果
void CloseBlend ()
 关闭混合效果
void OpenScissor (const int, const int, const int, const int)
 更改当前裁剪
void OpenScissor (const int *)
 更改当前裁剪
void CloseScissor ()
 关闭裁剪
void OpenAlphaTest (const GLenum, const float)
void CloseAlphaTest ()
void OpenDepthTest ()
 开启深度测试
void CloseDepthTest ()
 关闭深度测试
void OpenDepthMask ()
void CloseDepthMask ()
void OpenCullFace (GLuint)
 开启面裁剪
void CloseCullFace ()
 关闭面裁剪
bool ChangeArrayBuffer (GLuint)
 更改当前使用的缓冲区,返回true表示改换,返回false没有换(和原先的一样)
void DeleteArrayBuffer (GLuint)
 删除一个缓冲区
void CloseArrayBuffer ()
 关闭缓冲区
void ChangeShader (GLuint)
 更改当前使用的shader
void DeleteShader (GLuint)
 删除一个shader
void CloseShader ()
 关闭shader渲染
void OpenClientState (GraphicsClientState)
 开启OpenGL客户端状态
void CloseClientState (GraphicsClientState)
 关闭OpenGL客户端状态
void __inline DrawZeroPoint (const float size=0.5f)
void glRotate3fv (const float *vf)
void glRotate3f (const float x, const float y, const float z)
void glTranslate3fv (const float *vf)
void glTranslate3f (const float x, const float y, const float z)
void glScale3fv (const float *vf)
void glDrawArray (const GLenum mode, const void *vertex, const void *tex_coord, const void *color, const void *normal, const uint dc, const uint count)
void __inline glDrawArray (const GLenum mode, const void *vertex, const void *tex_coord, const uint dc, const uint count)
void __inline DrawLine (const float x1, const float y1, const float x2, const float y2)
void __inline DrawRectangle (const float left, const float top, const float width, const float height)
void __inline DrawBar (const float left, const float top, const float width, const float height)
void __inline DrawBar (const int left, const int top, const int width, const int height)
void __inline glRect (const RectScope2f &rs)
void __inline glRectFullScreen ()
void __inline glRectFullScreen (const Color3f &color)
bool ConvertMonoLayerImageToTex1D (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float rate=1)
 转换一个单层图片到Tex1D
LoaderASyncLoadTexture2D (Texture2D **, HAC *, const wchar_t *, uint=0, uint=1)
 异步加载一个贴图
void * LoadTexture (TDFNode *, uint &, int &, int &, ColorType &)
 从TDF加载一个贴图文件,并取得原始数据
void * LoadTexture (Stream *, uint &, int &, int &, ColorType &)
 从流加载一个贴图文件,并取得原始数据
void * LoadTexture (const wchar_t *, uint &, int &, int &, ColorType &)
 加载一个贴图文件,并取得原始数据
void * LoadTexture (HAC *, const wchar_t *, uint &, int &, int &, ColorType &)
 加载一个贴图文件,并取得原始数据
Texture2DCopyScreenToTexture2D (int, int, int, int, uint=0)
 根据当前屏幕内容生成一个2D贴图
bool SaveBitmapToTEX (const wchar_t *, int, int, ColorType, void *, const wchar_t *ca=L"RLE", float rate=1)
 保存一个位图数据成TEX文件
bool SaveScreenToTEX (const wchar_t *, int, int, int, int, const wchar_t *ca=L"RLE", float rate=1)
 保存当前屏幕图像成TEX文件
bool SaveScreenToTEX (const wchar_t *, int, int, int, int, int, int, const wchar_t *ca=L"RLE", float rate=1)
 保存当前屏幕图像成TEX文件
bool LoadCubeTexture (TDFNode *, Texture2D *[6])
 从TDF节点中加载一个Cube贴图
bool LoadCubeTexture (Stream *, Texture2D *[6])
 从流中加载一个Cube贴图
bool LoadCubeTexture (const wchar_t *, Texture2D *[6])
 加载一个Cube贴图文件
bool LoadCubeTexture (HAC *, const wchar_t *, Texture2D *[6])
 加载一个Cube贴图文件
bool ConvertImg2Tex (const wchar_t *, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float rate=1)
 转换一个图片到.TEX贴图文件
bool ConvertImg2CubeTex (const wchar_t **, const wchar_t *, ColorType=ctNone, const wchar_t *ca=L"RLE", float rate=1)
 转换一组图片到一个Cube贴图,供CubeMap或SkyBox使用
bool ConvertImg2Anime (int, const wchar_t **, const wchar_t *, ColorType ctNone, const wchar_t *ca=L"RLE", float rate=1)
 转换一组图片到一个Anime动画文件
HACOpenHAC (const wchar_t *name=0)
 打开一个.HAC文件,或是根据路径创建一个虚拟的HAC环境
bool GetKeyState (KeyButton)
bool GetJotState (JoyButton)
MemManageCreateCMemManage ()
 创建一个使用C内存函数的内存管理器
uint CountAdler32 (uint, const uchar *, uint)
void CountSHA1 (uint8 *, uint32, uint8[20])
void AesEncrypt (uint8[16], uint8 *, int)
void AesDecrypt (uint8[16], uint8 *, int)
void RC4Encrypt (uint8 *, int, uint8 *, int)
void OverflowEncrypt (void *, void *, int, void *, int)
void OverflowDecrypt (void *, void *, int, void *, int)
uint32 FastRand ()
 快速产生一个随机数
uint32 __inline FastRand (uint32 max_value)
int __inline FastRand (int v1, int v2, int p=1)
double __inline FastRand (double v1, double v2, double p)
uint64 GetTime ()
 取得当前时间(单位:1/1000秒)
uint64 GetMicroTime ()
 取得当前时间(单位:1/1000000秒)
double GetDoubleTime ()
 取得当前时间(单位:秒)
void WaitTime (double)
 等待一定时间(单位:秒)
void SetExpendString (const WideString &, const WideString &)
 设置特殊扩展字符串
void ClearExpendString (const WideString &)
 清除特殊扩展字符串
bool GetExpendString (const WideString &, WideString &)
 取得特殊扩展字符串
bool ConvertExpendString (const WideString &, WideString &)
 转换特殊扩展字符串
bool GetDesktopDisplayMode (int &, int &, int &, int &)
 取得当前桌面显示模式
void InitPlugIn ()
 初始化插件管理
void ClearAllPlugIn ()
 清除所有插件
void SetPlugIn (PlugIn *, PlugInType)
 设置一个插件
PlugIn *__cdecl LoadPlugIn (const wchar_t *, PlugInType=pitNormal)
 加载一个插件
void __cdecl UnloadPlugIn (PlugIn *)
 释放一个插件
void *__cdecl LoadInterface (const wchar_t *, int)
 加载一个插件,并取得指定接口
template<typename T >
T * CheckPlugIn (_IndexObject< WideString, T, PlugInFlagData< T * > > &PIM, const WideString &front, uint ver, const WideString &name)
void RegistryPIMClear (void(*)())
DevilVMCreateDevilEngine ()
template<typename T >
int strlen (const T *str)
template<typename T >
void strcpy (T *dst, const T *src)
template<typename T >
void strcpy (T *dst, int count, const T *src)
template<typename T >
void strcpy (T *dst, const T *src, int count)
template<typename T >
T * strstr (T *str1, const T *str2)
template<typename T >
void strcat (T *dst, const T src)
template<typename T >
void strcat (T *dst, const T *src)
template<typename T >
void strcat (T *dst, const T *src, int count)
template<typename T >
T * strchr (const T *str, const T ch)
template<typename T >
T * strchr (const T *str, const T ch, int n)
template<typename T >
T * strrchr (const T *str, const T ch)
template<typename T >
int strcmp (const T *src, const T *dst)
template<typename T >
int strcmp (const T *src, const T *dst, int count)
template<typename T >
int stricmp (const T *src, const T *dst)
template<typename T >
int stricmp (const T *src, const T *dst, const int count)
template<typename T >
void ReplaceExtName (const T *old_filename, T *new_filename, const T *new_extname)
template<typename T >
void ReplaceExtName (T *filename, const T *new_extname)
template<typename T >
T * CreateCopy (const T *str, int size=-1)
template<typename T >
void ReplaceChar (T *string, const T sch, const T tch)
template<typename T >
void UpperString (T *SourceString)
template<typename T >
void LowerString (T *SourceString)
template<typename T >
void UpperString (const T *SourceString, T *TargetString)
template<typename T >
void LowerString (const T *SourceString, T *TargetString)
template<typename T >
int StatChar (const T *str, const T ch)
template<typename T >
int StatLine (const T *str)
template<typename T >
bool isdigit (const T ch)
int AnsiToWide (CCP ccp, wchar_t *ws, int ws_size, const char *as, int as_size=-1)
int AnsiToWide (wchar_t *ws, int ws_size, const char *as, int as_size=-1)
int AnsiToWide (CCP ccp, wchar_t **ws, const char *as, int as_size=-1)
int AnsiToWide (wchar_t **ws, const char *as, int as_size=-1)
int WideToAnsi (CCP ccp, char *as, int as_size, const wchar_t *ws, int ws_size=-1)
int WideToAnsi (char *as, int as_size, const wchar_t *ws, int ws_size=-1)
int WideToAnsi (CCP ccp, char **as, const wchar_t *ws, int ws_size=-1)
int WideToAnsi (char **as, const wchar_t *ws, int ws_size=-1)
__inline FileStreamOpenFileStream (const wchar_t *filename, FileOpenMode mode=fomOpenRead)
CondVarCreateCondVar ()
 创建条件变量
RWLockCreateRWLock ()
 创建读写锁
void WaitThread (Thread **, int, double time=0)
 等待多个线程中的一个完成
 enum_uint (ColorType)
 色彩类型
unsigned int ColorNameToFormat (const wchar_t *)
 这一种格式是否需要混合
uint64 int128to64 (int128 n)
void itow (int128, wchar_t *)
int128 wtoi (wchar_t *)
int tdfReadCompressData (TDFNode *, const WideString &, const WideString &, void *, int)
 读取压缩数据
void tdfWriteCompressData (TDFNode *, const WideString &, const WideString &, void *, int, const WideString &)
 存入压缩数据
void tdfWriteCompressData (TDFNode *, const WideString &, const WideString &, void *, int, CA)
 存入压缩数据
int tdfReadCompressData (TDFNode *, const WideString &, void *, int)
 读取压缩数据
void tdfWriteCompressData (TDFNode *, const WideString &, void *, int, const WideString &)
 存入压缩数据
void tdfWriteCompressData (TDFNode *, const WideString &, void *, int, CA=caRLE)
 存入压缩数据
int tdfReadCompressImage (TDFNode *, const WideString &, const WideString &, void *, int, int, int)
void tdfWriteCompressImage (TDFNode *, const WideString &, const WideString &, void *, int, int, int, const WideString &, float)
int tdfReadCompressImage (TDFNode *, const WideString &, void *, int, int, int)
void tdfWriteCompressImage (TDFNode *, const WideString &, void *, int, int, int, const WideString &, float)
 oper_over (char)
 oper_over (wchar_t)
 oper_over (int)
 oper_over (uint)
 oper_over (int64)
 oper_over (uint64)
 oper_over (double)
 oper_over (char *)
 oper_over (wchar_t *)
template<typename T >
WideString BinaryToStr (const T &value)
WideString HexToStr (const uint8 *data, const int bytes, bool upper=true)
template<typename T >
WideString HexToStr (const T &value, bool upper=true)
WideString IntToStr (int64 n)
 转换整型数到WideString
WideString UIntToStr (uint64 n)
 转换整型数到WideString
WideString FloatToStr (double n)
 转换浮点数到WideString
void IntToSize (WideString &, uint64)
int power_to_2 (int value)
template<typename T >
void hgl_swap (T &x, T &y)
template<typename T >
hgl_abs (const T &v)
template<typename T >
hgl_min (const T &a, const T &b)
template<typename T >
hgl_max (const T &a, const T &b)
template<typename T >
hgl_min (const T *data, int count, T min_value)
template<typename T >
hgl_max (const T *data, int count, T max_value)
double hgl_ang2rad (const double ang)
double hgl_rad2ang (const double rad)
template<typename S , typename D >
void hgl_cpy (D *dst, const S *src, const size_t count)
template<typename T >
void hgl_set (T *data, const T &value, const size_t count)
FindPathCreateFindPath (FPA, int, int)
 创建寻路模块
template<typename T >
bool Sort (T *data, int count, Comparator< T > *comp=new Comparator< T >())
template<typename T >
bool Sort (List< T > &list, Comparator< T > *comp=Comparator< T >())
typedef DefEvent (bool, TASK_UPDATE_FUNC,(TaskManager *))
bool InitSystem (bool=true, bool=true)
 初始化系统
void CloseSystem ()
 关闭系统
bool InitGraphics (TCustomControl *)
 初始化图形模式,不显示
bool InitGraphics (TCustomControl *, int, int, int, int)
 初始化图形模式
void ChangeViewport (int=0, int=0, int=0, int=0)
 更改显示位置
void CloseGraphics ()
 关闭图形模式
void RedrawScreen ()
 刷新整个屏幕
void ChangeViewport ()
 更改显示位置
bool InitAudio (const char *device_name=0)
 初始化音频
void CloseAudio ()
 关闭音频
Matrix4f identity ()
Matrix4f inverse (const Matrix4f &m)
Matrix4f perspective (float fovy, float aspect, float znear, float zfar)
Matrix4f ortho2 (float width, float height, float znear=0, float zfar=1)
Matrix4f ortho4 (float left, float right, float bottom, float top, float znear=0, float zfar=1)
Matrix4f lookAt (const cml::vector3f &eye, const cml::vector3f &target, const cml::vector3f &up)
Matrix4f translate (const cml::vector3f &v)
Matrix4f translate (float x, float y, float z)
Matrix4f scale (const cml::vector3f &v)
Matrix4f scale (float x, float y, float z)
Matrix4f scale (float s)
Matrix4f rotate (float angle, const cml::vector3f &axis)
Matrix4f rotate (float angle, float x, float y, float z)
Matrix4f rotate (float angle, const cml::vector4f &axis)
cml::vector3f normalize (const cml::vector3f &v)
cml::vector3f cross (const cml::vector3f &v1, const cml::vector3f &v2)
float dot (const cml::vector3f &v1, const cml::vector3f &v2)
float length_squared (const cml::vector2f &v1, const cml::vector2f &v2)
float length (const cml::vector2f &v1, const cml::vector2f &v2)
float length_squared (const cml::vector3f &v1, const cml::vector3f &v2)
float length (const cml::vector3f &v1, const cml::vector3f &v2)
cml::vector2f to (const cml::vector2f &start, const cml::vector2f &end, float pos)
cml::vector3f to (const cml::vector3f &start, const cml::vector3f &end, float pos)
void init_genrand (uint32 s)
void init_by_array (uint32 init_key[], int32 key_length)
void InitRand ()
bool InitCore (SystemInfo &si, SystemInitInfo *)
bool GetTempPath (wchar_t *path, unsigned long s)
bool GetCMGDKPath (wchar_t *path, unsigned long s)
void GetCMGDKPath (wchar_t *path, const wchar_t *work, const wchar_t *start, const wchar_t *cm, const wchar_t *sub)
void GetCMGDKPath (CMGDKPATH &cp)
void SystemCheck (SystemInfo *si, bool put)
int find_argv (int argc, wchar_t **argv, const wchar_t *str)
void InitMemoryPool ()
void ClearMemoryPool ()
 FONTCOMP (SetWidth, int, width, w)
 FONTCOMP (SetHeight, int, height, h)
 FONTCOMP (SetBold, bool, bold, b)
 FONTCOMP (SetItalic, bool, italic, i)
int128 operator/ (int128 n1, int128 n2)
int128 operator* (int128 n1, int128 n2)
int128 operator% (int128 n1, int128 n2)
int128 operator+ (int128 n1, int128 n2)
int128 operator- (int128 n1, int128 n2)
int128 operator+= (int128 &n1, int128 n2)
int128 operator-= (int128 &n1, int128 n2)
int128 operator*= (int128 &n1, int128 n2)
int128 operator/= (int128 &n1, int128 n2)
int128 operator| (int128 n1, int128 n2)
int128 operator& (int128 n1, int128 n2)
bool operator== (int128 n1, int128 n2)
bool operator> (int128 n1, int128 n2)
bool operator< (int128 n1, int128 n2)
bool operator!= (int128 n1, int128 n2)
bool operator>= (int128 n1, int128 n2)
bool operator<= (int128 n1, int128 n2)
template<typename T >
void SplitToStringList (StringList *sl, T *data, int size)
 READFUNC (ReadBool, bool)
 READFUNC (ReadInt8, int8)
 READFUNC (ReadInt16, int16)
 READFUNC (ReadInt32, int32)
 READFUNC (ReadInt64, int64)
 READFUNC (ReadUint8, uint8)
 READFUNC (ReadUint16, uint16)
 READFUNC (ReadUint32, uint32)
 READFUNC (ReadUint64, uint64)
 READFUNC (ReadFloat, float)
 READFUNC (ReadDouble, double)
 READFUNC (ReadString, WideString)
 WRITEFUNC (WriteBool, bool)
 WRITEFUNC (WriteInt8, int8)
 WRITEFUNC (WriteInt16, int16)
 WRITEFUNC (WriteInt32, int32)
 WRITEFUNC (WriteInt64, int64)
 WRITEFUNC (WriteUint8, uint8)
 WRITEFUNC (WriteUint16, uint16)
 WRITEFUNC (WriteUint32, uint32)
 WRITEFUNC (WriteUint64, uint64)
 WRITEFUNC (WriteFloat, float)
 WRITEFUNC (WriteDouble, double)
 WRITEFUNC (WriteString, const WideString &)
void __cdecl HacMappingEnumFile (void *fp, hgl::FileInfo &fi)
bool __cdecl GetLogPlugInInterface (uint32 ver, void *data)
apr_pool_t * get_default_apr_pool ()
RWLockCreateRWLockAPR ()
CondVarCreateCondVarAPR ()
void InitCondVarNT6 ()
CondVarCreateCondVarNT6 ()
void InitRWLockNT6 ()
RWLockCreateRWLockNT6 ()
hgl_thread_result ThreadFunc (void *ptr)
 PlugInManage (Compress, L"Compress", 3)
void CreateTempFileName (WideString &filename)
int ParseAnsi (wchar_t **buf, uchar *raw_str, int byte_size, CCP ccp)
template<typename T >
int ParseUTF (wchar_t **buf, void *raw_str, int byte_size, bool is_little_endian)
int ParseUTF8 (wchar_t **wide_str, const uchar *utf8_str, int size)
void * LoadFileToMemory (const wchar_t *filename, uint offset, uint length, void *buf)
bool SaveMemoryToFile (const wchar_t *filename, int offset, int length, void *data)
bool LoadInterfaceByName (const wchar_t *name, int ver, void *data)
bool LoadInterfaceByIndex (int index, int ver, void *data)
bool __cdecl LoadInterface (const wchar_t *name, int ver, void *data)
 PROC (Proc_MouseMove)
 PROC (Proc_MouseLeftDown)
 PROC (Proc_MouseLeftUp)
 PROC (Proc_MouseLeftDoubleClick)
 PROC (Proc_MouseMidDown)
 PROC (Proc_MouseMidUp)
 PROC (Proc_MouseMidDoubleClick)
 PROC (Proc_MouseRightDown)
 PROC (Proc_MouseRightUp)
 PROC (Proc_MouseRightDoubleClick)
 PROC (Proc_JoystickDown)
 PROC (Proc_JoystickPress)
 PROC (Proc_JoystickUp)
 PROC (Proc_KeyDown)
 PROC (Proc_KeyPress)
 PROC (Proc_KeyUp)
 PROCFUNC (LeftDown)
 PROCFUNC (LeftUp)
 PROCFUNC (LeftDoubleClick)
 PROCFUNC (RightDown)
 PROCFUNC (RightUp)
 PROCFUNC (RightDoubleClick)
 PROCFUNC (MidDown)
 PROCFUNC (MidUp)
 PROCFUNC (MidDoubleClick)
 PROCFUNC (JoystickPress, uint)
 PROCFUNC (JoystickUp, uint)
 PROCFUNC (KeyDown, uint)
 PROCFUNC (KeyPress, uint)
 PROCFUNC (KeyUp, uint)
 PROCFUNC (Char, wchar_t)
 PROCFUNC (Proc_MouseMove, OnMouseMove)
 PROCFUNC (Proc_MouseLeftDown, OnMouseLeftDown)
 PROCFUNC (Proc_MouseLeftUp, OnMouseLeftUp)
 PROCFUNC (Proc_MouseLeftDoubleClick, OnMouseLeftDoubleClick)
 PROCFUNC (Proc_MouseRightDown, OnMouseRightDown)
 PROCFUNC (Proc_MouseRightUp, OnMouseRightUp)
 PROCFUNC (Proc_MouseRightDoubleClick, OnMouseRightDoubleClick)
 PROCFUNC (Proc_MouseMidDown, OnMouseMidDown)
 PROCFUNC (Proc_MouseMidUp, OnMouseMidUp)
 PROCFUNC (Proc_MouseMidDoubleClick, OnMouseMidDoubleClick)
 PROCFUNC (Proc_JoystickDown, uint)
 PROCFUNC (Proc_JoystickPress, uint)
 PROCFUNC (Proc_JoystickUp, uint)
 PROCFUNC (Proc_KeyDown, uint)
 PROCFUNC (Proc_KeyPress, uint)
 PROCFUNC (Proc_KeyUp, uint)
 PROCFUNC (Proc_Char, wchar_t)
 ProcFunc (Proc_MouseLeftUp)
 ProcFunc (Proc_MouseMidUp)
 ProcFunc (Proc_MouseRightUp)
 ProcFunc (Proc_MouseLeftDoubleClick)
 ProcTopFunc (Proc_MouseMidDown)
 ProcFunc (Proc_MouseMidDoubleClick)
 ProcTopFunc (Proc_MouseRightDown)
 ProcFunc (Proc_MouseRightDoubleClick)
void ClearFont ()
FontUnitGetFont (const wchar_t *fontname, int w, int h, bool b, bool i)
FontUnitGetFont (Font &fnt)
void ReleaseFont (FontUnit *fu)
void * ClipBorder (int &l, int &t, int &w, int &h, void **data, ColorType ct)
uint8GetScreenData (int, int, int, int, ColorType, bool=false)
uint8GetScreenData (int, int, int, int, int, int, ColorType, bool=false)
template<typename T >
void CheckBorder (int &l, int &t, int &w, int &h, T *data)
template<typename T >
T * ClipBorder (int &l, int &t, int &w, int &h, T **data)
int __inline CompColor (uchar *src, uchar *dst, int comp_color, int color)
void CheckSame (int &l, int &t, int &w, int &h, uchar *cur, int ol, int ot, int ow, int oh, uchar *ori, int color, bool clear_same_point)
bool ConvertImg2HGP (const wchar_t *img_filename, const wchar_t *hgp_filename, bool merge, bool same, ColorType ct, const wchar_t *ca, float rate)
 PlugInManage (Image, L"Image", 2)
ImagePlugInInterfaceImageInterfaceCheck (ImageFormat ift)
void L2LA (uint8 *tar, uint8 *src, uint8 *tcolor, uint32 size)
void RGB2RGBA (uint8 *tar, uint8 *src, uint8 *tcolor, uint32 size)
void RGBA2RGB (uint8 *rgba, uint8 *rgb, uint32 size)
void RGBA2RGB_A (uint8 *rgba, uint8 *rgb, uint8 *a, uint32 size)
void RGB_A2RGBA (uint8 *rgba, uint8 *rgb, uint8 *a, uint32 size)
bool CheckMono (uint8 *data, uint bytes, uint width, uint height)
void * ConvertToMono (uint8 *data, uint bytes, uint width, uint height)
int CheckAlpha (uint8 *data, uint bytes, uint width, uint height)
uint8ClearAlpha (uint8 *data, uint bytes, uint width, uint height)
void ClearColor (uchar *data, uint total, uint color)
void ClearColor (uchar *dst, uchar *src, uint total, uint color)
void * LoadOtherFormat (const wchar_t *filename, uint &format, int &width, int &height, ColorType &ct, bool check_mono, bool check_alpha, ImageFormat pi_index)
void * LoadMonoLayer (const wchar_t *filename, uint &format, int &width, int &height, ColorType &color, bool check_mono, bool check_alpha)
bool SaveBitmapToFile (const wchar_t *filename, int width, int height, int color, void *data)
bool ConvertImageFileFormat (const wchar_t *src, const wchar_t *dst)
void SplitToChannels (uint8 *out, uint8 *in, int size, int number)
void MergeChannels (uint8 *out, uint8 *in, int size, int number)
 enum_uint (ImageFormat)
ImagePlugInInterfaceImageInterfaceCheck (const WideString &)
int ProcSize (int size, int min)
int Unite (int *data, int number, int min)
void PutOpenExtInfo (const char *str, const char *flag)
void PutOpenGLIntegerValue (const wchar_t *name, const uint flag)
void PutOpenGLFloatValue (const wchar_t *name, const uint flag)
void PutOpenGLRGBAValue (const wchar_t *name, const uint flag)
void PutOpenGLFloatRange (const wchar_t *name, const uint flag)
void PutOpenGLStringValue (const char *name, const uint flag)
void PutOpenGLStringValue (const char *name, const char *str)
void PutOpenGLInfo (const char *os_ext_info, const char *os_ext_name)
void AnalyseVendor ()
void CheckMaxMatrixDepth ()
int CheckLight ()
int CheckMultiTexture ()
bool CheckFogCoord ()
bool CheckPointParameters ()
bool CheckDepthTexture ()
bool CheckShadow ()
bool CheckPointSprite ()
bool CheckAnisotropy ()
void CheckTextureWrap ()
bool CheckCubeMap ()
bool CheckVBOFunc ()
bool CheckVAO ()
bool CheckFBO ()
bool CheckPBO ()
bool CheckVP ()
bool CheckFP ()
bool CheckVS ()
bool CheckFS ()
bool CheckGS ()
bool CheckGLSL ()
bool CheckOcclusionQuery ()
void __stdcall glMultiDrawArrays_Software (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
void __stdcall glMultiDrawElements_Software (GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)
bool CheckMultiDraw ()
bool CheckDrawInstance ()
bool Check3DTexture ()
bool CheckRectTexture ()
bool CheckNPOTTexture ()
bool CheckTextureArray ()
void CheckCompressTexture ()
bool CheckFloatTexture ()
void PutATIMemoryInfo (uint value, const wchar_t *name)
void PutATIString (uint gpu_id, uint info_id, const wchar_t *fmt)
void PutATIInteger (uint gpu_id, uint info_id, const wchar_t *fmt)
void CheckVideoCard_ATI ()
void CheckVideoCard_NVIDIA ()
bool CreateScreenShotFilename (WideString &fn, const wchar_t *ext_name)
TARGB32Pixels (const TPicRegion &pic, const long x, const long y)
TARGB32 Pixels_Bound (const TPicRegion &pic, long x, long y)
void Bilinear_Fast_Common (TARGB32 *PColor0, TARGB32 *PColor1, unsigned long u_8, unsigned long v_8, TARGB32 *result)
void Bilinear_Border_Common (const TPicRegion &pic, const long x_16, const long y_16, TARGB32 *result)
void PicZoom_Bilinear_Common (const TPicRegion &Dst, const TPicRegion &Src)
 DRAW_ARRAY_DEF (DrawArrayColor, glColorPointer(dc_num, gl_format, 0, data+offset))
 DRAW_ARRAY_DEF (DrawArrayVertex, glVertexPointer(dc_num, gl_format, 0, data+offset))
 DRAW_ARRAY_DEF (DrawArrayTexCoord, glTexCoordPointer(dc_num, gl_format, 0, data+offset))
 DRAW_ARRAY_DEF (DrawArrayNormal, glNormalPointer(gl_format, 0, data+offset))
 DRAW_ARRAY_DEF (DrawArray2Color, glSecondaryColorPointer(dc_num, gl_format, 0, data+offset))
 DRAW_ARRAY_DEF (DrawArrayFogCoord, glFogCoordPointer(gl_format, 0, data+offset))
 DRAW_ARRAY_DEF (DrawArrayIndex, glIndexPointer(gl_format, 0, data+offset))
DrawArrayBufferInterfaceCreateTexCoordBuffer (bool use_vbo, uint dc, int count, uint offset)
uint CheckSame (uint8 *data, uint size)
uint CheckNotSame (uint8 *data, uint size)
uint RleCompress (uint8 *dst, uint dst_max, uint8 *src, uint src_length)
uint RleDecompress (uint8 *dst, uint, uint8 *src, uint src_length)
void AnalyseSize (int &fw, int &fh, int w, int h, int max)
void * LoadMonoLayer (const wchar_t *filename, uint &format, int &width, int &height, ColorType &ct)
void SwapRGB (uint8 *data, int size, int pitch)
double Lsin (int angle)
double Lcos (int angle)
void write_to_yuv_frame (uint w, uint h, uint8 *yuv, uint8 *yuv_y, uint8 *yuv_u, uint8 *yuv_v)
uint8 __inline clamp (double d)
uint8RGB2YUV (uint8 *rgb, int w, int h)
int getMin (int a, int b)
int getMax (int a, int b)
int mClamp (int val, int low, int high)
void InitYUV2RGBDecode ()
uint8YUV2RGB (uint8 *yuv, int w, int h)
double LoadAudioData (int index, AudioFileType aft, void *memory, int memory_size)
 PlugInManage (Audio, L"Audio", 2)
AudioPlugInInterfaceAudioInterfaceCheck (const WideString &)
 AFFECTOR_ENUM_FUNC (Start)
 AFFECTOR_ENUM_FUNC (Pause)
 AFFECTOR_ENUM_FUNC (Resume)
 AFFECTOR_ENUM_FUNC (Stop)
 AFFECTOR_ENUM_FUNC (Update)
void * CallCDeclFunction (void *, const void *, int)
 呼叫C函数
void * CallThiscallFunction (void *, const void *, const void *, int)
 呼叫C++函数
 OPER_OVER (DevilCompEqu,==)
 OPER_OVER (DevilCompNotEqu,!=)
 OPER_OVER (DevilCompLessEqu,<=)
 OPER_OVER (DevilCompGreaterEqu, >=)
 OPER_OVER (DevilCompLess,< )
 OPER_OVER (DevilCompGreater, >)
 DEVIL_VALUE (DevilInteger, int, ttInt, wtoi)
 DEVIL_VALUE (DevilUInteger, uint, ttUInt, wtou)
 DEVIL_VALUE (DevilFloat, float, ttFloat, wtof)
 DEVIL_VALUE (DevilBool, bool, ttBool, wtob)
 DEVIL_VALUE (DevilInt64, int64, ttInt64, wtoi)
 DEVIL_VALUE (DevilUInt64, uint64, ttUInt64, wtou)
 DEVIL_VALUE (DevilDouble, double, ttDouble, wtod)
void ConvertString (WideString &targe, wchar_t *source, int length)
void OnMovieCreate (void *movie, int width, int height, int color, int pitch)
void OnMovieDecodeFrame (void *movie, uchar *data)
typedef void (__cdecl *SeekFunc)(Stream *
typedef bool (__cdecl *EofFunc)(Stream *)
typedef int (__cdecl *ReadFunc)(Stream *
void __cdecl Seek (Stream *str, int pos)
bool __cdecl Eof (Stream *str)
int __cdecl Read (Stream *str, void *buf, int size)
bool SetDisplayMode (int width, int height, int bit, int vsync)
bool RestartDisplayMode ()
uint32 GetKeyFlags (uint32 wflags)
void InitKeyConvert ()
KeyButton ConvertOSKey (uint key)
 WMEF (WMProcDestroy)
 WMEF_MOUSE (LeftDown)
 WMEF_MOUSE (LeftUp)
 WMEF_MOUSE (LeftDoubleClick)
 WMEF_MOUSE (MidDown)
 WMEF_MOUSE (MidUp)
 WMEF_MOUSE (MidDoubleClick)
 WMEF_MOUSE (RightDown)
 WMEF_MOUSE (RightUp)
 WMEF_MOUSE (RightDoubleClick)
 WMEF_MOUSE (Move)
 WMEF2 (WMProcMouseWheel)
 WMEF1 (WMProcKeyDown)
 WMEF1 (WMProcKeyUp)
 WMEF1 (WMProcChar)
 WMEF1 (WMProcActive)
 WMEF2 (WMProcSize)
void __cdecl JoyDown (uint key)
void __cdecl JoyPress (uint key)
void __cdecl JoyUp (uint key)
bool GetJoyState (JoyButton key)
void LoadJoystick (HINSTANCE hInstance, HWND hWnd)
void InitMessageProc (GraphicsApplication *app, WinWindow *win, bool joy)
bool MessageProc (WinWindow *win)
void CloseMessageProc ()
LRESULT CALLBACK WindowProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
ThreadCreateWinMessageThread ()
void SetScreenValue (int, int)
void PutDisplayDevicesInfo ()
int ChoosePixelFormat (HDC hDC, int color, int alpha, int depth, int stencil, int accum, int multisample)
void PutSystemInfo (SystemInfo *)
void PutOpenGLInfo (HDC)
bool InitOpenGL ()

变量

OpenGLHardwareSupport OHS
OpenGLChipVendor OCV = ocvNone
GLenum COMPRESSED_RGB = 0
GLenum COMPRESSED_RGBA = 0
GLenum COMPRESSED_LUMINANCE = 0
GLenum COMPRESSED_LUMINANCE_ALPHA = 0
GLenum COMPRESSED_ALPHA = 0
GLenum COMPRESSED_RGB_A1 = 0
GLenum COMPRESSED_RGB_A4 = 0
const int DevilScriptMinLength = sizeof(L"func main(){}")
 《魔鬼》最小脚本长度
COLOR_DEF prv_color [ceEnd+1]
const unsigned int ColorTypeCount = ctEnd+1
const wchar_t ColorTypeName [ColorTypeCount][32]
const unsigned int GLFormatByColorType [ColorTypeCount]
 色彩类型名称
const unsigned int BytesByColorType [ColorTypeCount]
 针对色彩类型而对应的OpenGL格式
const bool BlendByColorType [ColorTypeCount]
 针对色彩类型而对应的每象素字节数
const char HexChar [2][16]
const char HAC3Flag [] = "HAC-3\x1A"
wchar_t CAName [caEnd][32]
IndexData< WideString, WideStringExpendString
const int buf_size = 1024*1024
const wchar_t BeginSymbol [] = "!),.:;?]}¨·ˇˉ―‖’”…∶、。〃々〉》」』】〕〗!"'),.:;?]`|}~¢"
const wchar_t EndSymbol [] = "([{·‘“〈《「『【〔〖(.[{£¥"
const int BeginSymbolCount = sizeof(BeginSymbol)/sizeof(wchar_t)
const int EndSymbolCount = sizeof(EndSymbol)/sizeof(wchar_t)
const wchar_t pi_name [ifEnd][32]
int ActiveTexture
const GLenum OpenGLClientState [gcsEnd]
struct {
   wchar_t   hgl::name [6]
   GLenum   hgl::flag
CubePanel [6]
const float full_tex_coord []
const double SIN45 = 0.707106781186548
const unsigned __int32 SINV [91]
const double clamp_u = 0.436*255.0
const double clamp_v = 0.615*255.0
const unsigned int InvalidIndex = 0xFFFFFFFF
const char glsl_yuv2rgb []

详细描述

__MAKE_HGL__&&!__MAKE_PLUGIN__

古月游戏开发库所使用的名字空间

虚拟机共用要素

由于设定read_pos=write_pos表示无数据,所以当数据刚好读写到结尾时,不立即转成0,而是仍为buffer_size


类型定义文档

AudioBuffer缓冲管理器

AudioBuffer缓冲管理器(从HAC名中取得文件)

typedef volatile uint hgl::avuint
typedef CompressAlgorithm hgl::CA

压缩算法枚举定义

typedef const avuint hgl::cavuint
typedef unsigned int hgl::CCP

HGP图片缓冲管理器

HGP图片缓冲管理器(从HAC名中取得文件)

HGP图片资源管理器

HGP图片资源管理器(从HAC名中取得文件)

HGPSame图片缓冲管理器

HGPSame图片缓冲管理器(从HAC名中取得文件)

typedef hgl::int
typedef signed short hgl::int16

有符号16位整型

鏈夌鍙?6浣嶆暣鍨?

typedef signed long hgl::int32

有符号32位整型

鏈夌鍙?2浣嶆暣鍨?

typedef signed __int64 hgl::int64

有符号64位整型

鏈夌鍙?4浣嶆暣鍨?

typedef signed char hgl::int8

有符号 8位整型

鏈夌鍙?8浣嶆暣鍨?

typedef cml::matrix33f_c hgl::Matrix3f
typedef cml::matrix44f_c hgl::Matrix4f
typedef void hgl::MOVIE
typedef void hgl::MovieInterface
typedef void(_Object::* hgl::ObjectMemberFunc)()

点数据成份

typedef void(* hgl::PIMClearFunc)()
typedef RectScope2<double> hgl::RectScope2d
typedef RectScope2<float> hgl::RectScope2f

Texture2D图片缓冲管理器

Texture2D图片缓冲管理器(从HAC包中取得文件)

Texture2D图片资源管理器

Texture2D图片资源管理器(从HAC名中取得文件)

typedef unsigned char hgl::TUInt8
typedef unsigned char hgl::uchar

无符号字符型

鏃犵鍙峰瓧绗﹀瀷

typedef unsigned int hgl::uint

无符号整型

鏃犵鍙锋暣鍨?

typedef unsigned short hgl::uint16

无符号16位整型

鏃犵鍙?6浣嶆暣鍨?

typedef unsigned long hgl::uint32

无符号32位整型

鏃犵鍙?2浣嶆暣鍨?

typedef unsigned __int64 hgl::uint64

无符号64位整型

鏃犵鍙?4浣嶆暣鍨?

typedef unsigned char hgl::uint8

无符号 8位整型

鏃犵鍙?8浣嶆暣鍨?

typedef cml::vector2f hgl::Vector2f
typedef cml::vector2i hgl::Vector2i
typedef cml::vector3f hgl::Vector3f
typedef cml::vector3i hgl::Vector3i
typedef cml::vector4f hgl::Vector4f
typedef cml::vector4i hgl::Vector4i
typedef Vertex2<double> hgl::Vertex2d
typedef Vertex2<float> hgl::Vertex2f

枚举类型文档

应用程序运行模式枚举

枚举值:
armNone 

起始定义,无意义

armASync 

异步模式,Draw按FPS数量执行,Update只要有空闲就运行

armSync 

同步模式,Draw/Update均按FPS数量执行

armFast 

高速模式,Draw/Update都运行相同数量,但不做延时,一般用于测试最大fps

armExternal 

外部Hinstance/hwnd模式,自身不控制主循环

armServer 

服务器程序专用运行模式

armEnd 

结束定义,无意义

音频文件格式

枚举值:
aftNone 

起始定义,如使用表示自动根据扩展名识别

aftWAV 

Wav音波文件

aftOGG 

Vorbis OGG文件

aftEnd 

代码页枚举

Windows代码页枚举

枚举值:
ccpNone 

起始定义,无意义

ccpGBK 

中国GBK标准中文

ccpBig5 

中国台湾Big5标准繁体中文

ccpGB2312 

中国GB2312标准简体中文

ccpHZGB2312 

中国香港HZ-GB2312标准简体中文

ccpGB18030 

中国GB18030-2000标准中文

ccpShiftJIS 

日文ShiftJIS

ccpJISX 

日文ISO-2022 JIS X 0201-1989

ccpUTF7 

utf-7

ccpUTF8 

utf-8

ccpEnd 

结束定义,无意义

颜色枚举

枚举值:
ceNone 
ceAliceBlue 

艾利斯兰

ceAntiqueWhite 

古董白

ceAqua 

浅绿色

ceAquaMarine 

碧绿色

ceAzure 

天蓝色

ceBeige 

米色

ceBisque 

桔黄色

ceBlack 

黑色

ceBlanchedAlmond 

白杏色

ceBlue 

蓝色

ceBlueViolet 

紫罗兰色

ceBrown 

褐色

ceBurlyWood 

实木色

ceCadetBlue 

军兰色

ceChartreuse 

黄绿色

ceChocolate 

巧克力色

ceCoral 

珊瑚色

ceCornflowerBlue 

菊花兰

ceCornsilk 

米绸色

ceCrimson 

暗深红

ceCyan 

青色

ceDarkBlue 

暗蓝色

ceDarkCyan 

暗青色

ceDarkGoldenrod 

暗金黄

ceDarkGray 

暗灰色

ceDarkGreen 

暗绿色

ceDarkGrey 

暗白色

ceDarkKhaki 

暗黄褐色

ceDarkMagenta 

暗洋红

ceDarkOliveGreen 

暗橄榄绿

ceDarkOrange 

暗桔黄

ceDarkOrchid 

暗紫色

ceDarkRed 

暗红色

ceDarkSalmon 

暗肉色

ceDarkSeaGreen 

暗海兰

ceDarkSlateBlue 

暗灰兰

ceDarkSlateGray 

墨绿色

ceDarkSlateGrey 

暗灰绿

ceDarkTurquoise 

暗宝石绿

ceDarkViolet 

暗紫罗兰

ceDeepPink 

深粉红

ceDeepSkyBlue 

深天蓝

ceDimGray 

暗灰色

ceDimGrey 

暗灰白

ceDodgerBlue 

闪兰色

ceFireBrick 

火砖色

ceFloralWhite 

花白色

ceForestGreen 

森林绿

ceFuchsia 

紫红色

ceGainsboro 

淡灰色

ceGhostWhite 

幽灵白

ceGold 

金色

ceGoldenrod 

金麒麟色

ceGray 

灰色

ceGreen 

绿色

ceGreenYellow 

蓝绿色

ceGrey 

灰白色

ceHoneydew 

蜜色

ceHotPink 

热粉红

ceIndianRed 

印第安红

ceIndigo 

靛青色

ceIvory 

象牙白

ceKhaki 

黄褐色

ceLavender 

淡紫色

ceLavenderBlush 

淡紫红

ceLawnGreen 

草绿色

ceLemonChiffon 

柠檬绸

ceLightBlue 

亮蓝色

ceLightCoral 

亮珊瑚色

ceLightCyan 

亮青色

ceLightGoldenrodYellow 

亮金黄

ceLightGray 

亮灰色

ceLightGreen 

亮绿色

ceLightGrey 

亮灰白

ceLightPink 

亮粉红

ceLightSalmon 

亮肉色

ceLightSeaGreen 

亮海蓝

ceLightSkyBlue 

亮天蓝

ceLightSlateGray 

亮蓝灰

ceLightSlateGrey 

亮蓝白

ceLightSteelBlue 

亮钢兰

ceLightYellow 

亮黄色

ceLime 

酸橙色

ceLimeGreen 

橙绿色

ceLinen 

亚麻色

ceMagenta 

红紫色

ceMaroon 

粟色

ceMediumAquamarine 

间绿色

ceMediumBlue 

间兰色

ceMediumOrchid 

间淡紫

ceMediumPurple 

间紫色

ceMediumSeaGreen 

间海蓝

ceMediumSlateBlue 

间暗蓝

ceMediumSpringGreen 

间春绿

ceMediumTurquoise 

间绿宝石

ceMediumVioletRed 

间紫罗兰

ceMidNightBlue 

中灰蓝

ceMintCream 

薄荷色

ceMistyRose 

浅玫瑰

ceMoccasin 

鹿皮色

ceNavajoWhite 

纳瓦白

ceNavy 

海军色

ceOldLace 

老花色

ceOlive 

橄榄色

ceOlivedrab 

深绿褐色

ceOrange 

橙色

ceOrangeRed 

红橙色

ceOrchid 

淡紫色

cePaleGoldenrod 

苍麒麟色

cePaleGreen 

苍绿色

cePaleTurquoise 

苍宝石绿

cePaleVioletRed 

苍紫罗兰色

cePapayawhip 

番木色

cePeachpuff 

桃色

cePeru 

秘鲁色

cePink 

粉红色

cePlum 

洋李色

cePowderBlue 

粉蓝色

cePurple 

紫色

ceRed 

红色

ceRosyBrown 

褐玫瑰红

ceRoyalBlue 

皇家蓝

ceSaddleBrown 

重褐色

ceSalmon 

鲜肉色

ceSandyBrown 

沙褐色

ceSeaGreen 

海绿色

ceSeaShell 

海贝色

ceSienna 

赭色

ceSilver 

银色

ceSkyBlue 

天蓝色

ceSlateBlue 

石蓝色

ceSlateGray 

灰石色

ceSlateGrey 

白灰石色

ceSnow 

雪白色

ceSpringGreen 

春绿色

ceSteelBlue 

钢兰色

ceTan 

茶色

ceTeal 

水鸭色

ceThistle 

蓟色

ceTomato 

西红柿色

ceTurquoise 

青绿色

ceViolet 

紫罗兰色

ceWheat 

浅黄色

ceWhite 

白色

ceWhiteSmoke 

烟白色

ceYellow 

黄色

ceYellowGreen 

黄绿色

ceEnd 

虚拟机状态

枚举值:
dvsRun 
dvsPause 
dvsStop 

绘制队列数据访问方式

枚举值:
daaWrite 

仅写

daaRead 

仅读

daaReadWrite 

读与写

绘制队列数据状态

枚举值:
dasTemp 

临时

dasStatic 

静态,数据几乎不做变动.(数据一般会放于显存)

dasDynamic 

动态,数据经常做变动.(AGP总线下数据一般会放于AGP加速内存)

dasStream 

频繁变动,数据几乎每帧都要动.(数据一般会放于系统内存)

文件访问模式枚举

枚举值:
fomCreate 

创建一个文件,只写方式

fomOpenRead 

打开一个文件,只读方式

fomOpenWrite 

打开一个文件,只写方式

fomOpenReadWrite 

打开一个文件,可读可写

fomRead 
fomWrite 
fomReadWrite 

寻路算法枚举

枚举值:
fpaNone 
fpaAStar 

A*四方向

fpaAStar8 

A*八方向

fpaLine 

直线

fpaEnd 

ConsoleFlowObject 流程对象状态枚举

参见:
ConsoleFlowObject
ControlFlowObject
枚举值:
fosNotInit 

未初始化

fosOK 

正常

fosExitNotClear 

退出,但不清除

fosExitToBack 

退出到后台,继续绘制和刷新,但不接收事件

fosReturn 

返回上一个状态为ExitNotClear/ExitToBack的对象

fosExit 

退出,进入下一个对象

fosExitFlow 

退出当前流程控制中的所有流程,并进入指定的下一个流程

fosExitGame 

退出整个游戏

枚举值:
gcsNone 
gcsVertex 
gcsTextureCoord 
gcsColor 
gcsNormal 
gcsSecondaryColor 
gcsFogCoord 
gcsIndex 
gcsEnd 
枚举值:
hsNone 
hsNotFind 
hsOpenError 
hsRead 
hsReadError 
hsEnd 

鼠标状态枚举定义

枚举值:
isNone 
isMove 

鼠标移动了

isLeft 

鼠标左键处于按下状态

isLeftDown 

鼠标左键按下了

isLeftUp 

鼠标左键弹起了

isLeftDoubleClick 

鼠标左键双击

isMid 

鼠标中键处于按下状态

isMidDown 

鼠标中键按下了

isMidUp 

鼠标中键弹起了

isMidDoubleClick 

鼠标中键双击

isRight 

鼠标右键处于按下状态

isRightDown 

鼠标右键按下了

isRightUp 

鼠标右键弹起了

isRightDoubleClick 

鼠标右键双击

isShift 

Shift键处于按下状态

isCtrl 

Ctrl键处于按下状态

手柄按键枚举

枚举值:
jbNone 
jbUp 
jbDown 
jbLeft 
jbRight 
jb0 
jb1 
jb2 
jb3 
jb4 
jb5 
jb6 
jb7 
jb8 
jb9 
jb10 
jb11 
jb12 
jb13 
jb14 
jb15 
jb16 
jb17 
jb18 
jb19 
jb20 
jb21 
jb22 
jb23 
jb24 
jb25 
jb26 
jb27 
jb28 
jb29 
jb30 
jb31 
jbEnd 
jbTriangle 
jbCircle 
jbFork 
jbRectangle 
jbL1 
jbL2 
jbR1 
jbR2 
jbSelect 
jbStart 

按键枚举定义,详细请参见InputState.H

枚举值:
kb_NONE 

起始定义,无意义

kbEsc 

ESC.

kbF1 

F1.

kbF2 

F2.

kbF3 

F3.

kbF4 

F4.

kbF5 

F5.

kbF6 

F6.

kbF7 

F7.

kbF8 

F8.

kbF9 

F9.

kbF10 

F10.

kbF11 

F11.

kbF12 

F12.

kbGrave 
kb0 

数字键0

kb1 

数字键1

kb2 

数字键2

kb3 

数字键3

kb4 

数字键4

kb5 

数字键5

kb6 

数字键6

kb7 

数字键7

kb8 

数字键8

kb9 

数字键9

kbMinus 
  • (减号)
kbEquals 

= (等号)

kbBackSlash 

\ (反斜杠)

kbBackSpace 

退格键

kbTab 

Tab键

kbQ 

Q.

kbW 

W.

kbE 

E.

kbR 

R.

kbT 

T.

kbY 

Y.

kbU 

U.

kbI 

I.

kbO 

O.

kbP 

P.

kbLeftBracket 

[

kbRightBracket 

]

kbCapsLock 

大写锁定键

kbA 

A.

kbS 

S.

kbD 

D.

kbF 

F.

kbG 

G.

kbH 

H.

kbJ 

J.

kbK 

K.

kbL 

L.

kbSemicolon 

; (分号)

kbApostrophe 

' (单引号)

kbEnter 

回车键

kbLeftShift 

左边的Shift键

kbZ 

Z.

kbX 

X.

kbC 

C.

kbV 

V.

kbB 

B.

kbN 

N.

kbM 

M.

kbComma 

, (逗号)

kbPeriod 

. (句号)

kbSlash 

/ (除号)

kbRightShift 

右边的Shift键

kbLeftCtrl 

左边的Ctrl键

kbLeftOS 

左边的OS键(Win/Apple键)

kbLeftAlt 

左边的Alt键

kbSpace 

空格键

kbRightAlt 

右边的Alt键

kbRightOS 

右边的OS键(Win/Apple键)

kbRightCtrl 

右边的Ctrl键

kbPrintScreen 

打印屏幕键

kbScrollLock 

滚动锁定键

kbPause 

暂停键

kbInsert 

插入键

kbDelete 

删除键

kbHome 

行首键

kbEnd 

行尾键

kbPageUp 

向前翻页键

kbPageDown 

向后翻页键

kbUp 

↑光标键

kbDown 

↓光标键

kbLeft 

←光标键

kbRight 

→光标键

kbNumLock 

小键盘 数字锁定键

kbNumDivide 

小键盘 /

kbNumMultiply 

小键盘 *

kbNumSubtract 

小键盘 -

kbNum7 

小键盘 7

kbNum8 

小键盘 8

kbNum9 

小键盘 9

kbNum4 

小键盘 4

kbNum5 

小键盘 5

kbNum6 

小键盘 6

kbNumAdd 

小键盘 +

kbNum1 

小键盘 1

kbNum2 

小键盘 2

kbNum3 

小键盘 3

kbNum0 

小键盘 0

kbNumDecimal 

小键盘 . (小数点/删除键)

kbNumEnter 

小键盘 回车键

kb_END 

结束定义,无意义

显卡OpenGL芯片生产商枚举

OpenGL 芯片生产商枚举

枚举值:
ocvNone 

起始定义,无意义

ocvATI 

ATI/AMD.

ocvNVidia 

NVidia.

ocvIntel 

英特尔

ocv3DLabs 

3DLabs

ocvPowerVR 

PowerVR.

ocvSiS 

SiS.

ocvVIA 

威盛科技(VIA)

ocvMatrox 

迈拓科技

ocvXGI 

图诚科技

ocvMesa 

Mesa的软件实现

ocvQuake2 

基于Quake2软件渲染部分的OpenGL实现

ocvDirect3D 

Direct3D API映射

ocvVoodoo 

巫毒,Glide API映射

ocvMicrosoft 

Microsoft 不产显卡,如出现一般表示未安装显卡驱动。引擎不在此模式下运行

ocvSciTech 

GLDirect (一种使用Direct3D模拟OpenGL的工具)

ocvEnd 

结束定义,无意义

点数据成份

枚举值:
pdcColor3f 

RGB 颜色数据

pdcColor4f 

RGBA颜色数据

pdcVertex2f 

XY顶点数据(浮点型)

pdcVertex3f 

XYZ顶点数据(浮点型)

pdcVertex2i 

XY顶点数据(整数型)

pdcVertex3i 

XYZ顶点数据(整数型)

pdcTexCoord1f 

L贴图坐标数据

pdcTexCoord2f 

XY贴图坐标数据

pdcTexCoord3f 

XYZ贴图坐标数据

pdcTexCoord4f 

XYZW贴图坐标数据

pdcTexCoord1i 

L贴图坐标数据

pdcTexCoord2i 

XY贴图坐标数据

pdcTexCoord3i 

XYZ贴图坐标数据

pdcTexCoord4i 

XYZW贴图坐标数据

pdcNormal3f 

法线数据

pdc2Color3f 

SecondaryColor.

pdcFogCoord1f 

雾坐标

pdcIndex1i 

索引int

资源偏移方向枚举

枚举值:
soBegin 

从资源最开始处开始,offset必须大于0。移到资源的offset位置

soCurrent 

从资源当前位置开始,移到资源的Position+offset位置

soEnd 

从资源的结束位置开始,offset必须小于0,表示结束前的字符数

文本排列方式

文本排列方式枚举

枚举值:
taNone 

起始定义,无意义。如使用处理为距左

taLeft 

距左

taCenter 

距中

taRight 

距右

taVRight 

距右(竖排)

taEnd 

结束定义,无意义。如使用处理为距左

对齐方式

枚举值:
alNone 

起始定义,无意义

alTop 

对齐最上端

alBottom 

对齐底端

alLeft 

对齐左边

alRight 

对齐右边

alClient 

使用剩下的所有空间

alLeftTop 

左上角

alRightTop 

右上角

alLeftBottom 

左下角

alRightBottom 

右下角

alTopCenter 

上边中间

alLeftCenter 

左边中间

alRightCenter 

右边中间

alBottomCenter 

下边中间

alCenter 

正中间

alEnd 

结束定义,无意义


函数文档

void hgl::AesDecrypt ( uint8  data[16],
uint8 key,
int  keysize 
)

AES算法解密函数

参数:
data要加密的数据
key密码
keysize密码位数(仅为128,192,256)
void hgl::AesEncrypt ( uint8  data[16],
uint8 key,
int  keysize 
)

AES算法加密函数

参数:
data要加密的数据
key密码
keysize密码位数(仅为128,192,256)
hgl::AFFECTOR_ENUM_FUNC ( Start  )
hgl::AFFECTOR_ENUM_FUNC ( Pause  )
hgl::AFFECTOR_ENUM_FUNC ( Resume  )
hgl::AFFECTOR_ENUM_FUNC ( Stop  )
hgl::AFFECTOR_ENUM_FUNC ( Update  )
void hgl::AnalyseSize ( int &  fw,
int &  fh,
int  w,
int  h,
int  max 
)
void hgl::AnalyseVendor ( )
int hgl::AnsiToWide ( CCP  ccp,
wchar_t *  ws,
int  ws_size,
const char *  as,
int  as_size = -1 
)

转换ANSI字符串到wchar_t *字符串

参数:
ccp代码页
wswchar_t *字符串缓冲区
ws_size缓冲区长度
asansi字符串
as_size字符串长度,-1表示全部
返回:
转换成功后的字符串字符数
int hgl::AnsiToWide ( wchar_t *  ws,
int  ws_size,
const char *  as,
int  as_size = -1 
) [inline]

转换ANSI字符串到wchar_t *字符串(当前系统默认字符集)

参数:
wswchar_t *字符串缓冲区
ws_size缓冲区长度
asansi字符串
as_size字符串长度,-1表示全部
返回:
转换成功后的字符串字符数
int hgl::AnsiToWide ( CCP  ccp,
wchar_t **  ws,
const char *  as,
int  as_size = -1 
)

转换ANSI字符串到wchar_t *字符串

参数:
ccp代码页
wswchar_t *字符串缓冲区,自动分配,需手动delete[]
asansi字符串
as_size字符串长度,-1表示全部
返回:
转换成功后的字符串字符数
int hgl::AnsiToWide ( wchar_t **  ws,
const char *  as,
int  as_size = -1 
) [inline]

转换ANSI字符串到wchar_t *字符串(当前系统默认字符集)

参数:
wswchar_t *字符串缓冲区,自动分配,需手动delete[]
asansi字符串
as_size字符串长度,-1表示全部
返回:
转换成功后的字符串字符数
Loader * hgl::ASyncLoadHGP ( HGP **  hgp,
HAC *  hac,
const wchar_t *  filename 
)

异步加载HGP图片

Loader * hgl::ASyncLoadHGPSame ( HGP **  hgp,
HAC *  hac,
const wchar_t *  filename 
)

异步加载HGPSame图片

Loader * hgl::ASyncLoadTexture2D ( Texture2D **  tex,
HAC *  hac,
const wchar_t *  filename,
uint  gl_format = 0,
uint  mip = 1 
)

异步加载一个贴图

AudioPlugInInterface* hgl::AudioInterfaceCheck ( const WideString &  )
void hgl::Bilinear_Border_Common ( const TPicRegion &  pic,
const long  x_16,
const long  y_16,
TARGB32 *  result 
) [inline]
void hgl::Bilinear_Fast_Common ( TARGB32 *  PColor0,
TARGB32 *  PColor1,
unsigned long  u_8,
unsigned long  v_8,
TARGB32 *  result 
) [inline]
template<typename T >
WideString hgl::BinaryToStr ( const T &  value)
typedef hgl::bool ( __cdecl *  EofFunc)
void * hgl::CallCDeclFunction ( void *  func,
const void *  args,
int  paramSize 
)

呼叫C函数

void * hgl::CallThiscallFunction ( void *  func,
const void *  obj,
const void *  args,
int  paramSize 
)

呼叫C++函数

const WideString hgl::CAToName ( CA  ca)

压缩法算枚举到名称转换

void hgl::ChangeActiveTexture ( int  index)

更改到当前贴图

bool hgl::ChangeArrayBuffer ( GLuint  n)

更改当前使用的缓冲区,返回true表示改换,返回false没有换(和原先的一样)

void hgl::ChangeBlend ( BlendMode &  bm)

更改到当前混合设置

void hgl::ChangeShader ( GLuint  index)

更改当前使用的shader

void hgl::ChangeTexture ( int  index,
Texture *  tex 
)

更改到当前贴图设置

void hgl::ChangeTexture ( Texture *  tex)

更改到当前贴图设置

void hgl::ChangeViewport ( int  left,
int  top,
int  width,
int  height 
)

更改显示位置

更改显示位置

参数:
left,top位置
width,height大小
void hgl::ChangeViewport ( )

更改显示位置

更新显示位置

参数:
显示位置对应的VCL控件
bool hgl::Check3DTexture ( )

检测并选择当前显卡/显卡驱动支持使用的矩形贴图

int hgl::CheckAlpha ( uint8 data,
uint  bytes,
uint  width,
uint  height 
)
bool hgl::CheckAnisotropy ( )
template<typename T >
void hgl::CheckBorder ( int &  l,
int &  t,
int &  w,
int &  h,
T *  data 
)
void hgl::CheckCompressTexture ( )

检则压缩贴图支持,并自动选择最好的压缩格式
支持S3TC,3DFX,ARB,3DC,LATC

bool hgl::CheckCubeMap ( )
bool hgl::CheckDepthTexture ( )
bool hgl::CheckDrawInstance ( )

检测是否支持实例绘制,如果不支持,使用自制的模拟实现

bool hgl::CheckFBO ( )
bool hgl::CheckFloatTexture ( )
bool hgl::CheckFogCoord ( )
bool hgl::CheckFP ( )
bool hgl::CheckFS ( )
bool hgl::CheckGLSL ( )
bool hgl::CheckGS ( )
int hgl::CheckLight ( )
void hgl::CheckMaxMatrixDepth ( )
bool hgl::CheckMono ( uint8 data,
uint  bytes,
uint  width,
uint  height 
)
bool hgl::CheckMultiDraw ( )

检测是否支持多重绘制,如果不支持,使用自制的模拟实现

int hgl::CheckMultiTexture ( )

检测多重贴图数量

uint hgl::CheckNotSame ( uint8 data,
uint  size 
)
bool hgl::CheckNPOTTexture ( )

检测当前显卡/驱动是否支持非2次幂贴图

bool hgl::CheckOcclusionQuery ( )
void hgl::CheckOpenGLExt ( )

检测和处理OpenGL扩展

bool hgl::CheckPBO ( )
template<typename T >
T* hgl::CheckPlugIn ( _IndexObject< WideString, T, PlugInFlagData< T * > > &  PIM,
const WideString front,
uint  ver,
const WideString name 
)
bool hgl::CheckPointParameters ( )
bool hgl::CheckPointSprite ( )
bool hgl::CheckRectTexture ( )

检测并选择当前显卡/显卡驱动支持使用的矩形贴图

uint hgl::CheckSame ( uint8 data,
uint  size 
)
void hgl::CheckSame ( int &  l,
int &  t,
int &  w,
int &  h,
uchar cur,
int  ol,
int  ot,
int  ow,
int  oh,
uchar ori,
int  color,
bool  clear_same_point 
)
bool hgl::CheckShadow ( )
bool hgl::CheckTextureArray ( )

检测当前显卡/驱动是否支持贴图阵列

void hgl::CheckTextureWrap ( )

检测显卡对贴图WRAP方式的支持

bool hgl::CheckVAO ( )

检测VAO支持
VAO必须VBO支持,以及2部分的函数

返回:
是否支持
bool hgl::CheckVBOFunc ( )

检测VBO函数支持
这个是必须的,不能仅通过ARB扩展和OpenGL版本号来区分。在Intel的显卡驱动中,某些显卡版本号标识1.4,但不支持VBO。

void hgl::CheckVideoCard_ATI ( )
void hgl::CheckVideoCard_NVIDIA ( )
bool hgl::CheckVP ( )
bool hgl::CheckVS ( )
int hgl::ChoosePixelFormat ( HDC  hDC,
int  color,
int  alpha,
int  depth,
int  stencil,
int  accum,
int  multisample 
)
uint8 __inline hgl::clamp ( double  d)
void hgl::ClearAllPlugIn ( )

清除所有插件

uint8 * hgl::ClearAlpha ( uint8 data,
uint  bytes,
uint  width,
uint  height 
)
void hgl::ClearColor ( uchar data,
uint  total,
uint  color 
)
void hgl::ClearColor ( uchar dst,
uchar src,
uint  total,
uint  color 
)
void hgl::ClearExpendString ( const WideString &  flag)

清除特殊扩展字符串

void hgl::ClearFont ( )
void hgl::ClearMatrix ( GLenum  matrix)

清除矩阵

清除指定矩阵

参数:
matrix矩阵(只能是GL_PROJECTION、GL_MODELVIEW、GL_TEXTURE)
void hgl::ClearMatrixStack ( )

清除矩阵堆栈

void hgl::ClearMemoryPool ( )
void hgl::ClearScreen ( ) [inline]
void * hgl::ClipBorder ( int &  l,
int &  t,
int &  w,
int &  h,
void **  data,
ColorType  ct 
)
template<typename T >
T* hgl::ClipBorder ( int &  l,
int &  t,
int &  w,
int &  h,
T **  data 
)
void hgl::CloseAlphaTest ( )
void hgl::CloseArrayBuffer ( )

关闭缓冲区

void hgl::CloseAudio ( )

关闭音频

void hgl::CloseBlend ( )

关闭混合效果

void hgl::CloseClientState ( GraphicsClientState  gcs)

关闭OpenGL客户端状态

void hgl::CloseColorMaterial ( )
void hgl::CloseCore ( )

关闭核心

void hgl::CloseCullFace ( )

关闭面裁剪

void hgl::CloseDepthMask ( )
void hgl::CloseDepthTest ( )

关闭深度测试

void hgl::CloseGraphics ( )

关闭图形模式

void hgl::CloseLineSmooth ( )

关闭线条平滑

void hgl::CloseLineStipple ( )

关闭点划线

void hgl::CloseMessageProc ( )
void hgl::CloseScissor ( )

关闭裁剪

void hgl::CloseShader ( )

关闭shader渲染

void hgl::CloseSystem ( )

关闭系统

void hgl::CloseTexture ( )

关闭贴图渲染

void hgl::CloseTexture ( int  index)

关闭贴图渲染

void hgl::CloseTextureGen ( GLenum  coord)
void hgl::CloseTextureGen ( )
unsigned int hgl::ColorNameToFormat ( const wchar_t *  str)

这一种格式是否需要混合

将色彩类型名称转成OpenGL格式

int __inline hgl::CompColor ( uchar src,
uchar dst,
int  comp_color,
int  color 
)
uint32 hgl::Compress ( const WideString ca_name,
void *  data,
uint32  size,
void *  compressdata,
uint32  out_max,
float  level 
)

压缩数据

压缩一个内存块的数据并存放到另一个内存块

参数:
ca_name压缩算法
data原始数据指针
size原始数据的长度
compressdata压缩后数据的存放位置
out_max压缩后输出数据存放区大小
level压缩级别(0:不压缩,1:最大压缩比)
返回:
压缩后数据的长度
参见:
CompressAlgorithm
Decompress
uint32 __inline hgl::Compress ( CA  ca,
void *  data,
uint32  size,
void *  compressdata,
uint32  out_max,
float  level = 1 
)

压缩一个内存块的数据并存放到另一个内存块

参数:
ca压缩算法
data原始数据指针
size原始数据的长度
compressdata压缩后数据的存放位置
out_max压缩后输出数据存放区大小
level压缩级别(0:不压缩,1:最大压缩比)
返回:
压缩后数据的长度
参见:
CompressAlgorithm
Decompress
bool hgl::ConvertExpendString ( const WideString &  source,
WideString &  target 
)

转换特殊扩展字符串

转换特殊扩展字符串

参数:
source原始字符串
target转换后的字符串
bool hgl::ConvertImageFileFormat ( const wchar_t *  src,
const wchar_t *  dst 
)
bool hgl::ConvertImg2Anime ( int  ,
const wchar_t **  ,
const wchar_t *  ,
ColorType  ctNone,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

转换一组图片到一个Anime动画文件

bool hgl::ConvertImg2CubeTex ( const wchar_t **  ,
const wchar_t *  ,
ColorType  = ctNone,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

转换一组图片到一个Cube贴图,供CubeMap或SkyBox使用

bool hgl::ConvertImg2HGP ( const wchar_t *  img_filename,
const wchar_t *  hgp_filename,
bool  merge,
bool  same,
ColorType  ct,
const wchar_t *  ca,
float  rate 
)

转换一个图片文件到HGP文件

参数:
img_filename原始文件名称
hgp_filenameHGP文件名称
merge是否自动合层
same是否裁剪重复内容
返回:
是否转换成功
bool hgl::ConvertImg2Tex ( const wchar_t *  ,
const wchar_t *  ,
ColorType  = ctNone,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

转换一个图片到.TEX贴图文件

bool hgl::ConvertMonoLayerImageToHGP ( const wchar_t *  img_filename,
const wchar_t *  hgp_filename,
ColorType  ct,
const wchar_t *  ca,
float  rate 
)

转换单层图片到HGP

转换一个图片文件到HGP文件,以单层模式读取PSD

参数:
img原始文件名称
hgpHGP文件名称
返回:
是否转换成功
bool hgl::ConvertMonoLayerImageToTex1D ( const wchar_t *  ,
const wchar_t *  ,
ColorType  = ctNone,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

转换一个单层图片到Tex1D

bool hgl::ConvertMultiLayerImageToHGP ( const wchar_t *  img_filename,
const wchar_t *  hgp_filename,
ColorType  ct,
const wchar_t *  ca,
float  rate 
)

转换多层图片到HGP

转换一个图片文件到HGP文件,自动识别多层PSD

参数:
img原始文件名称
hgpHGP文件名称
返回:
是否转换成功
KeyButton hgl::ConvertOSKey ( uint  key)
bool hgl::ConvertPSDToMapHGP ( const wchar_t *  img_filename,
const wchar_t *  hgp_filename,
ColorType  ct,
const wchar_t *  ca,
float  rate 
)

转换PSD到地图用HGP

转换一个图片文件到地图用HGP文件

参数:
img原始文件名称
hgpHGP文件名称
返回:
是否转换成功
bool hgl::ConvertSameLayerImageToHGP ( const wchar_t *  img_filename,
const wchar_t *  hgp_filename,
ColorType  ct,
const wchar_t *  ca,
float  rate 
)

转换多层图片到HGP(并自动裁剪掉每一层与底层相同内容的部分)

转换一个图片文件到HGP文件,自动识别多层PSD.并自动裁剪掉每层与底层相同的内容

参数:
img原始文件名称
hgpHGP文件名称
返回:
是否转换成功
bool hgl::ConvertSameLayerImageToHGPTest ( const wchar_t *  img_filename,
const wchar_t *  hgp_filename,
ColorType  ct = ctNone,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

转换多层图片到HGP(并自动裁剪掉每一层与底层相同内容的部分)

void hgl::ConvertString ( WideString targe,
wchar_t *  source,
int  length 
)
void * hgl::ConvertToMono ( uint8 data,
uint  bytes,
uint  width,
uint  height 
)
HGP * hgl::CopyScreenToHGP ( int  ,
int  ,
int  ,
int  ,
uint  = GL_RGB8 
)

根据当前屏幕图像生成一个HGP

根据当前屏幕内容生成一个HGP

参数:
left截取屏幕左边际坐标
top截取屏幕上边际坐标
width,height截取屏幕的宽,高
gl_format在显存中使用的OpenGL格式,默认GL_RGB8
返回:
创建好的HGP指针
NULL 创建失败
Texture2D * hgl::CopyScreenToTexture2D ( int  left,
int  top,
int  width,
int  height,
uint  gl_format 
)

根据当前屏幕内容生成一个2D贴图

根据当前屏幕内容生成一个Texture2D

参数:
left截取屏幕左边际坐标
top截取屏幕上边际坐标
width,height截取屏幕的宽,高
gl_format在显存中使用的OpenGL格式,默认GL_RGB8
返回:
创建好的Texture2D
uint hgl::CountAdler32 ( unsigned int  adler,
const unsigned char *  buf,
unsigned int  len 
)

Adler32校检码计算

参数:
adler初始码
buf待校验数据指针
len待校验数据长度
返回:
校检码
void hgl::CountSHA1 ( uint8 data,
uint32  size,
uint8  digest[20] 
)

使用SHA1算法生成一块数据的校验码

参数:
data数据
size数据长度
digest生成的校验码存放处
MemManage* hgl::CreateCMemManage ( )

创建一个使用C内存函数的内存管理器

CondVar * hgl::CreateCondVar ( )

创建条件变量

CondVar* hgl::CreateCondVarAPR ( )
CondVar* hgl::CreateCondVarNT6 ( )
template<typename T >
T* hgl::CreateCopy ( const T *  str,
int  size = -1 
)

创建一个复制

参数:
str要复制的字符串
size字符串长度,-1表示自动测试
返回:
复制出来的字符串
DevilVM * hgl::CreateDevilEngine ( )

创建一个《魔鬼》虚拟机引擎

FindPath * hgl::CreateFindPath ( FPA  fpa,
int  width,
int  height 
)

创建寻路模块

创建一个寻路模块

参数:
fpa寻路算法
width查找范围宽度
height查找范围高度
返回:
寻路模块
RWLock * hgl::CreateRWLock ( )

创建读写锁

RWLock * hgl::CreateRWLockAPR ( )
RWLock * hgl::CreateRWLockNT6 ( )
bool hgl::CreateScreenShotFilename ( WideString &  fn,
const wchar_t *  ext_name 
)
void hgl::CreateTempFileName ( const wchar_t *  )

创建临时文件名称

void hgl::CreateTempFileName ( WideString &  filename)
DrawArrayBufferInterface* hgl::CreateTexCoordBuffer ( bool  use_vbo,
uint  dc,
int  count,
uint  offset 
)
TileFont * hgl::CreateTileFont ( Font &  chs_fnt,
Font &  eng_fnt,
int  count 
)

创建一个字体,使用系统字体

通过系统字体创建一个Tile字体,字体大小以较大的为准

参数:
chs_fnt英文字体
eng_fnt中文字体
count缓冲区内保存的字符个数,-1表示自动取(会根据屏幕大小取最大值)
__inline TileFont* hgl::CreateTileFont ( const wchar_t *  chs_fontname,
const wchar_t *  eng_fontname,
int  width,
int  height,
bool  bold,
bool  italic,
int  count 
)

通过系统字体创建一个Tile字体

参数:
chs_fontname中文字体名称
eng_fontname英文字体名称
width宽,可以为0,表示默认。
height
bold加粗,默认false
italic斜体,默认false
count缓冲区内保存的字符个数
__inline TileFont* hgl::CreateTileFont ( const wchar_t *  fontname,
int  width,
int  height,
bool  bold = false,
bool  italic = false,
int  num = -1 
)

通过系统字体创建一个Tile字体,中英文字体相同

参数:
fontname字体名称
width宽,可以为0,表示默认。
height
bold加粗,默认false
italic斜体,默认false
count缓冲区内保存的字符个数
__inline TileFont* hgl::CreateTileFont ( const wchar_t *  chs_fontname,
const wchar_t *  eng_fontname,
int  width,
int  height,
int  num = -1 
)

通过系统字体创建一个Tile字体,无斜体,无加粗

参数:
chs_fontname中文字体名称
eng_fontname英文字体名称
width宽,可以为0,表示默认。
height
count缓冲区内保存的字符个数
VSBase * hgl::CreateVS ( int  width,
int  height,
ColorType  ct 
)

根据尺寸和色彩类型创建一个虚拟屏幕

VSBase * hgl::CreateVS ( ColorType  ct)

根据色彩类型创建一个虚拟屏幕

VSBase * hgl::CreateVSFromFile ( const wchar_t *  filename,
bool  check_mono,
bool  check_alpha 
)

从贴图文件(*.TEX)加载一个虚拟屏幕

加载一个贴图文件(*.TEX),并为其创建虚拟屏幕

参数:
filename贴图文件名称
check_mono自动将没有色彩的图片由RGB/RGBA转为Lum/LumAlpha
check_alpha自动清除alpha全部为0或全部为1的数据,将LumAlpha/RGBA转为Lum/RGB
VSBase * hgl::CreateVSFromFile ( HAC hac,
const wchar_t *  filename 
)

从贴图文件(*.TEX)加载一个虚拟屏幕

加载一个贴图文件(*.TEX),并为其创建虚拟屏幕

参数:
filename贴图文件名称
check_mono自动将没有色彩的图片由RGB/RGBA转为Lum/LumAlpha
check_alpha自动清除alpha全部为0或全部为1的数据,将LumAlpha/RGBA转为Lum/RGB
VSBase * hgl::CreateVSFromPixelBuffer ( uint8 pixel_buffer,
int  width,
int  height,
ColorType  color 
)

关联象素缓冲区为虚拟屏幕

关联象素缓冲区为虚拟屏幕

参数:
pixel_buffer象素缓冲区
width象素缓冲区宽
height象素缓冲区高
color象素缓冲区色彩格式
Thread* hgl::CreateWinMessageThread ( )
cml::vector3f hgl::cross ( const cml::vector3f &  v1,
const cml::vector3f &  v2 
) [inline]
uint32 hgl::Decompress ( const WideString ca_name,
void *  compressdata,
uint32  size,
void *  out_data,
uint32  out_max 
)

解压缩数据

解压缩一个内存块的数据并存放到另一个内存块

参数:
ca_name压缩算法
compressdata压缩数据的存放位置
size压缩数据的长度
out_data解压缩后数据的存放位置
out_max解压缩数据存放区的大小
返回:
解压缩后的数据长度
参见:
CompressAlgorithm
Compress
uint32 __inline hgl::Decompress ( CA  ca,
void *  compressdata,
uint32  size,
void *  out_data,
uint32  out_max 
)

解压缩一个内存块的数据并存放到另一个内存块

参数:
ca压缩算法
compressdata压缩数据的存放位置
size压缩数据的长度
out_data解压缩后数据的存放位置
out_max解压缩数据存放区的大小
返回:
解压缩后的数据长度
参见:
CompressAlgorithm
Compress
typedef hgl::DefEvent ( bool  ,
TASK_UPDATE_FUNC  ,
(TaskManager *)   
)
void hgl::DeleteArrayBuffer ( GLuint  n)

删除一个缓冲区

bool hgl::DeletePath ( const wchar_t *  dirname)

删除一个路径

删除一个子目录

参数:
dirname目录名称
返回:
目录是否删除成功
void hgl::DeleteShader ( GLuint  index)

删除一个shader

void hgl::DeleteTexture ( Texture *  tex)

删除一张贴图

void hgl::DeleteTree ( const wchar_t *  dirname)

删除一个路径(包含所有文件)

删除一个子目录,包含所有文件和子目录

参数:
dirname目录名称
返回:
目录是否删除成功
hgl::DEVIL_VALUE ( DevilFloat  ,
float  ,
ttFloat  ,
wtof   
)
hgl::DEVIL_VALUE ( DevilDouble  ,
double  ,
ttDouble  ,
wtod   
)
hgl::DEVIL_VALUE ( DevilInteger  ,
int  ,
ttInt  ,
wtoi   
)
hgl::DEVIL_VALUE ( DevilUInteger  ,
uint  ,
ttUInt  ,
wtou   
)
hgl::DEVIL_VALUE ( DevilBool  ,
bool  ,
ttBool  ,
wtob   
)
hgl::DEVIL_VALUE ( DevilInt64  ,
int64  ,
ttInt64  ,
wtoi   
)
hgl::DEVIL_VALUE ( DevilUInt64  ,
uint64  ,
ttUInt64  ,
wtou   
)
float hgl::dot ( const cml::vector3f &  v1,
const cml::vector3f &  v2 
) [inline]
hgl::DRAW_ARRAY_DEF ( DrawArrayColor  ,
glColorPointer(dc_num, gl_format, 0, data+offset  
)
hgl::DRAW_ARRAY_DEF ( DrawArrayVertex  ,
glVertexPointer(dc_num, gl_format, 0, data+offset  
)
hgl::DRAW_ARRAY_DEF ( DrawArrayTexCoord  ,
glTexCoordPointer(dc_num, gl_format, 0, data+offset  
)
hgl::DRAW_ARRAY_DEF ( DrawArray2Color  ,
glSecondaryColorPointer(dc_num, gl_format, 0, data+offset  
)
hgl::DRAW_ARRAY_DEF ( DrawArrayFogCoord  ,
glFogCoordPointer(gl_format, 0, data+offset  
)
hgl::DRAW_ARRAY_DEF ( DrawArrayNormal  ,
glNormalPointer(gl_format, 0, data+offset  
)
hgl::DRAW_ARRAY_DEF ( DrawArrayIndex  ,
glIndexPointer(gl_format, 0, data+offset  
)
void __inline hgl::DrawBar ( const float  left,
const float  top,
const float  width,
const float  height 
)

画矩形块

参数:
left,top矩形左上角坐标
width,height矩形宽高
void __inline hgl::DrawBar ( const int  left,
const int  top,
const int  width,
const int  height 
)

画矩形块

参数:
left,top矩形左上角坐标
width,height矩形宽高
void __inline hgl::DrawLine ( const float  x1,
const float  y1,
const float  x2,
const float  y2 
)

画直线

参数:
x1,y1起始点坐标
x2,y2结束定坐标
void __inline hgl::DrawRectangle ( const float  left,
const float  top,
const float  width,
const float  height 
)

画空心矩形

参数:
left,top矩形左上角坐标
width,height矩形宽高
void __inline hgl::DrawZeroPoint ( const float  size = 0.5f)

绘制坐标系原点

hgl::enum_uint ( ColorType  )

色彩类型

这个枚举用来声明在程序中所使用到的色彩类型

<起始定义,无意义。如使用代表未知色彩

<亮度

<亮度与透明度

<RGB三原色

<RGB三原色与透明度

<Alpha透明度

<BGR三原色

<BGR三原色与透明度

<结束定义,无意义

hgl::enum_uint ( BlendModeEnum  )

混合模式枚举

混合模式

<无,起始定义,无意义

<一般模式

<仅原图

<仅目标图

<饱合相加

<饱合相减

<原图阴影

<光线图

<反色

<结束定义,无意义

hgl::enum_uint ( CompressAlgorithm  )

压缩算法

压缩算法枚举
注意:请在任何情况下都使用算法名称,而不是数值来保存压缩算法的类型。

<不压缩

<Bzip2算法

<Lzo算法

<Lzma算法

<Zip算法

<RLE算法

<RYC算法(图像专用)

<RSC算法(图像专用)

<Jpeg2000算法(图像专用)

<VSRLE算法(图像专用)

<结束定义,无意义

hgl::enum_uint ( ImageFormat  )
int hgl::EnumFile ( const wchar_t *  folder_name,
const wchar_t *  find_name,
void *  data,
bool  proc_folder,
bool  proc_file,
bool  sub_folder,
void(__cdecl *func)(void *, hgl::FileInfo &)   
)

枚举一个目录内的所有文件

参数:
folder_name目录名称
find_name查找用名称
data自定义回传数据
proc_folder处理目录
proc_file处理文件
sub_folder是否处理子目录
func回调函数
返回:
查找到文件数据,-1表示失败
int hgl::EnumFile ( const wchar_t *  folder_name,
const wchar_t *  find_name,
void *  data,
void(__cdecl *func)(void *, hgl::FileInfo &)   
)

枚举一个目录内的所有文件

参数:
folder_name目录名称
find_name查找用名称
data自定义回传数据
func回调函数
返回:
查找到文件数据,-1表示失败
int hgl::EnumVolume ( void *  data,
void(__cdecl *func)(void *, hgl::VolumeInfo &)  ,
bool  check_removable = false,
bool  check_remote = false,
bool  check_cd = false 
)

枚举当前计算机所有卷

参数:
data用户自定义回传信息
func回调函数
check_removable检测可移除设备
check_remote检测远程驱动器
check_cd检测光盘
返回:
查找到的卷数量,-1表示失败

枚举当前计算机所有卷

参数:
data用户自定义回传信息
func回调函数
check_cd检测光盘
返回:
查找到的卷数量,-1表示失败
bool __cdecl hgl::Eof ( Stream str)
uint32 hgl::FastRand ( void  )

快速产生一个随机数

uint32 __inline hgl::FastRand ( uint32  max_value)

产生一个随机数,并指定上限。

参数:
max_value上限值
返回:
随机值,<max_value
参数:
max_value快速产生一个随机数,并指定上限
int __inline hgl::FastRand ( int  v1,
int  v2,
int  p = 1 
)

在指定范围内产生一个随机值,并指定精度

参数:
v1最小值
v2最大值
p精度,默认为1
返回:
随机值
参数:
p快速产生一个随机数(指定范围,并指定精度)
double __inline hgl::FastRand ( double  v1,
double  v2,
double  p 
)

在指定范围内产生一个随机值,并指定精度

参数:
v1最小值
v2最大值
p精度
返回:
随机值
参数:
p快速产生一个随机数(指定范围,并指定精度)
void hgl::FastUnProject ( GLdouble  x,
GLdouble  y,
GLdouble nx,
GLdouble ny 
)

快速求一个2D坐标对应的3D坐标位置.要求必须的缺省矩阵,即左下角(-1,-1),右上角(1,1),中心为(0,0)

参数:
x,y原始2D坐标
nx,ny求出来的3D坐标
int hgl::FileCanRead ( const wchar_t *  filename)

检测文件是否可读

检测文件是否可读

参数:
filename文件名
返回:
1 可读
0 不可读
-1 出错
int hgl::FileCanWrite ( const wchar_t *  filename)

检测文件是否可写

检测文件是否可写

参数:
filename文件名
返回:
1 可写
0 不可写
-1 出错
bool hgl::FileCheckOpen ( const wchar_t *  filename)

尝试打开文件

测试这个文件是否可以打开

参数:
filename文件名
返回:
是否可以打开
bool hgl::FileCheckOpen ( const wchar_t *  pathname,
const wchar_t *  filename 
)

尝试打开文件

bool hgl::FileComp ( const wchar_t *  filename1,
const wchar_t *  filename2 
)

文件比较

比较两个文件是否一样

参数:
filename1第一个文件的名称
filename2第二个文件的名称
返回:
文件是否一样
bool hgl::FileConfirm ( const wchar_t *  filename)

文件确认是否存在

确认文件是否存在

参数:
filename要查找的文件名称
返回:
这个文件是否存在
bool hgl::FileCopy ( const wchar_t *  sourcename,
const wchar_t *  targetname 
)

文件复制

复制一个文件

参数:
sourcename源文件名
targetname目标文件名
返回:
文件是否复制成功
bool hgl::FileDelete ( const wchar_t *  filename)

文件删除

删除一个文件

参数:
filename文件名
返回:
文件是否成功删除
bool hgl::FileMove ( const wchar_t *  sourcename,
const wchar_t *  targetname 
)

文件移动

移动一个文件

参数:
sourcename源文件名
targetname目标文件名
返回:
文件是否移动成功
bool hgl::FileRename ( const wchar_t *  oldname,
const wchar_t *  newname 
)

文件改名

修改文件名

参数:
oldname旧的文件名
newname新的文件名
返回:
文件名是否修改成功
void hgl::FillBlock ( uchar dst,
uchar  value,
int  width,
int  height,
int  color,
int  stride 
)
void hgl::FillBlock ( uchar dst,
const uchar src,
int  width,
int  height,
int  color,
int  stride 
)
int hgl::find_argv ( int  argc,
wchar_t **  argv,
const wchar_t *  str 
)
void hgl::FlipBitmap ( uint8 tar,
uint8 src,
int  width,
int  height,
int  byte 
)

上下翻转位图数据

参数:
tar目标数据区
src原始数据区
width位图宽
height位图高
byte位图每象素字节数
WideString hgl::FloatToStr ( double  n) [inline]

转换浮点数到WideString

将一个浮点数转换成字符串

参数:
n要转换的数值
返回:
转换后的字符串
hgl::FONTCOMP ( SetWidth  ,
int  ,
width  ,
w   
)
hgl::FONTCOMP ( SetHeight  ,
int  ,
height  ,
h   
)
hgl::FONTCOMP ( SetBold  ,
bool  ,
bold  ,
b   
)
hgl::FONTCOMP ( SetItalic  ,
bool  ,
italic  ,
 
)
apr_pool_t * hgl::get_default_apr_pool ( )
int hgl::GetCanvasHeight ( )

取游戏画布高度

int hgl::GetCanvasWidth ( )

取游戏画布宽度

bool hgl::GetCMGDKPath ( wchar_t *  path,
unsigned long  s 
)
void hgl::GetCMGDKPath ( wchar_t *  path,
const wchar_t *  work,
const wchar_t *  start,
const wchar_t *  cm,
const wchar_t *  sub 
)
void hgl::GetCMGDKPath ( CMGDKPATH cp)
wchar_t * hgl::GetCurrentPath ( )

取得当前路径,结果请自行delete[]

取得当前所在目录

返回:
NULL 获取失败
当前目录,由new分配,请自行delete[]
bool hgl::GetDesktopDisplayMode ( int &  width,
int &  height,
int &  bit,
int &  vsync 
)

取得当前桌面显示模式

取得当前桌面显示模式

参数:
width
height
bit色彩位数
vsync垂直刷新率
返回:
是否成功
double hgl::GetDoubleTime ( )

取得当前时间(单位:秒)

取得当前时间(双精度)

返回:
当前时间(单位:秒)
bool hgl::GetExpendString ( const WideString &  flag,
WideString &  str 
)

取得特殊扩展字符串

bool hgl::GetFileInfo ( const wchar_t *  filename,
struct FileInfo &  fi 
)

取得文件信息

FontUnit * hgl::GetFont ( const wchar_t *  fontname,
int  w,
int  h,
bool  b,
bool  i 
)
FontUnit * hgl::GetFont ( Font &  fnt)
bool hgl::GetJotState ( JoyButton  )
bool hgl::GetJoyState ( JoyButton  key)

取得手柄按键状态

参数:
key按键
返回:
按键是否按下
uint32 hgl::GetKeyFlags ( uint32  wflags)
bool hgl::GetKeyState ( KeyButton  kb)
bool __cdecl hgl::GetLogPlugInInterface ( uint32  ver,
void *  data 
)
int hgl::getMax ( int  a,
int  b 
) [inline]
uint hgl::GetMaxMatrixBufferSize ( )

最得取大矩阵缓冲长度

uint64 hgl::GetMicroTime ( )

取得当前时间(单位:1/1000000秒)

取得当前时间

返回:
当前时间(单位:百万分之一秒)
int hgl::getMin ( int  a,
int  b 
) [inline]
void hgl::GetPixel ( int  x,
int  y,
uint8 rgb 
)
uint8 * hgl::GetScreenData ( int  ,
int  ,
int  ,
int  ,
ColorType  ,
bool  = false 
)
uint8 * hgl::GetScreenData ( int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
ColorType  ,
bool  = false 
)
int hgl::GetScreenHeight ( )

取得屏幕高度

int hgl::GetScreenWidth ( )

取得屏幕宽度

bool hgl::GetTempPath ( wchar_t *  path,
unsigned long  s 
)
uint64 hgl::GetTime ( )

取得当前时间(单位:1/1000秒)

取得当前时间

返回:
当前时间(单位:千分之一秒)
void __inline hgl::glColor ( float  r,
float  g,
float  b 
)

根据RGB设置颜色

void __inline hgl::glColor ( float  r,
float  g,
float  b,
float  a 
)

根据RGBA设置颜色

void __inline hgl::glColor ( const Color3f &  v)

根据RGB设置颜色

void __inline hgl::glColor ( const Color3f &  v,
float  a 
)

根据RGBA设置颜色

void __inline hgl::glColor ( const Color4f &  v)

根据RGBA设置颜色

void __inline hgl::glColor ( const Color4f &  v,
float  a 
)

根据RGBA设置颜色(alpha再乘上一个系数)

void __inline hgl::glColor ( float  lum,
float  a 
)

根据亮度设置颜色

void __inline hgl::glColor ( float  lum)

根据亮度设置颜色

void __inline hgl::glColor256 ( int  r,
int  g,
int  b 
)

根据RGB设置颜色(颜色范围值为0-255)

void __inline hgl::glColor256 ( int  r,
int  g,
int  b,
int  a 
)

根据RGBA设置颜色(颜色范围值为0-255)

void __inline hgl::glColor256 ( int  lum,
int  a 
)

根据亮度设置颜色

void __inline hgl::glColor256 ( int  lum)

根据亮度设置颜色

void hgl::glDrawArray ( const GLenum  mode,
const void *  vertex,
const void *  tex_coord,
const void *  color,
const void *  normal,
const uint  dc,
const uint  count 
)
void __inline hgl::glDrawArray ( const GLenum  mode,
const void *  vertex,
const void *  tex_coord,
const uint  dc,
const uint  count 
)
void __stdcall hgl::glMultiDrawArrays_Software ( GLenum  mode,
const GLint first,
const GLsizei count,
GLsizei  primcount 
)

glMultiDrawArrays函数在无硬件或驱动支持下的模拟实现

void __stdcall hgl::glMultiDrawElements_Software ( GLenum  mode,
const GLsizei count,
GLenum  type,
const GLvoid **  indices,
GLsizei  primcount 
)

glMultiDrawElements函数在无硬件或驱动支持下的模拟实现

void __inline hgl::glRect ( const RectScope2f &  rs)
void __inline hgl::glRectFullScreen ( )
void __inline hgl::glRectFullScreen ( const Color3f &  color)
void hgl::glRotate3f ( const float  x,
const float  y,
const float  z 
)

按指定值旋转

参数:
x,y,z旋转度数
void hgl::glRotate3fv ( const float *  vf)

按指定值旋转

参数:
vf旋转度数指针
void hgl::glScale3fv ( const float *  vf)

按指定数值缩放

参数:
x,y,z缩放值
void hgl::glTranslate3f ( const float  x,
const float  y,
const float  z 
)

按指定数值移动

参数:
x,y,z移动值
void hgl::glTranslate3fv ( const float *  vf)

按指定数值移动

参数:
vf移动数据指针
void __cdecl hgl::HacMappingEnumFile ( void *  fp,
hgl::FileInfo fi 
)
WideString hgl::HexToStr ( const uint8 data,
const int  bytes,
bool  upper 
)

转换一串数据到

template<typename T >
WideString hgl::HexToStr ( const T &  value,
bool  upper = true 
)
参数:
upper转换数值到16进制字符串
template<typename T >
T hgl::hgl_abs ( const T &  v)
double hgl::hgl_ang2rad ( const double  ang) [inline]
template<typename S , typename D >
void hgl::hgl_cpy ( D *  dst,
const S *  src,
const size_t  count 
) [inline]
template<typename T >
T hgl::hgl_max ( const T &  a,
const T &  b 
)
template<typename T >
T hgl::hgl_max ( const T *  data,
int  count,
max_value 
)
template<typename T >
T hgl::hgl_min ( const T &  a,
const T &  b 
)
template<typename T >
T hgl::hgl_min ( const T *  data,
int  count,
min_value 
)
double hgl::hgl_rad2ang ( const double  rad) [inline]
template<typename T >
void hgl::hgl_set ( T *  data,
const T &  value,
const size_t  count 
) [inline]
template<typename T >
void hgl::hgl_swap ( T &  x,
T &  y 
)
Matrix4f hgl::identity ( ) [inline]
uint32 __inline hgl::ImageCompress ( CA  ca,
void *  buffer,
uint32  buffer_size,
void *  data,
int  width,
int  height,
int  channels,
int  level 
)

解压缩一个图像数据

参数:
ca压缩算法
buffer压缩后的数据存放缓冲区
buffer_size缓冲区大小
data原始的图像数据
width图像宽
height图像高
channels图像通道数
level压缩级别(0:不压缩,9:最大压缩比)
返回:
压缩后的数据大小
uint32 hgl::ImageCompress ( const WideString ca_name,
void *  buffer,
uint32  buffer_size,
void *  data,
int  width,
int  height,
int  channels,
float  level 
)

压缩图像数据

解压缩一个图像数据

参数:
ca_name压缩算法
buffer压缩后的数据存放缓冲区
buffer_size缓冲区大小
data原始的图像数据
width图像宽
height图像高
channels图像通道数
level压缩级别(0:不压缩,1:最大压缩比)
返回:
压缩后的数据大小
uint32 hgl::ImageDecompress ( const WideString ca_name,
void *  data,
void *  buffer,
uint32  size,
int  width,
int  height,
int  channels 
)

解压缩图像数据

解压缩一个图像数据

参数:
ca_name压缩算法
data解压后的数据存放处
buffer压缩的数据指针
size压缩数据的长度
width图像宽
height图像高
channels图像通道数
返回:
解压缩后的数据大小
uint32 __inline hgl::ImageDecompress ( CA  ca,
void *  data,
void *  buffer,
uint32  size,
int  width,
int  height,
int  channels 
)

解压缩一个图像数据

参数:
ca压缩算法
data解压后的数据存放处
buffer压缩的数据指针
size压缩数据的长度
width图像宽
height图像高
channels图像通道数
返回:
解压缩后的数据大小
ImagePlugInInterface * hgl::ImageInterfaceCheck ( ImageFormat  ift)
ImagePlugInInterface* hgl::ImageInterfaceCheck ( const WideString &  )
void hgl::init_by_array ( uint32  init_key[],
int32  key_length 
)
void hgl::init_genrand ( uint32  s)
bool hgl::InitAudio ( const char *  device_name = 0)

初始化音频

void hgl::InitCondVarNT6 ( )
bool hgl::InitCore ( SystemInfo &  si,
bool  create_log 
)

初始化核心

bool hgl::InitCore ( SystemInfo si,
SystemInitInfo sii 
)
bool hgl::InitGraphics ( TCustomControl *  ctrl)

初始化图形模式,不显示

bool hgl::InitGraphics ( TCustomControl *  ctrl,
int  left,
int  top,
int  width,
int  height 
)

初始化图形模式

初始化图形模式 ctrl 绘图用控件指针 left,top,width,height 显示位置

返回:
是否初始化成功
void hgl::InitKeyConvert ( )
void hgl::InitMemoryPool ( )
void hgl::InitMessageProc ( GraphicsApplication app,
WinWindow win,
bool  joy 
)
bool hgl::InitOpenGL ( )
void hgl::InitPlugIn ( )

初始化插件管理

void hgl::InitRand ( )
void hgl::InitRWLockNT6 ( )
bool hgl::InitSystem ( bool  create_log = true,
bool  check_system = true 
)

初始化系统

void hgl::InitYUV2RGBDecode ( )
typedef hgl::int ( __cdecl *  ReadFunc)
hgl::int ( __stdcall *  hglSwapBuffers)
uint64 hgl::int128to64 ( int128  n) [inline]
void hgl::IntToSize ( WideString &  ws,
uint64  value 
)

该函数将一个计算资料容量值转换成字符串 依次使用B,K,M,G,T,P

WideString hgl::IntToStr ( int64  n) [inline]

转换整型数到WideString

将整型数转换成字符串

参数:
n要转换的数值
返回:
转换后的字符串
Matrix4f hgl::inverse ( const Matrix4f &  m) [inline]
template<typename T >
bool hgl::isdigit ( const T  ch)
bool hgl::IsDirectory ( const wchar_t *  name)

判断这个名称是否是目录

判断当前名称是否是一个目录

参数:
name名称
void hgl::itow ( int128  n,
wchar_t *  Str 
)
void __cdecl hgl::JoyDown ( uint  key)
void __cdecl hgl::JoyPress ( uint  key)
void __cdecl hgl::JoyUp ( uint  key)
void hgl::L2LA ( uint8 tar,
uint8 src,
uint8 tcolor,
uint32  size 
)
double hgl::Lcos ( int  angle)
float hgl::length ( const cml::vector2f &  v1,
const cml::vector2f &  v2 
) [inline]
float hgl::length ( const cml::vector3f &  v1,
const cml::vector3f &  v2 
) [inline]
float hgl::length_squared ( const cml::vector2f &  v1,
const cml::vector2f &  v2 
) [inline]
float hgl::length_squared ( const cml::vector3f &  v1,
const cml::vector3f &  v2 
) [inline]
double hgl::LoadAudioData ( int  index,
AudioFileType  aft,
void *  memory,
int  memory_size 
)
bool hgl::LoadCubeTexture ( TDFNode *  tdf,
Texture2D *  tex[6] 
)

从TDF节点中加载一个Cube贴图

加载一个Cube贴图,里面包含了六张贴图

参数:
tdfTDF节点
tex贴图存放处
返回:
是否加载成功
bool hgl::LoadCubeTexture ( Stream *  stream,
Texture2D *  tex[6] 
)

从流中加载一个Cube贴图

加载一个Cube贴图,里面包含了六张贴图

参数:
stream
tex贴图存放处
返回:
是否加载成功
bool hgl::LoadCubeTexture ( const wchar_t *  filename,
Texture2D *  tex[6] 
)

加载一个Cube贴图文件

加载一个Cube贴图,里面包含了六张贴图

参数:
filename文件名
tex贴图存放处
返回:
是否加载成功
bool hgl::LoadCubeTexture ( HAC *  hac,
const wchar_t *  filename,
Texture2D *  tex[6] 
)

加载一个Cube贴图文件

加载一个Cube贴图,里面包含了六张贴图

参数:
hac存放贴图的HAC包
filename文件名
tex贴图存放处
返回:
是否加载成功
void* hgl::LoadFileToMemory ( const wchar_t *  filename,
uint  offset,
uint  length,
void *  buf 
)

读取文件的一部分到内存

参数:
filename文件名
offset起始地址
length读取长度
buf数据存放地址,为NULL表示要求函数分配
返回:
NULL 读取失败
读取出来的数据存放的地址
int64 hgl::LoadFileToMemory ( const wchar_t *  filename,
void **  buf 
)

加载一个文件到内存

加载一个文件到内存,文件数据请自己delete[]掉

参数:
filename要载入的文件名称
buf用来保存数据的内存指针的指针
返回:
文件长度
void* hgl::LoadFileToMemory ( const wchar_t *  ,
unsigned  int,
unsigned  int,
void *  buf = 0 
)

加载一个文件的一部分到内存

void * hgl::LoadHGP ( TDFNode *  tdf,
uint glformat,
int &  width,
int &  height,
int8 ct 
)
void * hgl::LoadHGP ( Stream *  str,
uint glformat,
int &  width,
int &  height,
int8 ct 
)
void * hgl::LoadHGP ( const wchar_t *  filename,
uint glformat,
int &  width,
int &  height,
int8 ct 
)
void * hgl::LoadHGP ( HAC *  hac,
const wchar_t *  filename,
uint glformat,
int &  width,
int &  height,
int8 ct 
)
bool __cdecl hgl::LoadInterface ( const wchar_t *  name,
int  ver,
void *  data 
)
void* __cdecl hgl::LoadInterface ( const wchar_t *  ,
int   
)

加载一个插件,并取得指定接口

bool hgl::LoadInterfaceByIndex ( int  index,
int  ver,
void *  data 
)
bool hgl::LoadInterfaceByName ( const wchar_t *  name,
int  ver,
void *  data 
)
void hgl::LoadJoystick ( HINSTANCE  hInstance,
HWND  hWnd 
)
void hgl::LoadMatrix ( GLenum  matrix,
float *  mm 
)

加载矩阵

加载矩阵

参数:
matrix矩阵(只能是GL_PROJECTION、GL_MODELVIEW、GL_TEXTURE)
mm矩阵数据
bool hgl::LoadMatrixStack ( void *  ,
uint   
)
void * hgl::LoadMonoLayer ( const wchar_t *  filename,
uint format,
int &  width,
int &  height,
ColorType &  ct 
)
void * hgl::LoadMonoLayer ( const wchar_t *  filename,
uint format,
int width,
int height,
ColorType &  color,
bool  check_mono,
bool  check_alpha 
)
void * hgl::LoadOtherFormat ( const wchar_t *  filename,
uint format,
int width,
int height,
ColorType &  ct,
bool  check_mono,
bool  check_alpha,
ImageFormat  pi_index 
)
PlugIn *__cdecl hgl::LoadPlugIn ( const wchar_t *  plugin_name,
PlugInType  type 
)

加载一个插件

加载一个插件

参数:
plugin_name插件名称
type特殊插件类型
返回:
返回模块指针,返回NULL表示失败
void * hgl::LoadTexture ( TDFNode *  ,
uint ,
int &  ,
int &  ,
ColorType &   
)

从TDF加载一个贴图文件,并取得原始数据

从TDF节点加载一个贴图文件数据

参数:
tdfTDF节点
format这个贴图文件推荐使用的OpenGL象素格式
width这个贴图文件的宽度
height这个贴图文件的高度
color这个贴图文件的色彩格式
返回:
这个贴图的象素数据缓冲区,注:请自行delete[]掉
参见:
ColorType
void * hgl::LoadTexture ( Stream *  ,
uint ,
int &  ,
int &  ,
ColorType &   
)

从流加载一个贴图文件,并取得原始数据

从流加载一个贴图文件

参数:
str要加载的贴图文件的流
format这个贴图文件推荐使用的OpenGL象素格式
width这个贴图文件的宽度
height这个贴图文件的高度
ct这个贴图文件的色彩格式
返回:
这个贴图的象素数据缓冲区,注:请自行delete[]掉
参见:
ColorType
void * hgl::LoadTexture ( const wchar_t *  ,
uint ,
int &  ,
int &  ,
ColorType &   
)

加载一个贴图文件,并取得原始数据

加载一个贴图文件

参数:
filename要加载的贴图文件名称
format这个贴图文件推荐使用的OpenGL象素格式
width这个贴图文件的宽度
height这个贴图文件的高度
ct这个贴图文件的色彩格式
返回:
这个贴图的象素数据缓冲区,注:请自行delete[]掉
参见:
ColorType
void * hgl::LoadTexture ( HAC *  ,
const wchar_t *  ,
uint ,
int &  ,
int &  ,
ColorType &   
)

加载一个贴图文件,并取得原始数据

加载一个贴图文件

参数:
hac贴图文件所在的HAC包
filename要加载的贴图文件名称
format这个贴图文件推荐使用的OpenGL象素格式
width这个贴图文件的宽度
height这个贴图文件的高度
color这个贴图文件的色彩格式
返回:
这个贴图的象素数据缓冲区,注:请自行delete[]掉
参见:
ColorType
int64 hgl::LoadTxtToMemory ( Stream *  str,
const int64  str_length,
wchar_t **  buf,
int  ccp 
)

加载文本文件到内存

加载一个文本到内存

参数:
str文本流
file_length流长度字节数
buf读取出的文本存放缓冲区
ccp如果为ansi,将使用的转换代码页
返回:
文本长度字符数
int64 hgl::LoadTxtToMemory ( const wchar_t *  filename,
wchar_t **  buf,
int  ccp 
)

加载文本文件到内存

加载一个文本文件到内存

参数:
filename文件名
buf文本缓冲区
ccp如果为ansi,将使用的转换代码页
返回:
文本长度
Matrix4f hgl::lookAt ( const cml::vector3f &  eye,
const cml::vector3f &  target,
const cml::vector3f &  up 
) [inline]
template<typename T >
void hgl::LowerString ( T *  SourceString)

将一个字符串中的字母全部改为小写

参数:
SourceString要处理的字符串
template<typename T >
void hgl::LowerString ( const T *  SourceString,
T *  TargetString 
)

将一个字符串中的字母全部改为小写

参数:
SourceString要处理的字符串
double hgl::Lsin ( int  angle)
bool hgl::MakePath ( const wchar_t *  dirname)

创建一个路径

创建一个子目录,该函数可自动创建多级目录。

参数:
dirname目录名称
返回:
目录是否创建成功
int hgl::mClamp ( int  val,
int  low,
int  high 
) [inline]
void hgl::MergeChannels ( uint8 out,
uint8 in,
int  size,
int  number 
)
wchar_t * hgl::MergeFilename ( const wchar_t *  pathname,
const wchar_t *  filename 
)

组合路径名与文件名

组合路径名与文件名,自动检测\

参数:
pathname路径名
filename文件名
返回:
组合好的字符串,注意需要手动delete[]
bool hgl::MergeFilename ( wchar_t *  full_name,
int  size,
const wchar_t *  pathname,
const wchar_t *  filename 
)

组合路径名与文件名

组合路径名与文件名,自动检测\

参数:
full_name完整路径文件名称存放空间指针
size存放空间长度
pathname路径名
filename文件名
返回:
是否组合成功
bool hgl::MessageProc ( WinWindow win)
CA hgl::NameToCA ( const WideString name)

名称到压缩算法枚举转换

cml::vector3f hgl::normalize ( const cml::vector3f &  v) [inline]
void hgl::OnMovieCreate ( void *  movie,
int  width,
int  height,
int  color,
int  pitch 
)
void hgl::OnMovieDecodeFrame ( void *  movie,
uchar data 
)
void hgl::OpenAlphaTest ( const GLenum  func,
const float  ref 
)
void hgl::OpenBlend ( BlendModeEnum  bme)

开启混合效果

void hgl::OpenBlend ( GLuint  sfactor,
GLuint  dfactor 
)

开启混合效果

void hgl::OpenClientState ( GraphicsClientState  gcs)

开启OpenGL客户端状态

void hgl::OpenColorMaterial ( GLenum  face,
GLenum  mode 
)
void hgl::OpenCullFace ( GLuint  mode)

开启面裁剪

void hgl::OpenDepthMask ( )
void hgl::OpenDepthTest ( )

开启深度测试

__inline FileStream* hgl::OpenFileStream ( const wchar_t *  filename,
FileOpenMode  mode = fomOpenRead 
)
HAC * hgl::OpenHAC ( const wchar_t *  filename)

打开一个.HAC文件,或是根据路径创建一个虚拟的HAC环境

打开一个.Hac文件或是指定一个目录,创建并返回一个HAC3包裹文件支持类。请注意它支持HAC-3的.HAC文件,并不支持HAC-2的HAC文件

参数:
filename包裹文件名称或是目录名称
返回:
HAC3包裹文件支持类,返回NULL表示失败
void hgl::OpenLineSmooth ( )

开启线条平滑

void hgl::OpenScissor ( const int *  v)

更改当前裁剪

void hgl::OpenScissor ( const int  left,
const int  top,
const int  width,
const int  height 
)

更改当前裁剪

void hgl::OpenTexture ( TextureType  type)

开启贴图渲染

void hgl::OpenTextureGen ( GLenum  coord,
GLenum  pname,
GLint  param 
)
hgl::OPER_OVER ( DevilCompGreater  )
hgl::oper_over ( char *  )
hgl::OPER_OVER ( DevilCompEqu  )
hgl::OPER_OVER ( DevilCompLessEqu  ,
<=   
)
hgl::OPER_OVER ( DevilCompLess  )
hgl::oper_over ( int  )
hgl::OPER_OVER ( DevilCompGreaterEqu  ,
>=   
)
hgl::oper_over ( uint64  )
hgl::oper_over ( wchar_t *  )
hgl::OPER_OVER ( DevilCompNotEqu  ,
 
)
hgl::oper_over ( uint  )
hgl::oper_over ( int64  )
hgl::oper_over ( double  )
hgl::oper_over ( char  )
hgl::oper_over ( wchar_t  )
bool hgl::operator!= ( int128  n1,
int128  n2 
)
int128 hgl::operator% ( int128  n1,
int128  n2 
)
int128 hgl::operator& ( int128  n1,
int128  n2 
)
int128 hgl::operator* ( int128  n1,
int128  n2 
)
int128 hgl::operator*= ( int128 &  n1,
int128  n2 
)
int128 hgl::operator+ ( int128  n1,
int128  n2 
)
int128 hgl::operator+= ( int128 &  n1,
int128  n2 
)
int128 hgl::operator- ( int128  n1,
int128  n2 
)
int128 hgl::operator-= ( int128 &  n1,
int128  n2 
)
int128 hgl::operator/ ( int128  n1,
int128  n2 
)
int128 hgl::operator/= ( int128 &  n1,
int128  n2 
)
bool hgl::operator< ( int128  n1,
int128  n2 
)
bool hgl::operator<= ( int128  n1,
int128  n2 
)
bool hgl::operator== ( int128  n1,
int128  n2 
)
bool hgl::operator> ( int128  n1,
int128  n2 
)
bool hgl::operator>= ( int128  n1,
int128  n2 
)
int128 hgl::operator| ( int128  n1,
int128  n2 
)
Matrix4f hgl::ortho2 ( float  width,
float  height,
float  znear = 0,
float  zfar = 1 
) [inline]
Matrix4f hgl::ortho4 ( float  left,
float  right,
float  bottom,
float  top,
float  znear = 0,
float  zfar = 1 
) [inline]
void hgl::OverflowDecrypt ( void *  target,
void *  source,
int  size,
void *  key,
int  key_size 
)

溢出解密

参数:
target解密后的数据存放区
source解密前的数据存放区
size数据长度
key密码
keysize密码长度
void hgl::OverflowEncrypt ( void *  target,
void *  source,
int  size,
void *  key,
int  key_size 
)

溢出加密

参数:
target加密后的数据存放区
source加密前的数据存放区
size数据长度
key密码
key_size密码长度
int hgl::ParseAnsi ( wchar_t **  buf,
uchar raw_str,
int  byte_size,
CCP  ccp 
)
template<typename T >
int hgl::ParseUTF ( wchar_t **  buf,
void *  raw_str,
int  byte_size,
bool  is_little_endian 
)
int hgl::ParseUTF8 ( wchar_t **  wide_str,
const uchar utf8_str,
int  size 
)
Matrix4f hgl::perspective ( float  fovy,
float  aspect,
float  znear,
float  zfar 
) [inline]
void hgl::PicZoom_Bilinear_Common ( const TPicRegion &  Dst,
const TPicRegion &  Src 
)
TARGB32& hgl::Pixels ( const TPicRegion &  pic,
const long  x,
const long  y 
) [inline]
TARGB32 hgl::Pixels_Bound ( const TPicRegion &  pic,
long  x,
long  y 
) [inline]
hgl::PlugInManage ( Audio  ,
L"Audio"  ,
 
)
hgl::PlugInManage ( Compress  ,
L"Compress"  ,
 
)
hgl::PlugInManage ( Image  ,
L"Image"  ,
 
)
void hgl::PopMatrix ( GLenum  matrix)

弹出指定矩阵

弹出指定矩阵

参数:
matrix矩阵(只能是GL_PROJECTION、GL_MODELVIEW、GL_TEXTURE)
int hgl::power_to_2 ( int  value) [inline]
int hgl::PowerTo2 ( int  old,
int  max_value 
)

计算能适应当前数的一个符合2次幂的值,并且不能超过某个值

参数:
old原本的数
返回:
符合2次幂的数
int hgl::PowerTo2 ( int  old)

计算能适应当前数的一个符合2次幂的值

参数:
old原本的数
返回:
符合2次幂的数
hgl::PROC ( Proc_MouseMidDoubleClick  )
hgl::PROC ( Proc_JoystickDown  )
hgl::PROC ( Proc_MouseMove  )
hgl::PROC ( Proc_MouseLeftDown  )
hgl::PROC ( Proc_MouseLeftDoubleClick  )
hgl::PROC ( Proc_MouseMidUp  )
hgl::PROC ( Proc_MouseRightDown  )
hgl::PROC ( Proc_MouseRightUp  )
hgl::PROC ( Proc_MouseRightDoubleClick  )
hgl::PROC ( Proc_JoystickPress  )
hgl::PROC ( Proc_KeyDown  )
hgl::PROC ( Proc_MouseMidDown  )
hgl::PROC ( Proc_KeyUp  )
hgl::PROC ( Proc_KeyPress  )
hgl::PROC ( Proc_MouseLeftUp  )
hgl::PROC ( Proc_JoystickUp  )
hgl::ProcFunc ( Proc_MouseMidUp  )
hgl::PROCFUNC ( MidDown  )
hgl::PROCFUNC ( MidUp  )
hgl::PROCFUNC ( LeftDoubleClick  )
hgl::PROCFUNC ( Char  ,
wchar_t   
)
hgl::PROCFUNC ( MidDoubleClick  )
hgl::ProcFunc ( Proc_MouseRightUp  )
hgl::PROCFUNC ( Proc_MouseRightDoubleClick  ,
OnMouseRightDoubleClick   
)
hgl::PROCFUNC ( RightUp  )
hgl::PROCFUNC ( RightDown  )
hgl::PROCFUNC ( JoystickPress  ,
uint   
)
hgl::PROCFUNC ( Proc_JoystickDown  ,
uint   
)
hgl::PROCFUNC ( Proc_MouseMidDoubleClick  ,
OnMouseMidDoubleClick   
)
hgl::PROCFUNC ( Proc_MouseMidDown  ,
OnMouseMidDown   
)
hgl::PROCFUNC ( Proc_JoystickPress  ,
uint   
)
hgl::PROCFUNC ( Proc_KeyUp  ,
uint   
)
hgl::PROCFUNC ( LeftDown  )
hgl::PROCFUNC ( JoystickUp  ,
uint   
)
hgl::PROCFUNC ( Proc_MouseLeftUp  ,
OnMouseLeftUp   
)
hgl::PROCFUNC ( LeftUp  )
hgl::PROCFUNC ( Proc_MouseLeftDoubleClick  ,
OnMouseLeftDoubleClick   
)
hgl::PROCFUNC ( RightDoubleClick  )
hgl::ProcFunc ( Proc_MouseLeftUp  )
hgl::PROCFUNC ( KeyDown  ,
uint   
)
hgl::PROCFUNC ( KeyPress  ,
uint   
)
hgl::PROCFUNC ( KeyUp  ,
uint   
)
hgl::PROCFUNC ( Proc_MouseMove  ,
OnMouseMove   
)
hgl::PROCFUNC ( Proc_MouseRightDown  ,
OnMouseRightDown   
)
hgl::PROCFUNC ( Proc_MouseRightUp  ,
OnMouseRightUp   
)
hgl::PROCFUNC ( Proc_MouseMidUp  ,
OnMouseMidUp   
)
hgl::PROCFUNC ( Proc_JoystickUp  ,
uint   
)
hgl::PROCFUNC ( Proc_KeyDown  ,
uint   
)
hgl::PROCFUNC ( Proc_KeyPress  ,
uint   
)
hgl::PROCFUNC ( Proc_Char  ,
wchar_t   
)
hgl::ProcFunc ( Proc_MouseLeftDoubleClick  )
hgl::ProcFunc ( Proc_MouseMidDoubleClick  )
hgl::ProcFunc ( Proc_MouseRightDoubleClick  )
hgl::PROCFUNC ( Proc_MouseLeftDown  ,
OnMouseLeftDown   
)
int hgl::ProcSize ( int  size,
int  min 
)
hgl::ProcTopFunc ( Proc_MouseRightDown  )
hgl::ProcTopFunc ( Proc_MouseMidDown  )
void hgl::PushMatrix ( GLenum  matrix)

压入矩阵堆栈

压入指定矩阵

参数:
matrix矩阵(只能是GL_PROJECTION、GL_MODELVIEW、GL_TEXTURE)
void hgl::PutATIInteger ( uint  gpu_id,
uint  info_id,
const wchar_t *  fmt 
)
void hgl::PutATIMemoryInfo ( uint  value,
const wchar_t *  name 
)
void hgl::PutATIString ( uint  gpu_id,
uint  info_id,
const wchar_t *  fmt 
)
void hgl::PutDisplayDevicesInfo ( )
void hgl::PutOpenExtInfo ( const char *  str,
const char *  flag 
)
void hgl::PutOpenGLFloatRange ( const wchar_t *  name,
const uint  flag 
)
void hgl::PutOpenGLFloatValue ( const wchar_t *  name,
const uint  flag 
)
void hgl::PutOpenGLInfo ( HDC  )
void hgl::PutOpenGLInfo ( const char *  os_ext_info,
const char *  os_ext_name 
)
void hgl::PutOpenGLIntegerValue ( const wchar_t *  name,
const uint  flag 
)
void hgl::PutOpenGLRGBAValue ( const wchar_t *  name,
const uint  flag 
)
void hgl::PutOpenGLStringValue ( const char *  name,
const char *  str 
)
void hgl::PutOpenGLStringValue ( const char *  name,
const uint  flag 
)
void hgl::PutSystemInfo ( SystemInfo *  )
void hgl::RC4Encrypt ( uint8 data,
int  datasize,
uint8 key,
int  keysize 
)

RC4算法加密函数

参数:
data数据
datasize数据长度
key密码
keysize密码长度(字节)
int __cdecl hgl::Read ( Stream str,
void *  buf,
int  size 
)
hgl::READFUNC ( ReadInt64  ,
int64   
)
hgl::READFUNC ( ReadUint16  ,
uint16   
)
hgl::READFUNC ( ReadUint64  ,
uint64   
)
hgl::READFUNC ( ReadDouble  ,
double   
)
hgl::READFUNC ( ReadUint8  ,
uint8   
)
hgl::READFUNC ( ReadInt16  ,
int16   
)
hgl::READFUNC ( ReadBool  ,
bool   
)
hgl::READFUNC ( ReadInt8  ,
int8   
)
hgl::READFUNC ( ReadInt32  ,
int32   
)
hgl::READFUNC ( ReadUint32  ,
uint32   
)
hgl::READFUNC ( ReadFloat  ,
float   
)
hgl::READFUNC ( ReadString  ,
WideString   
)
void hgl::RedrawScreen ( )

刷新整个屏幕

void hgl::RegistryPIMClear ( void(*)()  func)
void hgl::ReleaseFont ( FontUnit *  fu)
template<typename T >
void hgl::ReplaceChar ( T *  string,
const T  sch,
const T  tch 
)

将一个字符串中的某个字符全部替换为另一个字符

参数:
string要处理的字符串
sch要被替换掉的字符
tch替换后的字符
template<typename T >
void hgl::ReplaceExtName ( const T *  old_filename,
T *  new_filename,
const T *  new_extname 
)

给一个文件名更改扩展名

参数:
old_filename原始文件名称
new_filename新文件名称
new_extname新扩展名(不带.)
template<typename T >
void hgl::ReplaceExtName ( T *  filename,
const T *  new_extname 
)

给一个文件名更改扩展名

参数:
filename文件名称
new_extname新扩展名(不带.)
bool hgl::RestartDisplayMode ( )
void hgl::RestartOpenGL ( )

重置渲染控制器

重置OpenGL渲染器状态

void hgl::RGB2RGBA ( uint8 tar,
uint8 src,
uint8 tcolor,
uint32  size 
)
uint8 * hgl::RGB2YUV ( uint8 rgb,
int  w,
int  h 
)
void hgl::RGB_A2RGBA ( uint8 rgba,
uint8 rgb,
uint8 a,
uint32  size 
)
void hgl::RGBA2RGB ( uint8 rgba,
uint8 rgb,
uint32  size 
)
void hgl::RGBA2RGB_A ( uint8 rgba,
uint8 rgb,
uint8 a,
uint32  size 
)
uint hgl::RleCompress ( uint8 dst,
uint  dst_max,
uint8 src,
uint  src_length 
)

RLE压缩

参数:
dst压缩后数据的存放缓冲区
dst_max存放缓冲区大小
src原始数据
src_length原始数据长度
uint hgl::RleDecompress ( uint8 dst,
uint  dst_max,
uint8 src,
uint  src_length 
)

RLE解压

参数:
dst解压后数据的存放缓冲区
dst_max存放缓冲区大小
dst_pitch解压后时每位数据的间隔
src原始数据
src_length原始数据长度
Matrix4f hgl::rotate ( float  angle,
const cml::vector4f &  axis 
) [inline]
Matrix4f hgl::rotate ( float  angle,
const cml::vector3f &  axis 
) [inline]
Matrix4f hgl::rotate ( float  angle,
float  x,
float  y,
float  z 
) [inline]
bool hgl::SaveBitmapToFile ( const wchar_t *  filename,
int  width,
int  height,
int  color,
void *  data 
)
bool hgl::SaveBitmapToHGP ( const wchar_t *  ,
int  ,
int  ,
ColorType  ,
void *  ,
const wchar_t *  ca = L"RLE",
float  = 1 
)

保存一个位图数据成HGP文件

bool hgl::SaveBitmapToTEX ( const wchar_t *  ,
int  ,
int  ,
ColorType  ,
void *  ,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

保存一个位图数据成TEX文件

保存一个位图数据为贴图文件

参数:
filename文件名
width图像宽
height图像高
color色彩类型
data数据
返回:
是否成功
uint hgl::SaveMatrixStack ( void *  )
bool hgl::SaveMemoryToFile ( const wchar_t *  ,
unsigned  int,
unsigned  int,
void *   
)

保存一块内存到一个文件

int64 hgl::SaveMemoryToFile ( const wchar_t *  filename,
void *  buf,
int64  size 
)

保存一块内存成文件

保存一块内存成文件

参数:
filename要保存的文件名称
buf要保存的内存指针
size要保存的内存数据长度
返回:
成功写入的字节数
-1 失败
bool hgl::SaveMemoryToFile ( const wchar_t *  filename,
int  offset,
int  length,
void *  data 
)

保存内存中的数据到文件中

参数:
filename文件名
offset起始地址
length数据长度
data数据长度
返回:
是否成功
bool hgl::SaveScreenToBMP ( const wchar_t *  filename,
int  width,
int  height 
)

截取当前屏幕图像保存成BMP文件

参数:
filename文件名,如不输入表示自动产生文件名(于 启动目录 目录下)
返回:
保存是否成功
bool hgl::SaveScreenToHGP ( const wchar_t *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
const wchar_t *  ca = L"RLE",
float  = 1 
)

保存当前屏幕图像成HGP文件

将当前屏幕内容保存成HGP文件

参数:
filename文件名称
img_width,img_height最终图像文件大小
left截取屏幕左边际坐标
top截取屏幕上边际坐标
width,height截取屏幕的宽,高
ca压缩算法
level压缩级别(0:最小压缩,1:最大压缩)
bool hgl::SaveScreenToHGP ( const wchar_t *  ,
int  ,
int  ,
int  ,
int  ,
const wchar_t *  ca = L"RLE",
float  = 1 
)

保存当前屏幕图像成HGP文件

将当前屏幕内容保存成HGP文件

参数:
filename文件名称
left截取屏幕左边际坐标
top截取屏幕上边际坐标
width,height截取屏幕的宽,高
ca压缩算法
level压缩级别(0:最小压缩,1:最大压缩)
bool hgl::SaveScreenToTEX ( const wchar_t *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

保存当前屏幕图像成TEX文件

将当前屏幕内容保存成TEX文件

参数:
filename文件名称
img_width,img_height最终图像文件大小
left截取屏幕左边际坐标
top截取屏幕上边际坐标
width,height截取屏幕的宽,高
bool hgl::SaveScreenToTEX ( const wchar_t *  ,
int  ,
int  ,
int  ,
int  ,
const wchar_t *  ca = L"RLE",
float  rate = 1 
)

保存当前屏幕图像成TEX文件

将当前屏幕内容保存成TEX文件

参数:
filename文件名称
left截取屏幕左边际坐标
top截取屏幕上边际坐标
width,height截取屏幕的宽,高
bool hgl::SaveScreenToTGA ( const wchar_t *  filename,
int  width,
int  height 
)

截取当前屏幕图像保存成TGA文件

参数:
filename文件名,如不输入表示自动产生文件名(于 启动目录 目录下)
返回:
保存是否成功
Matrix4f hgl::scale ( const cml::vector3f &  v) [inline]
Matrix4f hgl::scale ( float  s) [inline]
Matrix4f hgl::scale ( float  x,
float  y,
float  z 
) [inline]
void hgl::ScaleImage ( void *  old_data,
int  old_width,
int  old_height,
void *  new_data,
int  new_width,
int  new_height,
ColorType  color 
)

缩放一个图像

参数:
old_data原始数据
old_width,old_height原始图像大小
new_data新数据
new_width,new_height新图像大小
color色彩类型
void __cdecl hgl::Seek ( Stream str,
int  pos 
)
void hgl::Set3DOrigin ( GLdouble  x,
GLdouble  y 
)

设置当前矩阵3D原点在屏幕上的2D坐标位置,本函数仅移动x,y坐标.
要求当前已为3D矩阵,并且原点在中心

参数:
x,y原点在屏幕上的2D坐标
void hgl::SetCanvas ( int  w,
int  h 
)

设置画布大小

void hgl::SetClearSimplePixel ( bool  csp)

设置色差容差

bool hgl::SetDisplayMode ( int  width,
int  height,
int  bit,
int  vsync 
)
void hgl::SetExpendString ( const WideString &  flag,
const WideString &  str 
)

设置特殊扩展字符串

void hgl::SetLineStipple ( GLuint  factor,
GLushort  pattern 
)

设置点划线

void hgl::SetLineWidth ( GLfloat  width)

设置线宽

void hgl::SetMatrix ( GLenum  matrix)

设置矩阵堆栈

设定当前矩阵

参数:
matrix矩阵(只能是GL_PROJECTION、GL_MODELVIEW、GL_TEXTURE)
void hgl::SetPixelStore ( GLenum  p,
int  v 
)
void hgl::SetPlugIn ( PlugIn pi,
PlugInType  type 
)

设置一个插件

设置插件

参数:
pi插件指针
type插件类型
void hgl::SetSameColor ( int  sc)
void hgl::SetScreen ( int  w,
int  h 
)

设置屏幕大小

void hgl::SetScreenValue ( int  ,
int   
)
template<typename T >
bool hgl::Sort ( List< T > &  list,
Comparator< T > *  comp = Comparator<T>() 
)
template<typename T >
bool hgl::Sort ( T *  data,
int  count,
Comparator< T > *  comp = new Comparator<T>() 
)
int hgl::SplitPowerTo2 ( int  size,
int *  val,
int  min 
)

拆分一个数到一组符合2次幂的数

参数:
size原本的数
val拆分后的数组指针
min拆分的最小值,默认为4(不足4的按4算)
返回:
拆分后的数数量
void hgl::SplitToChannels ( uint8 out,
uint8 in,
int  size,
int  number 
)
template<typename T >
void hgl::SplitToStringList ( StringList *  sl,
T *  data,
int  size 
)
template<typename T >
int hgl::StatChar ( const T *  str,
const T  ch 
)

统计在字符串中某个字符的出现次数

参数:
str字符串
ch
返回:
出现次数
template<typename T >
int hgl::StatLine ( const T *  str)

统计一个字符串的行数

template<typename T >
void hgl::strcat ( T *  dst,
const T  src 
)

复制一个字符到当前字符串后面

参数:
dst目标字符串
src源字符
template<typename T >
void hgl::strcat ( T *  dst,
const T *  src,
int  count 
)

复制一个字符串到当前字符串后面,并指定最大长度

template<typename T >
void hgl::strcat ( T *  dst,
const T *  src 
)

复制一个字符串到当前字符串后面

参数:
dst目标字符串
src源字符串
template<typename T >
T* hgl::strchr ( const T *  str,
const T  ch 
)

在字符串中查找某个字符

参数:
str字符串
ch字符
返回:
查找到的位置指针
template<typename T >
T* hgl::strchr ( const T *  str,
const T  ch,
int  n 
)

在字符串中查找某个字符,指定字符串最大长度

参数:
str字符串
ch字符
n字符串长度
返回:
查找到的位置指针
template<typename T >
int hgl::strcmp ( const T *  src,
const T *  dst 
)

比较两个字符串的大小

参数:
src,dst要比较的字符串
返回:
-1 src < dst
0 src == dst
+1 src > dst
template<typename T >
int hgl::strcmp ( const T *  src,
const T *  dst,
int  count 
)

比较两个字符串的大小,并指定最大比较长度

参数:
src,dst要比较的字符串
count比较的最大长度
返回:
-1 src < dst
0 src == dst
+1 src > dst
template<typename T >
void hgl::strcpy ( T *  dst,
const T *  src 
)

复制字符串

参数:
dst目标字符串
src源字符串
template<typename T >
void hgl::strcpy ( T *  dst,
int  count,
const T *  src 
)

复制字符串,并指定最大长度

参数:
dst目标字符串
src源字符串
count最多复制多少个字符
template<typename T >
void hgl::strcpy ( T *  dst,
const T *  src,
int  count 
)

复制字符串,并指定最大长度

参数:
dst目标字符串
src源字符串
count最多复制多少个字符
template<typename T >
int hgl::stricmp ( const T *  src,
const T *  dst,
const int  count 
)

比较两个字符串的大小(英文不区大小写)

参数:
src,dst要比较的字符串
count比较的最大长度
返回:
-1 src < dst
0 src == dst
+1 src > dst
template<typename T >
int hgl::stricmp ( const T *  src,
const T *  dst 
)

比较两个字符串的大小(英文不区大小写)

参数:
src,dst要比较的字符串
返回:
-1 src < dst
0 src == dst
+1 src > dst
template<typename T >
int hgl::strlen ( const T *  str)

对宽字符串计算字串长度

参数:
str要计算长度的字符串指针
返回:
字符串长度
template<typename T >
T* hgl::strrchr ( const T *  str,
const T  ch 
)

在字符串中从结尾处开始查找某个字符

参数:
str字符串
ch字符
返回:
查找到的位置指针
template<typename T >
T* hgl::strstr ( T *  str1,
const T *  str2 
)

在字符串str1内查找另一个字符串str2

参数:
str1完整的字符串
str2要查找的字符串
返回:
str2在str1中所在位置的指针
void hgl::SwapRGB ( uint8 data,
int  size,
int  pitch 
)
void hgl::SystemCheck ( SystemInfo si,
bool  put 
)
int hgl::tdfReadCompressData ( TDFNode *  tdf,
const WideString &  dn_name,
void *  data,
int  size 
)

读取压缩数据

将数据压缩并写入一个TDF节点

参数:
tdf节点
dn_name保存压缩数据的节点名称
data要压缩保存的数据
size数据最大长度
返回:
真实数据长度,-1表示错误
int hgl::tdfReadCompressData ( TDFNode *  tdf,
const WideString &  ca_name,
const WideString &  dn_name,
void *  data,
int  size 
)

读取压缩数据

将数据压缩并写入一个TDF节点

参数:
tdf节点
ca_name保存压缩算法名称的节点名称
dn_name保存压缩数据的节点名称
data要压缩保存的数据
size数据最大长度
返回:
真实数据长度,-1表示错误
int hgl::tdfReadCompressImage ( TDFNode *  tdf,
const WideString &  ca_name,
const WideString &  dn_name,
void *  data,
int  width,
int  height,
int  channels 
)
int hgl::tdfReadCompressImage ( TDFNode *  tdf,
const WideString &  dn_name,
void *  data,
int  width,
int  height,
int  channels 
)
void hgl::tdfWriteCompressData ( TDFNode *  tdf,
const WideString &  dn_name,
void *  data,
int  size,
CA  ca 
)

存入压缩数据

将数据压缩并写入一个TDF节点

参数:
tdf节点
dn_name保存压缩数据的节点名称
data要压缩保存的数据
size数据长度
ca压缩算法
void hgl::tdfWriteCompressData ( TDFNode *  tdf,
const WideString &  ca_name,
const WideString &  dn_name,
void *  data,
int  size,
CA  ca 
)

存入压缩数据

将数据压缩并写入一个TDF节点

参数:
tdf节点
ca_name保存压缩算法名称的节点名称
dn_name保存压缩数据的节点名称
data要压缩保存的数据
size数据长度
ca压缩算法
void hgl::tdfWriteCompressData ( TDFNode *  tdf,
const WideString &  dn_name,
void *  data,
int  size,
const WideString &  ca 
)

存入压缩数据

将数据压缩并写入一个TDF节点

参数:
tdf节点
dn_name保存压缩数据的节点名称
data要压缩保存的数据
size数据长度
ca压缩算法
void hgl::tdfWriteCompressData ( TDFNode *  tdf,
const WideString &  ca_name,
const WideString &  dn_name,
void *  data,
int  size,
const WideString &  ca 
)

存入压缩数据

将数据压缩并写入一个TDF节点

参数:
tdf节点
ca_name保存压缩算法名称的节点名称
dn_name保存压缩数据的节点名称
data要压缩保存的数据
size数据长度
ca压缩算法
void hgl::tdfWriteCompressImage ( TDFNode *  tdf,
const WideString &  ca_name,
const WideString &  dn_name,
void *  data,
int  width,
int  height,
int  channels,
const WideString &  ca,
float  rate 
)
void hgl::tdfWriteCompressImage ( TDFNode *  tdf,
const WideString &  dn_name,
void *  data,
int  width,
int  height,
int  channels,
const WideString &  ca,
float  rate 
)
hgl_thread_result hgl::ThreadFunc ( void *  ptr)
cml::vector2f hgl::to ( const cml::vector2f &  start,
const cml::vector2f &  end,
float  pos 
) [inline]
cml::vector3f hgl::to ( const cml::vector3f &  start,
const cml::vector3f &  end,
float  pos 
) [inline]
void hgl::To2DMode ( float  canvas_width,
float  canvas_height,
float  left,
float  top,
float  width,
float  height 
)

设置当前矩阵为正角视图,并将绘图坐标系转换为2D坐标系

参数:
canvas_width游戏画面宽度
canvas_height游戏画面高度
left可视画面左边界坐标
top可视画面上边界坐标
width可视画面宽度
height可视画现高度
void hgl::To2DMode ( float  w,
float  h 
)

设置当前矩阵为正角视图,并将绘图坐标系转换为2D坐标系

参数:
w游戏画面宽度
h游戏画现高度
void hgl::To2DMode ( )
void __inline hgl::To3DMode ( float  fov,
float  n,
float  f 
)
void hgl::To3DMode ( float  fovy,
float  p,
float  n,
float  f 
)

设置当前矩阵为投影视图,并将绘图坐标系设为标准3D坐标系

参数:
fovy角度
p宽/高比例
n最近的坐标
f最远的坐标
void __inline hgl::To3DMode ( float  fov)
void hgl::To3DOrtho ( float  size,
float  nr 
)

设置3D正角视图模式

参数:
size宽或高的值(一般为1)
nr远近的值(一般为1)
void hgl::ToHalf ( uchar dst,
const uchar src,
int  width,
int  height,
int  color 
)

将图片缩小到原始的一半

参数:
dst缩小后的图片保存地址
src原始图片数据保存地址
width原始图片宽
height原始图片高
color图片色彩成份
Matrix4f hgl::translate ( const cml::vector3f &  v) [inline]
Matrix4f hgl::translate ( float  x,
float  y,
float  z 
) [inline]
WideString hgl::UIntToStr ( uint64  n) [inline]

转换整型数到WideString

将整型数转换成字符串

参数:
n要转换的数值
返回:
转换后的字符串
int hgl::Unite ( int *  data,
int  number,
int  min 
)
void __cdecl hgl::UnloadPlugIn ( PlugIn pi)

释放一个插件

释放一个插件

参数:
pi插件指针
template<typename T >
void hgl::UpperString ( T *  SourceString)

将一个字符串中的字母全部改为大写

参数:
SourceString要处理的字符串
template<typename T >
void hgl::UpperString ( const T *  SourceString,
T *  TargetString 
)

将一个字符串中的字母全部改为大写

参数:
SourceString要处理的字符串
typedef hgl::void ( __cdecl *  SeekFunc)
void hgl::WaitThread ( Thread **  mt,
int  count,
double  time 
)

等待多个线程中的一个完成

等待多个线程中的一个完成

参数:
mt线程
count线程数量
time等待的时间,如果为0表示等到线程运行结束为止。默认为0
void hgl::WaitTime ( double  time)

等待一定时间(单位:秒)

等待指定时间

参数:
time时间(单位:秒)
int hgl::WideToAnsi ( CCP  ccp,
char *  as,
int  as_size,
const wchar_t *  ws,
int  ws_size = -1 
)

转换wchar_t *字符串到ANSI字符串

参数:
ccp代码页
asansi字符串
as_size字符串长度
wswchar_t *字符串缓冲区
ws_size缓冲区长度,-1表示全部
返回:
转换成功后的字符串字符数
int hgl::WideToAnsi ( char *  as,
int  as_size,
const wchar_t *  ws,
int  ws_size = -1 
) [inline]

转换wchar_t *字符串到ANSI字符串(当前系统默认字符集)

参数:
asansi字符串
as_size字符串长度
wswchar_t *字符串缓冲区
ws_size缓冲区长度,-1表示全部
返回:
转换成功后的字符串字符数
int hgl::WideToAnsi ( CCP  ccp,
char **  as,
const wchar_t *  ws,
int  ws_size = -1 
)

转换wchar_t *字符串到ANSI字符串

参数:
ccp代码页
aschar *字符串缓冲区,自动分配,需手动delete[]
wswchar_t *字符串
ws_size字符串长度,-1表示全部
返回:
转换成功后的字符串字符数
int hgl::WideToAnsi ( char **  as,
const wchar_t *  ws,
int  ws_size = -1 
) [inline]

转换wchar_t *字符串到ANSI字符串(当前系统默认字符集)

参数:
aschar *字符串缓冲区,自动分配,需手动delete[]
wswchar_t *字符串
ws_size字符串长度,-1表示全部
返回:
转换成功后的字符串字符数
LRESULT CALLBACK hgl::WindowProc ( HWND  hWnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam 
)
hgl::WMEF ( WMProcDestroy  )
hgl::WMEF1 ( WMProcChar  )
hgl::WMEF1 ( WMProcKeyDown  )
hgl::WMEF1 ( WMProcActive  )
hgl::WMEF1 ( WMProcKeyUp  )
hgl::WMEF2 ( WMProcMouseWheel  )
hgl::WMEF2 ( WMProcSize  )
hgl::WMEF_MOUSE ( MidDown  )
hgl::WMEF_MOUSE ( MidUp  )
hgl::WMEF_MOUSE ( LeftDoubleClick  )
hgl::WMEF_MOUSE ( LeftDown  )
hgl::WMEF_MOUSE ( Move  )
hgl::WMEF_MOUSE ( RightDown  )
hgl::WMEF_MOUSE ( RightDoubleClick  )
hgl::WMEF_MOUSE ( LeftUp  )
hgl::WMEF_MOUSE ( MidDoubleClick  )
hgl::WMEF_MOUSE ( RightUp  )
void hgl::write_to_yuv_frame ( uint  w,
uint  h,
uint8 yuv,
uint8 yuv_y,
uint8 yuv_u,
uint8 yuv_v 
)
hgl::WRITEFUNC ( WriteFloat  ,
float   
)
hgl::WRITEFUNC ( WriteInt64  ,
int64   
)
hgl::WRITEFUNC ( WriteUint64  ,
uint64   
)
hgl::WRITEFUNC ( WriteInt32  ,
int32   
)
hgl::WRITEFUNC ( WriteDouble  ,
double   
)
hgl::WRITEFUNC ( WriteBool  ,
bool   
)
hgl::WRITEFUNC ( WriteString  ,
const WideString &   
)
hgl::WRITEFUNC ( WriteUint8  ,
uint8   
)
hgl::WRITEFUNC ( WriteUint32  ,
uint32   
)
hgl::WRITEFUNC ( WriteInt16  ,
int16   
)
hgl::WRITEFUNC ( WriteInt8  ,
int8   
)
hgl::WRITEFUNC ( WriteUint16  ,
uint16   
)
int128 hgl::wtoi ( wchar_t *  Str)
uint8 * hgl::YUV2RGB ( uint8 yuv,
int  w,
int  h 
)

变量文档

const wchar_t hgl::BeginSymbol[] = "!),.:;?]}¨·ˇˉ―‖’”…∶、。〃々〉》」』】〕〗!"'),.:;?]`|}~¢"
const int hgl::BeginSymbolCount = sizeof(BeginSymbol)/sizeof(wchar_t)
初始化序列:
          
    {
        false,  

        false,  
        true,   
        false,  
        true,   
        true,   

        false,  
        true,   

        false,  
    }

针对色彩类型而对应的每象素字节数

const int hgl::buf_size = 1024*1024
const unsigned int hgl::BytesByColorType
初始化序列:
  
    {
        0,      

        1,      
        2,      
        3,      
        4,      
        1,      

        3,      
        4,      

        0,      
    }

针对色彩类型而对应的OpenGL格式

wchar_t hgl::CAName[caEnd][32]
初始化序列:
    {
        L"",

        L"Bzip2",
        L"Lzo",
        L"Lzma",
        L"Zip",
        L"RLE",
        L"RYC",
        L"RSC",
        L"Jpeg2000"
        L"VSRLE"
    }
const double hgl::clamp_u = 0.436*255.0
const double hgl::clamp_v = 0.615*255.0
const unsigned int hgl::ColorTypeCount = ctEnd+1
const wchar_t hgl::ColorTypeName
初始化序列:
    {
        L"",

        L"Luminance",
        L"Luminance Alpha",
        L"RGB",
        L"RGBA",
        L"Alpha",

        L"BGR",
        L"BGRA",

        L""
    }
struct { ... } hgl::CubePanel[6]
const int hgl::DevilScriptMinLength = sizeof(L"func main(){}")

《魔鬼》最小脚本长度

const wchar_t hgl::EndSymbol[] = "([{·‘“〈《「『【〔〖(.[{£¥"
const int hgl::EndSymbolCount = sizeof(EndSymbol)/sizeof(wchar_t)
const float hgl::full_tex_coord[]
初始化序列:
    {
        0,0,
        1,0,
        1,1,
        0,1
    }
const unsigned int hgl::GLFormatByColorType
初始化序列:

色彩类型名称

const char hgl::glsl_yuv2rgb[]
初始化序列:
    {
        "uniform sampler2D tex_y;\n"
        "uniform sampler2D tex_u;\n"
        "uniform sampler2D tex_v;\n"

        "void main()\n"
        "{\n"
        "   float y = texture2D( tex_y, gl_TexCoord[0].xy ).r;\n"
        "   float u = texture2D( tex_u, gl_TexCoord[1].xy ).r;\n"
        "   float v = texture2D( tex_v, gl_TexCoord[2].xy ).r;\n"

        "   if(u == 0.0 && v == 0.0)\n"
        "       y = 0.0;\n"

        "   y=1.1643*(y-0.0625);\n"
        "   u=u-0.5;\n"
        "   v=v-0.5;\n"

        "   gl_FragColor=vec4(  y+1.5958*v,\n"
        "                       y-0.39173*u-0.81290*v,\n"
        "                       y+2.017*u,\n"
        "                       1.0);\n"
        "}\n"
    }
const char hgl::HAC3Flag[] = "HAC-3\x1A"
const char hgl::HexChar[2][16]
初始化序列:
{   {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'},
                                {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}}
const unsigned int hgl::InvalidIndex = 0xFFFFFFFF
float hgl::m_null_matrix[16]
wchar_t hgl::name[6]
float hgl::p_null_matrix[16]
const wchar_t hgl::pi_name[ifEnd][32]
初始化序列:
    {
        L"PSD",
        L"Monolayer",
        L"Tim2",
        L"ART2",
        L"KLZ"
    }
void* hgl::ptr
float hgl::ref
const double hgl::SIN45 = 0.707106781186548
const unsigned __int32 hgl::SINV[91]
初始化序列:
    {
        0,
         17452406,   34899496,   52335956,   69756473,   87155742,  104528463,
        121869343,  139173100,  156434465,  173648177,  190808995,  207911690,
        224951054,  241921895,  258819045,  275637355,  292371704,  309016994,
        325568154,  342020143,  358367949,  374606593,  390731128,  406736643,
        422618261,  438371146,  453990499,  469471562,  484809620,  500000000,
        515038074,  529919264,  544639035,  559192903,  573576436,  587785252,
        601815023,  615661475,  629320391,  642787609,  656059028,  669130606,
        681998360,  694658370,  707106781,  719339800,  731353701,  743144825,
        754709580,  766044443,  777145961,  788010753,  798635510,  809016994,
        819152044,  829037572,  838670567,  848048096,  857167300,  866025403,
        874619707,  882947592,  891006524,  898794046,  906307787,  913545457,
        920504853,  927183854,  933580426,  939692620,  945518575,  951056516,
        956304755,  961261695,  965925826,  970295726,  974370064,  978147600,
        981627183,  984807753,  987688340,  990268068,  992546151,  994521895,
        996194698,  997564050,  998629534,  999390827,  999847695,  1000000000
    }
float hgl::t_null_matrix[16]
 全部  名字空间 文件 函数 变量 类型定义 枚举 枚举值 友元 宏定义