Refactor, separate docs from headers, add ru docs

Doxygen kind'a sucks and I need multilanguage documentation, so I did
that. Also, separated massive Math.h file into smaller files.

doc/Manual/ru/BH_Algo.pod

@@ -0,0 +1,165 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Algo - Общие алгоритмы
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Algo.h>
+
+ int data[4] = {5, 2, 3, 1};
+ int value, i;
+
+ value = 4;
+ BH_Partition(&value, data, 4, sizeof(int), intEqual);
+ BH_Sort(data, 4, sizeof(int), intEqual);
+ BH_HeapMake(data, 4, sizeof(int), intEqual);
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Algo предоставляет набор алгоритмов для работы с данными:
+
+=over
+
+=item * 
+
+Обмен значениями (L</BH_Swap>)
+
+=item * 
+
+Разбиение массива (L</BH_Partition>)
+
+=item * 
+
+Сортировка (L</BH_Sort>)
+
+=item * 
+
+Работа с кучей (L</BH_HeapMake>, L</BH_HeapRemove>, L</BH_HeapInsert>,
+L</BH_HeapReplace>)
+
+=back
+
+Эти алгоритмы позволяют эффективно выполнять различные операции над массивами и
+другими структурами данных.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Swap
+
+ void BH_Swap(void *dest,
+              void *src,
+              size_t size);
+
+Меняет значение между переменными I<dest> и I<src> заданного размера I<size>.
+
+
+=head2 BH_Partition
+
+ void *BH_Partition(void *pivot,
+                    void *array,
+                    size_t size,
+                    size_t element,
+                    BH_EqualCallback equal);
+
+Разбивает массив элементов I<array> (с количеством элементов I<size> и размером
+элемента I<element>) на две группы относительно элемента I<pivot>.
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два
+элемента.
+
+Параметр I<pivot> может ссылаться на элемент разбиваемого массива.
+
+Функция возвращает указатель на первый элемент массива, который принадлежит
+второй группе.
+
+
+=head2 BH_Sort
+
+ void BH_Sort(void *array,
+              size_t size,
+              size_t element,
+              BH_EqualCallback equal);
+
+Сортирует массив элементов I<array> (с количеством элементов I<size> и размером
+элемента I<element>).
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два
+элемента.
+
+
+=head2 BH_HeapMake
+
+ void BH_HeapMake(void *array,
+                  size_t size,
+                  size_t element,
+                  BH_EqualCallback equal);
+
+Создаёт кучу в массиве I<array> (с количеством элементов I<size> и размером
+элемента I<element>).
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два
+элемента.
+
+
+=head2 BH_HeapRemove
+
+ void BH_HeapRemove(void *array,
+                    size_t size,
+                    size_t element,
+                    BH_EqualCallback equal);
+
+Извлекает верхний элемент кучи в массиве I<array> (с количеством элементов
+I<size> и размером элемента I<element>).
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два
+элемента.
+
+
+=head2 BH_HeapInsert
+
+ void BH_HeapInsert(void *value,
+                    void *array,
+                    size_t size,
+                    size_t element,
+                    BH_EqualCallback equal);
+
+Добавляет элемент I<value> в кучу в массиве I<array> (с количеством элементов
+I<size> и размером элемента I<element>).
+
+Если I<value> равен NULL, предполагается, что новое значение находится в конце
+массива.
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два
+элемента.
+
+
+=head2 BH_HeapReplace
+
+ void BH_HeapReplace(void *value,
+                     void *array,
+                     size_t size,
+                     size_t element,
+                     BH_EqualCallback equal);
+
+Извлекает верхний элемент кучи в массиве I<array> (с количеством элементов
+I<size> и размером элемента I<element>) и добавляет в неё элемент I<value>.
+
+Если I<value> равен NULL, предполагается, что новое значение находится в конце
+массива.
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два
+элемента.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Args.pod

@@ -0,0 +1,165 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Args - обработка аргументов командной строки
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Args.h>
+
+ static BH_ArgsOption options[] =
+ {
+     {'h', "help", 0, "Display this help"},
+     {1000, "list", 0, "List files"},
+     {'i', "input", BH_ARGS_VALUE, "Input file"},
+     {'o', "output", BH_ARGS_VALUE | BH_ARGS_OPTIONAL, "Output file"},
+     {0, NULL, 0, NULL}
+ };
+
+ static int OptionsCallback(int key,
+                            char *arg,
+                            void *data)
+ {
+     switch (key)
+     {
+         case BH_ARGS_UNKNOWN:
+             /* Unknown options */
+             break;
+
+         case BH_ARGS_ARGUMENT:
+             /* Regular argument in arg */
+             break;
+
+         case 'h':
+             /* Named option without argument */
+             break;
+
+         case 1000:
+             /* Long-only option without argument */
+             break;
+
+         case 'i':
+             /* Option with argument in arg */
+             break;
+
+         case 'o':
+             /* Option with optional argument in arg */
+             break;
+     }
+
+     return BH_OK;
+ }
+
+ BH_ArgsParse(argc, argv, options, OptionsCallback, NULL);
+ BH_ArgsHelp(options, 0);
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Args предназначена для удобной обработки аргументов командной
+строки в программах. Она позволяет определить набор опций, которые могут быть
+указаны при запуске программы, и предоставляет механизмы для их анализа и
+обработки.
+
+Разбор аргументов происходит с учётом следующих правил:
+
+=over
+
+=item *
+
+Если указан аргумент "--", последующий разбор аргументов прекращается.
+
+=item *
+
+Если указан аргумент "-", он обрабатывается как есть.
+
+=item *
+
+Для значений длинных аргументов будет использоваться строка после знака равно
+или следующий аргумент ("--define=value" или "--define value").
+
+=item *
+
+Для значений коротких аргументов будет использоваться остаток строки после
+символа параметра или следующий аргумент ("-dvalue" или "-d value").
+
+=back
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_ArgsParse
+
+ int BH_ArgsParse(int argc,
+                  char **argv,
+                  BH_ArgsOption *options,
+                  BH_ArgsCallback callback,
+                  void *data);
+
+Разбирает аргументы I<options> командной строки (заданные в I<argc> и I<argv>) и
+вызывает указанный обработчик I<callback> (с пользовательскими данными I<data>).
+
+Параметр I<options> ссылается на нуль-терминированный массив.
+
+В случае успеха данная функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_ArgsHelp
+
+ void BH_ArgsHelp(BH_ArgsOption *options,
+                  int padding);
+
+Выводит в F<stdout> справочную информацию для аргументов I<options> (с указанным
+выравниванием I<padding>).
+
+В случае если параметр I<padding> равен 0, то будет использовано значение
+по умолчанию (30).
+
+
+=head1 СТРУКТУРЫ
+
+
+=head2 BH_ArgsOption
+
+ typedef struct BH_ArgsOption
+ {
+     int key;
+     const char *name;
+     int flags;
+     const char *description;
+ } BH_ArgsOption;
+
+Поле I<key> содержит идентификатор опции. В случае если идентификатор I<key>
+является печатным символом ASCII, то он будет использоваться в качестве
+короткого аргумента.
+
+Опциональное поле I<name> содержит строку, которая будет использоваться в
+качестве длинного аргумента.
+
+Поле I<flags> содержит флаги аргумента. Возможна комбинация из следующих флагов:
+
+=over
+
+=item B<BH_ARGS_VALUE>
+
+Аргумент принимает значение.
+
+=item B<BH_ARGS_OPTIONAL>
+
+Значение аргумента опционально.
+
+=back
+
+Поле I<description> содержит строку, которая будет использоваться при выводе
+справочной информации при помощи функции L</BH_ArgsHelp>.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Box2f.pod

@@ -0,0 +1,102 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Box2f - двухмерный ограничивающий прямоугольник
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Box2f.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Box2f предоставляет функции для работы с двухмерными ограничивающими 
+прямоугольниками. Он включает в себя операции объединения, пересечения, проверки
+вхождения точки в прямоугольник и вычисления ограничивающего прямоугольника по
+набору точек.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Box2fUnion
+
+ void BH_Box2fUnion(const float aMin[2],
+                    const float aMax[2],
+                    const float bMin[2],
+                    const float bMax[2],
+                    float outMin[2],
+                    float outMax[2]);
+
+Объединяет два ограничивающих прямоугольника A и B.
+
+Параметры I<aMin> и I<aMax> описывают ограничивающий прямоугольник A.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник B.
+
+Параметры I<outMin> и I<outMax> описывают результирующий ограничивающий 
+прямоугольник.
+
+
+=head2 BH_Box2fIntersect
+
+ int BH_Box2fIntersect(const float aMin[2],
+                       const float aMax[2],
+                       const float bMin[2],
+                       const float bMax[2],
+                       float outMin[2],
+                       float outMax[2]);
+
+Вычисляет пересечение двух ограничивающих прямоугольников A и B.
+
+Параметры I<aMin> и I<aMax> описывают ограничивающий прямоугольник A.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник B.
+
+Параметры I<outMin> и I<outMax> описывают результирующий ограничивающий 
+прямоугольник.
+
+Возвращает 0 в случае успешного пересечения или код ошибки.
+
+
+=head2 BH_Box2fContains
+
+ int BH_Box2fContains(const float aMin[2],
+                      const float aMax[2],
+                      const float point[2]);
+
+Проверяет, находится ли точка I<point> внутри ограничивающего прямоугольника.
+
+Параметры I<aMin> и I<aMax> описывают ограничивающий прямоугольник.
+
+Параметр I<point> описывает точку.
+
+Возвращает 0, если точка находится внутри прямоугольника, или код ошибки.
+
+
+=head2 BH_Box2fEnclose
+
+ int BH_Box2fEnclose(const float *points,
+                     size_t size,
+                     float outMin[2],
+                     float outMax[2]);
+
+Вычисляет ограничивающий прямоугольник по заданным точкам I<points>.
+
+Параметры I<points> и I<size> описывают входной массив точек.
+
+Параметры I<outMin> и I<outMax> описывают результирующий ограничивающий 
+прямоугольник.
+
+Возвращает 0 в случае успешного вычисления или код ошибки.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>,
+L<BH_Box3f>

doc/Manual/ru/BH_Box3f.pod

@@ -0,0 +1,103 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Box3f - трёхмерный ограничивающий прямоугольник
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Box3f.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Box3f предоставляет функции для работы с трёхмерными ограничивающими
+прямоугольниками. Он включает в себя операции объединения, пересечения, проверки
+вхождения точки в прямоугольник и вычисления ограничивающего прямоугольника по
+набору точек.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Box3fUnion
+
+ void BH_Box3fUnion(const float aMin[3],
+                    const float aMax[3],
+                    const float bMin[3],
+                    const float bMax[3],
+                    float outMin[3],
+                    float outMax[3]);
+
+Объединяет два ограничивающих прямоугольника A и B.
+
+Параметры I<aMin> и I<aMax> описывают ограничивающий прямоугольник A.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник B.
+
+Параметры I<outMin> и I<outMax> описывают результирующий ограничивающий 
+прямоугольник.
+
+
+=head2 BH_Box3fIntersect
+
+ int BH_Box3fIntersect(const float aMin[3],
+                       const float aMax[3],
+                       const float bMin[3],
+                       const float bMax[3],
+                       float outMin[3],
+                       float outMax[3]);
+
+Вычисляет пересечение двух ограничивающих прямоугольников A и B.
+
+Параметры I<aMin> и I<aMax> описывают ограничивающий прямоугольник A.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник B.
+
+Параметры I<outMin> и I<outMax> описывают результирующий ограничивающий 
+прямоугольник.
+
+Возвращает 0 в случае успешного пересечения или код ошибки.
+
+
+=head2 BH_Box3fContains
+
+ int BH_Box3fContains(const float aMin[3],
+                      const float aMax[3],
+                      const float point[3]);
+
+Проверяет, находится ли точка I<point> внутри ограничивающего прямоугольника.
+
+Параметры I<aMin> и I<aMax> описывают ограничивающий прямоугольник.
+
+Параметр I<point> описывает точку.
+
+Возвращает 0, если точка находится внутри ограничивающего прямоугольника, или
+код ошибки.
+
+
+=head2 BH_Box3fEnclose
+
+ int BH_Box3fEnclose(const float *points,
+                     size_t size,
+                     float outMin[3],
+                     float outMax[3]);
+
+Вычисляет ограничивающий прямоугольник по заданным точкам.
+
+Параметры I<points> и I<size> описывают входной массив точек.
+
+Параметры I<outMin> и I<outMax> описывают результирующий ограничивающий 
+прямоугольник.
+
+Возвращает 0 в случае успеха или код ошибки.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>,
+L<BH_Box2f>

doc/Manual/ru/BH_Hashmap.pod

@@ -0,0 +1,198 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Hashmap - неупорядочный ассоциативный массив
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Hashmap.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Hashmap предоставляет реализацию неупорядоченного ассоциативного
+массива, основанного на хэш-таблице. Она позволяет эффективно хранить и 
+извлекать данные по ключу.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_HashmapNew
+
+ BH_Hashmap *BH_HashmapNew(BH_EqualCallback equal,
+                           BH_HashCallback hash);
+
+Создаёт ассоциативный массив.
+
+Параметр I<equal> принимает указатель на функцию, которая сравнивает два 
+элемента.
+
+Параметр I<hash> принимает указатель на функцию, вычисляющую хэш-значение 
+элемента.
+
+В случае успеха функция возвращает указатель на новый объект BH_Hashmap или NULL
+в случае ошибки.
+
+
+=head2 BH_HashmapFree
+
+ void BH_HashmapFree(BH_Hashmap *hashmap);
+
+Уничтожает ассоциативный массив.
+
+
+=head2 BH_HashmapClear
+
+ void BH_HashmapClear(BH_Hashmap *hashmap);
+
+Очищает ассоциативный массив.
+
+
+=head2 BH_HashmapReserve
+
+ int BH_HashmapReserve(BH_Hashmap *hashmap,
+                       size_t size);
+
+Резервирует место как минимум для I<size> элементов.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_HashmapInsert
+
+ int BH_HashmapInsert(BH_Hashmap *hashmap,
+                      void *key,
+                      void *value);
+
+Вставляет элемент, представленный парой ключ-значение I<key> и I<value>.
+
+Функция позволяет вставлять несколько элементов с одинаковым значением ключа.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_HashmapRemove
+
+ void BH_HashmapRemove(BH_Hashmap *hashmap,
+                       void *key);
+
+Удаляет элемент с заданным значением ключа I<key>.
+
+Если ассоциативный массив содержит несколько элементов с одинаковым значением 
+ключа, функция удалит только одну пару ключ-значение.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+
+=head2 BH_HashmapAt
+
+ int BH_HashmapAt(BH_Hashmap *hashmap,
+                  void *key,
+                  void **value);
+
+Проверяет наличие элемента с заданным ключом I<key>.
+
+Опциональный параметр I<value> возвращает значение элемента с заданным ключом.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_HashmapEmpty
+
+ int BH_HashmapEmpty(BH_Hashmap *hashmap);
+
+Проверяет, является ли ассоциативный массив пустым.
+
+
+=head2 BH_HashmapSize
+
+ size_t BH_HashmapSize(BH_Hashmap *hashmap);
+
+Возвращает количество элементов.
+
+
+=head2 BH_HashmapCapacity
+
+ size_t BH_HashmapCapacity(BH_Hashmap *hashmap);
+
+Возвращает ёмкость.
+
+
+=head2 BH_HashmapFactor
+
+ float BH_HashmapFactor(BH_Hashmap *hashmap);
+
+Возвращает максимальный коэффициент загрузки.
+
+
+=head2 BH_HashmapSetFactor
+
+ void BH_HashmapSetFactor(BH_Hashmap *hashmap,
+                          float factor);
+
+Задаёт максимальный коэффициент загрузки I<factor>.
+
+Новое значение максимального коэффициента загрузки будет применено при следующем
+вызове функции
+L</BH_HashmapInsert> или L</BH_HashmapReserve>.
+
+
+=head2 BH_HashmapIterAt
+
+ void *BH_HashmapIterAt(BH_Hashmap *hashmap,
+                        void *key);
+
+Возвращает итератор на элемент с заданным ключом I<key>.
+
+В случае успеха функция возвращает итератор или NULL.
+
+
+=head2 BH_HashmapIterNext
+
+ void *BH_HashmapIterNext(BH_Hashmap *hashmap,
+                          void *iter);
+
+Возвращает итератор на следующий элемент.
+
+Опциональный параметр I<iter> принимает итератор на текущий элемент.
+
+В случае успеха функция возвращает итератор или NULL.
+
+
+=head2 BH_HashmapIterRemove
+
+ void BH_HashmapIterRemove(BH_Hashmap *hashmap,
+                           void *iter);
+
+Удаляет элемент по заданному итератору I<iter>.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+
+=head2 BH_HashmapIterKey
+
+ void *BH_HashmapIterKey(void *iter);
+
+Возвращает ключ элемента, указываемый итератором I<iter>.
+
+
+=head2 BH_HashmapIterValue
+
+ void *BH_HashmapIterValue(void *iter);
+
+Возвращает значение элемента, указываемое итератором I<iter>.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_IO.pod

@@ -0,0 +1,514 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_IO - Подсистема ввода-вывода
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/io.h>
+
+ BH_IO *io = BH_FileNew("input.txt", BH_FILE_WRITE | BH_FILE_TRUNCATE, NULL);
+ BH_IOWrite(io, "Hello, world!", 13, NULL);
+ BH_IOFree(io);
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+BH_IO предоставляет подсистему, позволяющей работать с различными объектами
+(файлы, сокеты, память) через единый интерфейс ввода-вывода. Это позволяет
+писать код, непривязанный к конкретной системе ввода-вывода.
+
+Гарантируется, что любой объект BH_IO поддерживает следующие операции:
+L</BH_IORead>, L</BH_IOWrite>, L</BH_IOCtl> и L</BH_IOCap>.
+
+В зависимости от реализации того или иного объекта BH_IO, могут быть доступны
+дополнительные операции: L</BH_IOFlags>, L</BH_IOClear>, L</BH_IOFlush>,
+L</BH_IOSize>, L</BH_IOTell>, L</BH_IOSeek>, L</BH_IOPeek> и другие.
+
+По-умолчанию подсистема ввода-вывода позволяет работать с файлами
+(L</BH_FileNew>) или оперативной памятью (L</BH_BytesNew>), а также
+буферизировать ввод-вывод (L</BH_BufferNew>).
+
+
+=head1 РАСШИРЕНИЕ
+
+BH_IO предоставляет разработчику возможность создавать собственные реализации
+устройств ввода-вывода. Пример:
+
+ typedef struct BH_MyIO
+ {
+     BH_IO parent;
+     int flags;
+ };
+
+ static int ioDestroy(BH_MyIO *io)
+ {
+     /* Ommitted for the example */
+ }
+
+ static int ioRead(BH_MyIO *io,
+                   BH_IOReadInfo *info)
+ {
+     /* Ommitted for the example */
+ }
+
+ static int ioWrite(BH_MyIO *io,
+                    BH_IOWriteInfo *info)
+ {
+     /* Ommited for the example */
+ }
+
+ static int ioFlags(BH_MyIO *io,
+                    int *flags)
+ {
+     *flags = io->flags;
+     return BH_OK;
+ }
+
+ static int ioCap(BH_MyIO *io,
+                  int *op)
+ {
+     BH_UNUSED(io);
+
+     switch (*op)
+     {
+     case BH_IO_CTL_FLAGS:
+         return BH_OK;
+
+     default:
+         return BH_NOIMPL;
+     }
+ }
+
+ static int ioCtl(BH_MyIO *io,
+                  BH_IOCtlInfo *info)
+ {
+     switch (info->op)
+     {
+     case BH_IO_CTL_FLAGS:
+         return ioFlags(io, (int *)info->arg);
+
+     default:
+         return BH_NOIMPL;
+     }
+ }
+
+ static int ioCallback(BH_MyIO *io,
+                       int type,
+                       void *arg)
+ {
+     switch (type)
+     {
+     case BH_IO_OP_DESTROY:  return ioDestroy(io);
+     case BH_IO_OP_READ:     return ioRead(io, (BH_IOReadInfo *)arg);
+     case BH_IO_OP_WRITE:    return ioWrite(io, (BH_IOWriteInfo *)arg);
+     case BH_IO_OP_CTL:      return ioCtl(io, (BH_IOCtlInfo *)arg);
+     case BH_IO_OP_CAP:      return ioCap(io, (int*)arg);
+     default:                return BH_NOIMPL;
+     }
+ }
+
+ BH_IO *BH_MyIONew(int *result)
+ {
+     BH_MyIO *io;
+     int code;
+
+     code = BH_OOM;
+     if ((io = malloc(sizeof(*io))))
+     {
+         io->parent.callback = (BH_IOCallback)ioCallback;
+         io->flags = 0;
+     }
+
+     if (result)
+         *result = code;
+
+     return (BH_IO*)io;
+ }
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_FileNew
+
+ BH_IO *BH_FileNew(const char *path,
+                   int mode,
+                   int *result);
+
+Создает устройство ввода-вывода для работы с файлом по пути I<path>.
+
+Параметр I<mode> может принимать комбинацию из следующих значений:
+
+=over
+
+=item B<BH_FILE_READ>
+
+Открывает файл на чтение
+
+=item B<BH_FILE_WRTIE>
+
+Открывает файл на запись
+
+=item B<BH_FILE_APPEND>
+
+Открывает файл в режиме добавление в конец
+
+=item B<BH_FILE_TRUNCATE>
+
+Усекает файл
+
+=item B<BH_FILE_CREATE>
+
+Файл должен быть создан
+
+=item B<BH_FILE_EXIST>
+
+Файл должен существовать
+
+=back
+
+Опциональный параметр I<result> возвращает 0 или код ошибки.
+
+Данная функция возвращает указатель на новый BH_IO объект или NULL.
+
+
+=head2 BH_BufferNew
+
+ BH_IO *BH_BufferNew(BH_IO *device,
+                     size_t size,
+                     int *result);
+
+Создает устройство ввода-вывода для буферизации данных к другому устройству
+I<device>.
+
+Параметр I<size> отвечает за размер буферов чтения и записи.
+
+Опциональный параметр I<result> возвращает 0 или код ошибки.
+
+В случае успеха, данная функция возвращает указатель на новый BH_IO объект или
+NULL в случае ошибки.
+
+
+=head2 BH_BytesNew
+
+ BH_IO *BH_BytesNew(char *data,
+                    size_t size,
+                    int *result);
+
+Создает устройство ввода-вывода для региона памяти I<data> с размером I<size>.
+
+Опциональный параметр I<result> возвращает код ошибки.
+
+В случае успеха, данная функция возвращает указатель на новый BH_IO объект или
+NULL в случае ошибки.
+
+
+=head2 BH_IOFree
+
+ void BH_IOFree(BH_IO *device);
+
+Уничтожает устройство ввода-вывода.
+
+
+=head2 BH_IORead
+
+ int BH_IORead(BH_IO *device,
+               char *buffer,
+               size_t size,
+               size_t *actual);
+
+Читает до I<size> байт из устройства ввода-вывода и записывает данные в
+I<buffer>.
+
+Опциональный параметр I<actual> возвращает число байт, которое было фактически
+прочитано.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOWrite
+
+ int BH_IOWrite(BH_IO *io,
+                const char *buffer,
+                size_t size,
+                size_t *actual);
+
+Записывает до I<size> байт в устройство ввода-вывода из I<buffer>.
+
+Опциональный параметр I<actual> возвращает число байт, которое было записано.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOCtl
+
+ int BH_IOCtl(BH_IO *device,
+              int op,
+              void *arg);
+
+Манипулирует параметрами устройства ввода-вывода с помощью команды I<op> и
+параметра I<arg>.
+
+Возможные значения I<op>:
+
+=over
+
+=item B<BH_IO_CTL_FLAGS>
+
+Аргумент: int *
+
+Вернуть флаги устройства ввода-вывода.
+
+=item B<BH_IO_CTL_CLEAR>
+
+Сбросить ошибки устройства ввода-вывода.
+
+=item B<BH_IO_CTL_PEEK>
+
+Аргумент: L<BH_IOReadInfo *|/BH_IOReadInfo>
+
+Читает без извлечения данные из устройства ввода-вывода.
+
+=item B<BH_IO_CTL_FLUSH>
+
+Записать буферизированные данные в устройство ввода-вывода.
+
+=item B<BH_IO_CTL_SIZE>
+
+Аргумент: int64_t *
+
+Получить размер устройства ввода-вывода.
+
+=item B<BH_IO_CTL_TELL>
+
+Аргумент: int64_t *
+
+Читает текущее смещение указателя чтения устройства ввода-вывода.
+
+=item B<BH_IO_CTL_SEEK>
+
+Аргумент: L<BH_IOSeekInfo *|/BH_IOSeekInfo>
+
+Изменяет текущее положение указателя чтения устройства ввода-вывода.
+
+=item B<BH_IO_CTL_GET_IO>
+
+Аргумент: L<BH_IO **|/BH_IO>|void *
+
+Получает объект устройства, используемый в реализации.
+
+=item B<BH_IO_CTL_SET_IO>
+
+Аргумент: L<BH_IO *|/BH_IO>|void *
+
+Устанавливает объект устройства, который будет использоваться в реализации.
+
+=back
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOCap
+
+ int BH_IOCap(BH_IO *device,
+              int op);
+
+Проверяет возможность выполнения команды I<op> на устройстве ввода-вывода.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOFlags
+
+ int BH_IOFlags(BH_IO *device,
+                int *flags);
+
+Возвращает текущие флаги I<flags> устройства ввода-вывода.
+
+Возможные флаги (и их комбинации):
+
+=over
+
+=item B<BH_IO_FLAG_ERROR>
+
+В процессе выполнения возникла ошибка.
+
+=item B<BH_IO_FLAG_EOF>
+
+Устройство достигло конца файла.
+
+=back
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOClear
+
+ int BH_IOClear(BH_IO *device);
+
+Очищает устройство ввода-вывода от ошибок.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOPeek
+
+ int BH_IOPeek(BH_IO *device,
+               char *buffer,
+               size_t size,
+               size_t *actual);
+
+Читает без извлечения до I<size> байт из устройства ввода-вывода и записывает
+данные в I<buffer>.
+
+Опциональный параметр I<actual> возвращает число байт, которое было фактически
+прочитано.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOFlush
+
+ int BH_IOFlush(BH_IO *device);
+
+Записывает буферизированные значения в устройство ввода-вывода.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOSize
+
+ int BH_IOSize(BH_IO *device,
+               int64_t *size);
+
+Читает текущий размер устройства ввода-вывода в байтах и записывает значение в
+I<size>.
+
+Для различных типов устройств ввода-вывода данное значение может означать разные
+вещи (к примеру: текущий размер файла, размер выделенной для ввода-вывода памяти
+и т.д.).
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOTell
+
+ int BH_IOTell(BH_IO *device,
+               int64_t *offset);
+
+Читает текущее смещение указателя чтения устройства ввода-вывода относительно
+начала и записывает значение в I<offset>.
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOSeek
+
+ int BH_IOSeek(BH_IO *device,
+               int64_t offset,
+               int whence);
+
+Изменяет текущее положение указателя чтения устройства ввода-вывода с учетом
+смещения I<offset> и начальной позиции I<whence>.
+
+Возможные значения начальной позиции I<whence>:
+
+=over
+
+=item B<BH_IO_SEEK_SET>
+
+Смещение относительно начала устройства.
+
+=item B<BH_IO_SEEK_CUR>
+
+Смещение относительно текущей позиции устройства.
+
+=item B<BH_IO_SEEK_END>
+
+Смещение относительно конца устройства.
+
+=back
+
+В случае успеха, данная функция возвращает 0 или код ошибки.
+
+
+=head2 BH_IOError
+
+ int BH_IOError(BH_IO *device);
+
+Проверяет, находится ли устройство ввода-вывода в состоянии ошибки.
+
+Данная функция эквивалентна следующему коду:
+
+ (BH_IOFlags(device) & BH_IO_FLAG_ERROR)
+
+
+=head2 BH_IOEndOfFile
+
+ int BH_IOEndOfFile(BH_IO *device);
+
+Проверяет, достигло ли устройство ввода-вывода конца.
+
+Данная функция эквивалентна следующему коду:
+
+ (BH_IOFlags(device) & BH_IO_FLAG_EOF)
+
+
+=head1 СТРУКТУРЫ ДАННЫХ
+
+
+=head2 BH_IO
+
+ typedef struct BH_IO
+ {
+     BH_IOCallback callback;
+ } BH_IO;
+
+
+=head2 BH_IOReadInfo
+
+ typedef struct BH_IOReadInfo
+ {
+     char *data;
+     size_t size;
+     size_t *actual;
+ } BH_IOReadInfo;
+
+
+=head2 BH_IOWriteInfo
+
+ typedef struct BH_IOWriteInfo
+ {
+     const char *data;
+     size_t size;
+     size_t *actual;
+ } BH_IOWriteInfo;
+
+
+=head2 BH_IOCtlInfo
+
+ typedef struct BH_IOCtlInfo
+ {
+     int op;
+     void *arg;
+ } BH_IOCtlInfo;
+
+
+=head2 BH_IOSeekInfo
+
+ typedef struct BH_IOSeekInfo
+ {
+     int64_t offset;
+     int whence;
+ } BH_IOSeekInfo;
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Line.pod

@@ -0,0 +1,60 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Line - прямая на плоскости.
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Line предоставляет функции для работы с прямыми на плоскости. Он 
+позволяет вычислять коэффициенты прямой по двум точкам, находить расстояние от 
+точки до прямой и определять ближайшую точку на прямой к заданной точке.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_LineFromPoints
+
+ int BH_LineFromPoints(const float a[2],
+                       const float b[2],
+                       float out[3]);
+
+Вычисляет коэффициенты прямой на плоскости по двум точкам I<a> и I<b>.
+
+Параметр I<out> описывает результирующую прямую на плоскости.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_LineDistance
+
+ float BH_LineDistance(const float line[3],
+                       const float point[2]);
+
+Вычисляет расстояние от точки I<point> до прямой I<line>.
+
+
+=head2 BH_LineClosestPoint
+
+ void BH_LineClosestPoint(const float line[3],
+                          const float point[2],
+                          float out[2]);
+
+Вычисляет ближайшую точку на прямой I<line> к другой точке I<point>.
+
+Параметр I<out> описывает результирующую точку.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Mat3f.pod

@@ -0,0 +1,168 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Mat3f - вещественная матрица 3x3
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Mat3f.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Mat3f предоставляет набор функций для работы с вещественными матрицами
+размером 3x3.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Mat3fIdentity
+
+ void BH_Mat3fIdentity(float out[9]);
+
+Записывает единичную матрицу в I<out>.
+
+
+=head2 BH_Mat3fAdd
+
+ void BH_Mat3fAdd(const float a[9],
+                  const float b[9],
+                  float out[9]);
+
+Вычисляет сумму двух матриц I<a> и I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fSub
+
+ void BH_Mat3fSub(const float a[9],
+                  const float b[9],
+                  float out[9]);
+
+Вычисляет разность двух матриц I<a> и I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fMul
+
+ void BH_Mat3fMul(const float a[9],
+                  const float b[9],
+                  float out[9]);
+
+Вычисляет результат перемножения двух матриц I<a> и I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fScale
+
+ void BH_Mat3fScale(const float a[9],
+                    float b,
+                    float out[9]);
+
+Вычисляет результат умножения матрицы I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fTranspose
+
+ void BH_Mat3fTranspose(const float in[9],
+                        float out[9]);
+
+Транспонирует матрицу I<in>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fTrace
+
+ float BH_Mat3fTrace(const float in[9]);
+
+Вычисляет сумму элементов главной диагонали матрицы I<in>.
+
+
+=head2 BH_Mat3fDet
+
+ float BH_Mat3fDet(const float in[9]);
+
+Вычисляет определитель матрицы I<in>.
+
+
+=head2 BH_Mat3fInverse
+
+ int BH_Mat3fInverse(const float in[9],
+                     float out[9]);
+
+Вычисляет обратную матрицу для I<in>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Mat3fFromScale
+
+ void BH_Mat3fFromScale(float x,
+                        float y,
+                        float out[9]);
+
+Вычисляет масштабирующую матрицу с масштабами I<x> и I<y>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fFromTranslation
+
+ void BH_Mat3fFromTranslation(float x,
+                              float y,
+                              float out[9]);
+
+Вычисляет матрицу смещения со значениями I<x> и I<y>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fFromRotation
+
+ void BH_Mat3fFromRotation(float angle,
+                           float out[9]);
+
+Вычисляет матрицу вращения с заданным углом I<angle>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat3fApplyVec3f
+
+ void BH_Mat3fApplyVec3f(float a[9],
+                         float b[3],
+                         float out[3]);
+
+Вычисляет результат перемножения матрицы I<a> и вектора I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Mat3fApplyVec2f
+
+ void BH_Mat3fApplyVec2f(float a[9],
+                         float b[2],
+                         float out[2]);
+
+Вычисляет результат перемножения матрицы I<a> и вектора I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Mat4f.pod

@@ -0,0 +1,290 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Mat4f - вещественная матрица 4x4
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Mat4f.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Mat4f предоставляет набор функций для работы с вещественными матрицами
+размером 4x4. Эти функции позволяют выполнять различные операции над матрицами,
+такие как сложение, вычитание, умножение, транспонирование, вычисление 
+определителя и другие.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Mat4fIdentity
+
+ void BH_Mat4fIdentity(float out[16]);
+
+Записывает единичную матрицу в I<out>.
+
+
+=head2 BH_Mat4fAdd
+
+ void BH_Mat4fAdd(const float a[16],
+                  const float b[16],
+                  float out[16]);
+
+Вычисляет сумму двух матриц I<a> и I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fSub
+
+ void BH_Mat4fSub(const float a[16],
+                  const float b[16],
+                  float out[16]);
+
+Вычисляет разность двух матриц I<a> и I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fMul
+
+ void BH_Mat4fMul(const float a[16],
+                  const float b[16],
+                  float out[16]);
+
+Вычисляет результат перемножения двух матриц I<a> и I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fScale
+
+ void BH_Mat4fScale(const float a[16],
+                    float b,
+                    float out[16]);
+
+Вычисляет результат умножения матрицы I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fTranspose
+
+ void BH_Mat4fTranspose(const float in[16],
+                        float out[16]);
+
+Транспонирует матрицу I<in>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fTrace
+
+ float BH_Mat4fTrace(const float in[16]);
+
+Вычисляет сумму элементов главной диагонали матрицы I<in>.
+
+
+=head2 BH_Mat4fDet
+
+ float BH_Mat4fDet(const float in[16]);
+
+Вычисляет определитель матрицы I<in>.
+
+
+=head2 BH_Mat4fInverse
+
+ int BH_Mat4fInverse(const float in[16],
+                     float out[16]);
+
+Вычисляет обратную матрицу для I<in>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Mat4fFromScale
+
+ void BH_Mat4fFromScale(float x,
+                        float y,
+                        float z,
+                        float out[16]);
+
+Вычисляет масштабирующую матрицу с масштабами I<x>, I<y> и I<z>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromTranslation
+
+ void BH_Mat4fFromTranslation(float x,
+                              float y,
+                              float z,
+                              float out[16]);
+
+Вычисляет матрицу смещения со значениями I<x>, I<y> и I<z>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromRotationX
+
+ void BH_Mat4fFromRotationX(float angle,
+                            float out[16]);
+
+Вычисляет матрицу вращения относительно оси X с заданным углом I<angle>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromRotationY
+
+ void BH_Mat4fFromRotationY(float angle,
+                            float out[16]);
+
+Вычисляет матрицу вращения относительно оси Y с заданным углом I<angle>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromRotationZ
+
+ void BH_Mat4fFromRotationZ(float angle,
+                            float out[16]);
+
+Вычисляет матрицу вращения относительно оси Z с заданным углом I<angle>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromAxis
+
+ void BH_Mat4fFromAxis(const float axis[3],
+                       float angle,
+                       float out[16]);
+
+Вычисляет матрицу вращения относительно оси I<axis> с заданным углом I<angle>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromEuler
+
+ void BH_Mat4fFromEuler(float roll,
+                        float pitch,
+                        float yaw,
+                        float out[16]);
+
+Вычисляет матрицу вращения из углов связанной системы координат I<roll>,
+I<pitch> и I<yaw>.
+
+Порядок применения вращения ZYX (yaw, pitch, roll).
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromQuat4f
+
+ void BH_Mat4fFromQuat4f(const float in[4],
+                         float out[16]);
+
+Вычисляет матрицу вращения из кватерниона I<in>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromOrtho
+
+ void BH_Mat4fFromOrtho(float xMin,
+                        float xMax,
+                        float yMin,
+                        float yMax,
+                        float zMin,
+                        float zMax,
+                        float out[16]);
+
+Вычисляет матрицу ортографической проекции.
+
+Параметры I<xMin> и I<xMax> определяют допустимый диапазон значений X
+координат.
+
+Параметры I<yMin> и I<yMax> определяют допустимый диапазон значений Y
+координат.
+
+Параметры I<zMin> и I<zMax> определяют допустимый диапазон значений Z
+координат.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromFrustum
+
+ void BH_Mat4fFromFrustum(float fov,
+                          float aspect,
+                          float zMin,
+                          float zMax,
+                          float out[16]);
+
+Вычисляет матрицу перспективной проекции.
+
+Параметр I<fov> определяет угол обзора.
+
+Параметр I<aspect> определяет соотношение сторон.
+
+Параметры I<zMin> и I<zMax> определяют допустимый диапазон значений Z
+координат.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fFromLookAt
+
+ void BH_Mat4fFromLookAt(const float position[3],
+                         const float at[3],
+                         const float up[3],
+                         float out[16]);
+
+Вычисляет видовую матрицу камеры.
+
+Параметр I<position> определяет положение камеры в пространстве.
+
+Параметр I<at> определяет точку, куда направлена камера.
+
+Параметр I<up> определяет «верх» камеры.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head2 BH_Mat4fApplyVec4f
+
+ void BH_Mat4fApplyVec4f(const float a[16],
+                         const float b[4],
+                         float out[4]);
+
+Вычисляет результат перемножения матрицы I<a> и вектора I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Mat4fApplyVec3f
+
+ void BH_Mat4fApplyVec3f(const float a[16],
+                         const float b[3],
+                         float out[3]);
+
+Вычисляет результат перемножения матрицы I<a> и вектора I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Math.pod

@@ -0,0 +1,48 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Math - Математические функции
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Math предоставляет набор математических функций для различных 
+вычислений.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Lerpf
+
+ float BH_Lerpf(float a, float b, float t);
+
+Интерполирует значение между I<a> и I<b> с заданным коэффициентом I<t>.
+
+
+=head2 BH_Triangle3fBarycentric
+
+ void BH_Triangle3fBarycentric(const float a[3],
+                               const float b[3],
+                               const float c[3],
+                               const float point[3],
+                               float out[3]);
+
+Вычисляет барицентрические координаты точки I<point> относительно треугольника, 
+заданного точками I<a>, I<b>, I<c>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Plane.pod

@@ -0,0 +1,66 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Plane - Плоскость в пространстве
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Plane предоставляет функции для работы с плоскостями в трёхмерном
+пространстве. Он позволяет вычислять коэффициенты плоскости по трём точкам,
+определять расстояние от точки до плоскости и находить ближайшую точку на
+плоскости к заданной точке.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_PlaneFromPoints
+
+ int BH_PlaneFromPoints(const float a[3],
+                        const float b[3],
+                        const float c[3],
+                        float out[4]);
+
+Вычисляет коэффициенты плоскости по трём точкам I<a>, I<b>, I<c>.
+
+Предполагается, что точки расположены в порядке по часовой стрелке.
+
+Если точки образуют вырожденный треугольник, функция вернёт ошибку.
+
+Параметр I<out> определяет результирующую плоскость.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_PlaneDistance
+
+ float BH_PlaneDistance(const float plane[4],
+                        const float point[3]);
+
+Вычисляет расстояние от точки I<point> до плоскости I<plane>.
+
+
+=head2 BH_PlaneClosestPoint
+
+ void BH_PlaneClosestPoint(const float plane[4],
+                           const float point[3],
+                           float out[3]);
+
+Вычисляет ближайшую точку на плоскости I<plane> к другой точке I<point>.
+
+Параметр I<out> описывает результирующую точку.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Quat.pod

@@ -0,0 +1,219 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Quat - Кватернион
+
+
+=head1 СИНТАКСИС
+
+#include <BH/Math/Quat.h>
+
+cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Данный модуль предоставляет набор функций для работы с кватернионами. 
+Кватернионы используются для представления вращений в трёхмерном пространстве и 
+обладают преимуществами перед другими методами, такими как матрицы вращения или 
+углы Эйлера, в части устойчивости к накоплению ошибок при многократных операциях
+вращения.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Quat4fAdd
+
+ #define BH_Quat4fAdd(a, b, out) \
+     BH_Vec4fAdd(a, b, out)
+
+Вычисляет сумму двух кватернионов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fSub
+
+ #define BH_Quat4fSub(a, b, out) \
+     BH_Vec4fSub(a, b, out)
+
+Вычисляет разность двух кватернионов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fScale
+
+ #define BH_Quat4fScale(a, b, out) \
+     BH_Vec4fScale(a, b, out)
+
+Вычисляет результат умножения кватерниона I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fNegate
+
+ #define BH_Quat4fNegate(in, out) \
+     BH_Vec4fNegate(in, out)
+
+Вычисляет противоположный кватернион от кватерниона I<in>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fDot
+
+ #define BH_Quat4fDot(a, b) \
+     BH_Vec4fDot(a, b)
+
+Вычисляет скалярное произведение кватернионов I<a> и I<b>.
+
+
+=head2 BH_Quat4fLength
+
+ #define BH_Quat4fLength(in) \
+     BH_Vec4fLength(in)
+
+float BH_Vec4fLength(const float in[4]);
+
+Вычисляет длину кватерниона I<in>.
+
+
+=head2 BH_Quat4fNormal
+
+ #define BH_Quat4fNormal(in, out) \
+     BH_Vec4fNormal(in, out)
+
+Вычисляет нормализованную форму кватерниона I<in>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fLerp
+
+ #define BH_Quat4fLerp(a, b, t, out) \
+     BH_Vec4fLerp(a, b, t, out)
+
+Выполняет линейную интерполяцию между двумя кватернионами I<a> и I<b> с 
+параметром I<t>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fIdentity
+
+ void BH_Quat4fIdentity(float out[4]);
+
+Записывает единичный кватернион в I<out>.
+
+
+=head2 BH_Quat4fConjugate
+
+ void BH_Quat4fConjugate(const float in[4],
+                         float out[4]);
+
+Вычисляет сопряжённый кватернион из I<in>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fInverse
+
+ void BH_Quat4fInverse(const float in[4],
+                       float out[4]);
+
+Вычисляет обратный кватернион из I<in>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fMul
+
+ void BH_Quat4fMul(const float a[4],
+                   const float b[4],
+                   float out[4]);
+
+Вычисляет результат перемножения двух кватернионов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fSlerp
+
+ void BH_Quat4fSlerp(const float a[4],
+                     const float b[4],
+                     float t,
+                     float out[4]);
+
+Выполняет сферическую линейную интерполяцию между двумя кватернионами I<a> и
+I<b> с параметром I<t>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fFromEuler
+
+ void BH_Quat4fFromEuler(float roll,
+                         float pitch,
+                         float yaw,
+                         float out[4]);
+
+Вычисляет кватернион из углов связанной системы координат I<roll>, I<pitch> и
+I<yaw>.
+
+Порядок применения вращения ZYX (yaw, pitch, roll).
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fFromAxis
+
+ void BH_Quat4fFromAxis(const float axis[3],
+                        float angle,
+                        float out[4]);
+
+Вычисляет кватернион из вращения относительно оси I<axis> с заданным углом
+I<angle>.
+
+Параметр I<out> описывает результирующий кватернион.
+
+
+=head2 BH_Quat4fToEuler
+
+ void BH_Quat4fToEuler(const float in[4],
+                       float *roll,
+                       float *pitch,
+                       float *yaw);
+
+Вычисляет углы связанной системы координат I<roll>, I<pitch> и I<yaw> из
+кватерниона I<in>.
+
+Порядок применения вращения ZYX (yaw, pitch, roll).
+
+
+=head2 BH_Quat4fToAxis
+
+ void BH_Quat4fToAxis(const float in[4],
+                      float axis[3],
+                      float *angle);
+
+Вычисляет ось вращения I<axis> и угол I<angle> из кватерниона I<in>.
+
+
+=head2 BH_Quat4fToMat4f
+
+ void BH_Quat4fToMat4f(const float in[4],
+                       float out[16]);
+
+Вычисляет матрицу вращения из кватерниона I<in>.
+
+Параметр I<out> описывает результирующую матрицу.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Queue.pod

@@ -0,0 +1,137 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Queue - контейнер очереди
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Queue.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Queue предоставляет реализацию контейнера очереди, который позволяет
+добавлять элементы в конец и извлекать их из начала. Очередь основана на
+динамическом массиве, что обеспечивает эффективное использование памяти и 
+быстрый доступ к элементам.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_QueueNew
+
+ BH_Queue *BH_QueueNew(void);
+
+Создаёт очередь.
+
+В случае успеха функция возвращает указатель на новый объект BH_Queue,
+или NULL в случае ошибки.
+
+
+=head2 BH_QueueFree
+
+ void BH_QueueFree(BH_Queue *queue);
+
+Уничтожает очередь.
+
+
+=head2 BH_QueueClear
+
+ void BH_QueueClear(BH_Queue *queue);
+
+Очищает очередь.
+
+
+=head2 BH_QueueReserve
+
+ int BH_QueueReserve(BH_Queue *queue, 
+                     size_t size);
+
+Резервирует место как минимум для I<size> элементов.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_QueueInsert
+
+ int BH_QueueInsert(BH_Queue *queue, 
+                    void *value);
+
+Вставляет элемент I<value>.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_QueueRemove
+
+ void BH_QueueRemove(BH_Queue *queue);
+
+Удаляет первый элемент из очереди.
+
+Вызов этой функции делает существующие итераторы недействительными.
+
+
+=head2 BH_QueueFront
+
+ int BH_QueueFront(BH_Queue *queue, 
+                   void **value);
+
+Возвращает первый элемент очереди.
+
+Параметр I<value> возвращает значение элемента.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_QueueEmpty
+
+ int BH_QueueEmpty(BH_Queue *queue);
+
+Проверяет, является ли очередь пустой.
+
+
+=head2 BH_QueueSize
+
+ size_t BH_QueueSize(BH_Queue *queue);
+
+Возвращает количество элементов.
+
+
+=head2 BH_QueueCapacity
+
+ size_t BH_QueueCapacity(BH_Queue *queue);
+
+Возвращает ёмкость.
+
+
+=head2 BH_QueueIterNext
+
+ void *BH_QueueIterNext(BH_Queue *queue, void *iter);
+
+Возвращает итератор на следующий элемент.
+
+Опциональный параметр I<iter> принимает итератор на текущий элемент.
+
+В случае успеха функция возвращает итератор или NULL.
+
+
+=head2 BH_QueueIterValue
+
+ void *BH_QueueIterValue(void *iter);
+
+Возвращает значение элемента, указываемое итератором I<iter>.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Ray2f.pod

@@ -0,0 +1,202 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Ray2f, BH_Segment2f - Луч/сегмент на плоскости
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Ray2f.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Данный модуль предоставляет функции для работы с лучами и сегментами на 
+плоскости. Он включает в себя функции для проверки пересечений между лучами, 
+сегментами, прямыми и ограничивающими прямоугольниками.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Ray2fIntersectLine
+
+ int BH_Ray2fIntersectLine(const float start[2],
+                           const float direction[2],
+                           const float line[3],
+                           float *t,
+                           float out[2]);
+
+Проверяет пересечение между лучом и прямой.
+
+Параметры I<start> и I<direction> описывают луч.
+
+Параметр I<line> описывает прямую.
+
+Параметр I<t> описывает результирующее время пересечения луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Ray2fIntersectTime
+
+ int BH_Ray2fIntersectTime(const float aStart[2],
+                           const float aDirection[2],
+                           const float bStart[2],
+                           const float bDirection[2],
+                           float *time1,
+                           float *time2);
+
+Вычисляет время пересечения между двумя лучами.
+
+Параметры I<aStart> и I<aDirection> описывают первый луч.
+
+Параметры I<bStart> и I<bDirection> описывают второй луч.
+
+Параметр I<time1> описывает результирующее время пересечения первого луча.
+
+Параметр I<time2> описывает результирующее время пересечения второго луча.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Ray2fIntersectRay
+
+ int BH_Ray2fIntersectRay(const float aStart[2],
+                          const float aDirection[2],
+                          const float bStart[2],
+                          const float bDirection[2],
+                          float *t,
+                          float out[2]);
+
+Проверяет пересечение между двумя лучами.
+
+Параметры I<aStart> и I<aDirection> описывают первый луч.
+
+Параметры I<bStart> и I<bDirection> описывают второй луч.
+
+Параметр I<t> описывает результирующее время пересечения первого луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Ray2fIntersectSegment
+
+ int BH_Ray2fIntersectSegment(const float aStart[2],
+                              const float aDirection[2],
+                              const float bStart[2],
+                              const float bEnd[2],
+                              float *t,
+                              float out[2]);
+
+Проверяет пересечение между лучом и сегментом.
+
+Параметры I<aStart> и I<aDirection> описывают луч.
+
+Параметры I<bStart> и I<bEnd> описывают сегмент.
+
+Параметр I<t> описывает результирующее время пересечения луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Segment2fIntersectLine
+
+ int BH_Segment2fIntersectLine(const float start[2],
+                               const float end[2],
+                               const float line[3],
+                               float *t,
+                               float out[2]);
+
+Проверяет пересечение между сегментом и прямой.
+
+Параметры I<start> и I<end> описывают сегмент.
+
+Параметр I<line> описывают прямую.
+
+Параметр I<t> описывает результирующее время пересечения сегмента.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Segment2fIntersectSegment
+
+ int BH_Segment2fIntersectSegment(const float aStart[2],
+                                  const float aEnd[2],
+                                  const float bStart[2],
+                                  const float bEnd[2],
+                                  float *t,
+                                  float out[2]);
+
+Проверяет пересечение между двумя сегментами.
+
+Параметры I<aStart> и I<aEnd> описывают первый сегмент.
+
+Параметры I<bStart> и I<bEnd> описывают второй сегмент.
+
+Параметр I<t> описывает результирующее время пересечения первого сегмента.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Ray2fIntersectBox2f
+
+ int BH_Ray2fIntersectBox2f(const float aStart[2],
+                            const float aDirection[2],
+                            const float bMin[2],
+                            const float bMax[2],
+                            float *t,
+                            float out[2]);
+
+Проверяет пересечение между лучом и ограничивающим прямоугольником.
+
+Параметры I<aStart> и I<aDirection> описывают луч.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник.
+
+Параметр I<t> описывает результирующее время пересечения луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head2 BH_Segment2fIntersectBox2f
+
+ int BH_Segment2fIntersectBox2f(const float aStart[2],
+                                const float aEnd[2],
+                                const float bMin[2],
+                                const float bMax[2],
+                                float *t,
+                                float out[2]);
+
+Проверяет пересечение между сегментом и ограничивающим прямоугольником.
+
+Параметры I<aStart> и I<aEnd> описывают сегмент.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник.
+
+Параметр I<t> описывает результирующее время пересечения сегмента.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в противном случае - код ошибки.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Ray3f.pod

@@ -0,0 +1,161 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Ray3f, BH_Segment3f - луч/сегмент в пространстве
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Ray3f.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Данный модуль предоставляет функции для работы с лучами и сегментами в 
+трёхмерном пространстве. Он включает в себя методы для проверки пересечений 
+лучей и сегментов с плоскостями, треугольниками и ограничивающими 
+прямоугольниками.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Ray3fIntersectPlane
+
+ int BH_Ray3fIntersectPlane(const float start[3],
+                            const float direction[3],
+                            const float plane[4],
+                            float *t,
+                            float out[3]);
+
+Проверяет пересечение между лучом и плоскостью.
+
+Параметры I<start> и I<direction> описывают луч.
+
+Параметр I<plane> описывает плоскость.
+
+Параметр I<t> описывает результирующее время пересечения луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_Ray3fIntersectTriangle
+
+ int BH_Ray3fIntersectTriangle(const float start[3],
+                               const float direction[3],
+                               const float a[3],
+                               const float b[3],
+                               const float c[3],
+                               float *t,
+                               float out[3]);
+
+Проверяет пересечение между лучом и треугольником.
+
+Параметры I<start> и I<direction> описывают луч.
+
+Параметры I<a>, I<b>, I<c> описывают точки треугольника.
+
+Параметр I<t> описывает результирующее время пересечения луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_Segment3fIntersectPlane
+
+ int BH_Segment3fIntersectPlane(const float start[3],
+                                const float end[3],
+                                const float plane[4],
+                                float *t,
+                                float out[3]);
+
+Проверяет пересечение между сегментом и плоскостью.
+
+Параметры I<start> и I<end> описывают сегмент.
+
+Параметр I<plane> описывает плоскость.
+
+Параметр I<t> описывает результирующее время пересечения сегмента.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_Segment3fIntersectTriangle
+
+ int BH_Segment3fIntersectTriangle(const float start[3],
+                                   const float end[3],
+                                   const float a[3],
+                                   const float b[3],
+                                   const float c[3],
+                                   float *t,
+                                   float out[3]);
+
+Проверяет пересечение между сегментом и треугольником.
+
+Параметры I<start> и I<end> описывают сегмент.
+
+Параметры I<a>, I<b>, I<c> описывают точки треугольника.
+
+Параметр I<t> описывает результирующее время пересечения луча.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_Ray3fIntersectBox3f
+
+ int BH_Ray3fIntersectBox3f(const float aStart[3],
+                            const float aDirection[3],
+                            const float bMin[3],
+                            const float bMax[3],
+                            float *t,
+                            float out[3]);
+
+Проверяет пересечение между лучом и ограничивающим прямоугольником.
+
+Параметры I<aStart> и I<aDirection> описывают луч.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник.
+
+Параметр I<t> описывает результирующее время пересечения первого сегмента.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head2 BH_Segment3fIntersectBox3f
+
+ int BH_Segment3fIntersectBox3f(const float aStart[3],
+                                const float aEnd[3],
+                                const float bMin[3],
+                                const float bMax[3],
+                                float *t,
+                                float out[3]);
+
+Проверяет пересечение между сегментом и ограничивающим прямоугольником.
+
+Параметры I<aStart> и I<aEnd> описывают сегмент.
+
+Параметры I<bMin> и I<bMax> описывают ограничивающий прямоугольник.
+
+Параметр I<t> описывает результирующее время пересечения первого сегмента.
+
+Параметр I<out> описывает результирующую точку пересечения.
+
+В случае успеха функция возвращает 0, в случае ошибки - код ошибки.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_String.pod

@@ -0,0 +1,373 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_String - Работа со строками
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_String предоставляет набор функций для работы со строками, включая
+преобразование чисел в строки и обратно.
+
+
+=head1 ОПРЕДЛЕНИЕ ОСНОВАНИЯ
+
+В функциях семейства I<StringToInt> присутсвует алгоритм определения основания
+числа по префиксам строки:
+
+=over
+
+=item * 
+
+Если префикс I<0b> - основние 2
+
+=item *
+
+Если префикс I<0> - основние 8
+
+=item *
+
+Если префикс I<0x> - основние 16
+
+=item *
+
+Иначе - основание 10
+
+=back
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_StringFromDouble
+
+ int BH_StringFromDouble(char *string,
+                         size_t size,
+                         double value,
+                         char format,
+                         int precision,
+                         size_t *actual);
+
+
+Форматирует вещественное число I<value> в нуль-терминированную строку I<string>
+(с ограничением по длинне I<size>).
+
+Параметр I<format> задает формат преобразования числа в строку. Допустимые 
+форматы:
+
+=over
+
+=item B<f>, B<F>
+
+Фиксированный формат: [-]ddd.ddd
+
+=item B<e>, B<E>
+
+Научный формат: [-]d.dddedd
+
+=item B<g>, B<G>
+
+Фиксированный или научный формат, в зависимости от того, какой из них короче
+
+=back
+
+Параметр I<precision> задает точность преобразования числа в строку. Если
+значение точности отрицательное, преобразование будет выполнено с минимально 
+необходимой точностью, чтобы при обратном преобразовании получилось исходное 
+число.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+Данная функция следует правилу IEEE 754 округление до четного.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt8s
+
+ int BH_StringFromInt8s(char *string,
+                        size_t size,
+                        int8_t value,
+                        int base,
+                        size_t *actual);
+
+Форматирует целое 8-битное знаковое число I<value> в нуль-терминированную строку
+I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt16s
+
+ int BH_StringFromInt16s(char *string,
+                         size_t size,
+                         int16_t value,
+                         int base,
+                         size_t *actual);
+
+Форматирует целое 16-битное знаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt32s
+
+ int BH_StringFromInt32s(char *string,
+                         size_t size,
+                         int32_t value,
+                         int base,
+                         size_t *actual);
+
+Форматирует целое 32-битное знаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt64s
+
+ int BH_StringFromInt64s(char *string,
+                         size_t size,
+                         int64_t value,
+                         int base,
+                         size_t *actual);
+
+Форматирует целое 64-битное знаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt8u
+
+ int BH_StringFromInt8u(char *string,
+                        size_t size,
+                        uint8_t value,
+                        int base,
+                        size_t *actual);
+
+Форматирует целое 8-битное беззнаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt16u
+
+ int BH_StringFromInt16u(char *string,
+                         size_t size,
+                         uint16_t value,
+                         int base,
+                         size_t *actual);
+
+Форматирует целое 16-битное беззнаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt32u
+
+ int BH_StringFromInt32u(char *string,
+                         size_t size,
+                         uint32_t value,
+                         int base,
+                         size_t *actual);
+
+Форматирует целое 32-битное беззнаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringFromInt64u
+
+ int BH_StringFromInt64u(char *string,
+                         size_t size,
+                         uint64_t value,
+                         int base,
+                         size_t *actual);
+
+Форматирует целое 64-битное беззнаковое число I<value> в нуль-терминированную 
+строку I<string> (с ограничением по длинне I<size>). 
+
+Параметр I<base> задает основание для преобразования.
+
+Опциональный параметр I<actual> возвращает длину записанной строки.
+
+В случае успеха, возвращает 0 или код ошибки.
+
+
+=head2 BH_StringToDouble
+
+ double BH_StringToDouble(const char *string,
+                          size_t *size);
+
+Преобразовывает строку I<string> в вещественное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt8s
+
+ int8_t BH_StringToInt8s(const char *string,
+                         size_t *size,
+                         int base);
+
+Преобразовывает строку I<string> в целое знаковое 8-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt16s
+
+ int16_t BH_StringToInt16s(const char *string,
+                           size_t *size,
+                           int base);
+
+Преобразовывает строку I<string> в целое знаковое 16-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt32s
+
+ int32_t BH_StringToInt32s(const char *string,
+                           size_t *size,
+                           int base);
+
+Преобразовывает строку I<string> в целое знаковое 32-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt64s
+
+ int64_t BH_StringToInt64s(const char *string,
+                           size_t *size,
+                           int base);
+
+Преобразовывает строку I<string> в целое знаковое 64-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt8u
+
+ uint8_t BH_StringToInt8u(const char *string,
+                          size_t *size,
+                          int base);
+
+Преобразовывает строку I<string> в целое беззнаковое 8-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt16u
+
+ uint16_t BH_StringToInt16u(const char *string,
+                            size_t *size,
+                            int base);
+
+Преобразовывает строку I<string> в целое беззнаковое 16-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt32u
+
+ uint32_t BH_StringToInt32u(const char *string,
+                            size_t *size,
+                            int base);
+
+Преобразовывает строку I<string> в целое беззнаковое 32-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head2 BH_StringToInt64u
+
+ uint64_t BH_StringToInt64u(const char *string,
+                            size_t *size,
+                            int base);
+
+Преобразовывает строку I<string> в целое беззнаковое 64-битное число.
+
+Опциональный параметр I<size> возвращает число прочитанных символов из строки. 
+
+Опциональный параметр I<base> задает основание числа.
+
+В случае успеха, возвращает преобразованное число или 0.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Thread.pod

@@ -0,0 +1,289 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Thread - многопоточность и примитивы синхронизации
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Thread.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Thread предоставляет набор функций для работы с многопоточностью
+и синхронизацией потоков. Она включает в себя функции для создания и управления
+потоками, работы с мьютексами, семафорами, условными переменными и спинлоками.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_ThreadNew
+
+ BH_Thread *BH_ThreadNew(size_t stack,
+                         BH_ThreadCallback callback,
+                         void *data);
+
+Создаёт поток с заданным размером стека I<stack>, исполняемой функцией
+I<callback> и данными I<data>.
+
+В случае успеха возвращает указатель на объект потока, иначе NULL.
+
+
+=head2 BH_ThreadJoin
+
+ int BH_ThreadJoin(BH_Thread *thread);
+
+Блокирует исполнение текущего потока до завершения другого потока.
+
+По завершении выполнения потока ресурсы I<thread> освобождаются.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_ThreadDetach
+
+ int BH_ThreadDetach(BH_Thread *thread);
+
+Отсоединяет поток от текущего процесса.
+
+По завершении выполнения потока ресурсы I<thread> освобождаются.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_MutexNew
+
+ BH_Mutex *BH_MutexNew(void);
+
+Создаёт мьютекс.
+
+В случае успеха возвращает указатель на объект мьютекса, иначе NULL.
+
+
+=head2 BH_MutexFree
+
+ void BH_MutexFree(BH_Mutex *mutex);
+
+Уничтожает мьютекс.
+
+Если мьютекс захвачен, поведение не определено.
+
+
+=head2 BH_MutexLock
+
+ int BH_MutexLock(BH_Mutex *mutex);
+
+Захватывает мьютекс.
+
+Если мьютекс уже был захвачен, поведение не определено.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_MutexUnlock
+
+ int BH_MutexUnlock(BH_Mutex *mutex);
+
+Отпускает мьютекс.
+
+Если мьютекс захвачен другим потоком, поведение не определено.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_MutexLockTry
+
+ int BH_MutexLockTry(BH_Mutex *mutex);
+
+Производит попытку захвата мьютекса.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_SemaphoreNew
+
+ BH_Semaphore *BH_SemaphoreNew(int value);
+
+Создаёт семафор с заданным изначальным значением I<value>.
+
+В случае успеха возвращает указатель на объект семафора, иначе NULL.
+
+
+=head2 BH_SemaphoreFree
+
+ void BH_SemaphoreFree(BH_Semaphore *semaphore);
+
+Уничтожает семафор.
+
+
+=head2 BH_SemaphorePost
+
+ int BH_SemaphorePost(BH_Semaphore *semaphore);
+
+Увеличивает значение семафора на 1.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_SemaphoreWait
+
+ int BH_SemaphoreWait(BH_Semaphore *semaphore);
+
+Уменьшает значение семафора на 1.
+
+Если значение семафора равно 0, блокирует выполнение текущего потока до тех пор,
+пока значение семафора не станет больше 0.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_SemaphoreWaitTry
+
+ int BH_SemaphoreWaitTry(BH_Semaphore *semaphore);
+
+Пытается уменьшить значение семафора на 1.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_SemaphoreWaitFor
+
+ int BH_SemaphoreWaitFor(BH_Semaphore *semaphore,
+                         uint32_t timeout);
+
+Пытается уменьшить значение семафора на 1 в пределах заданного времени
+I<timeout>.
+
+Параметр I<timeout> задаёт время ожидания в миллисекундах.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_ConditionNew
+
+ BH_Condition *BH_ConditionNew(void);
+
+Создаёт новую условную переменную.
+
+В случае успеха возвращает указатель на объект условной переменной, иначе NULL.
+
+
+=head2 BH_ConditionFree
+
+ void BH_ConditionFree(BH_Condition *condition);
+
+Уничтожает условную переменную.
+
+Если условная переменная используется другими потоками, поведение не определено.
+
+
+=head2 BH_ConditionWait
+
+ int BH_ConditionWait(BH_Condition *condition,
+                      BH_Mutex *mutex);
+
+Блокирует исполнение текущего потока до тех пор, пока другой поток не 
+просигнализирует об изменении условия.
+
+В некоторых ситуациях сигнал об изменении условия может быть ложным.
+
+Параметр I<mutex> определяет мьютекс, который используется совместно с условной
+переменной.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_ConditionWaitFor
+
+ int BH_ConditionWaitFor(BH_Condition *condition,
+                         BH_Mutex *mutex,
+                         uint32_t timeout);
+
+Пытается заблокировать исполнение текущего потока до тех пор, пока другой поток
+не просигнализирует об изменении условия в пределах заданного времени 
+I<timeout>.
+
+В некоторых ситуациях сигнал об изменении условия может быть ложным.
+
+Параметр I<mutex> определяет мьютекс, который используется совместно с условной
+переменной.
+
+Параметр I<timeout> задаёт время ожидания в миллисекундах.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_ConditionSignal
+
+ int BH_ConditionSignal(BH_Condition *condition);
+
+Сигнализирует одному ожидающему потоку об изменении условия.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_ConditionBroadcast
+
+ int BH_ConditionBroadcast(BH_Condition *condition);
+
+Сигнализирует всем ожидающим потокам об изменении условия.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_SpinlockLock
+
+ void BH_SpinlockLock(int *lock);
+
+Блокирует спинлок.
+
+
+=head2 BH_SpinlockLockTry
+
+ int BH_SpinlockLockTry(int *lock);
+
+Пытается заблокировать спинлок.
+
+В случае успеха возвращает 0, иначе код ошибки.
+
+
+=head2 BH_SpinlockUnlock
+
+ void BH_SpinlockUnlock(int *lock);
+
+Разблокирует спинлок.
+
+
+=head2 BH_TssCreate
+
+ int BH_TssCreate(BH_GenericCallback callback);
+
+Создаёт новый TSS/TLS индекс с функцией очистки I<callback>.
+
+В случае успеха возвращает TSS/TLS индекс, иначе код ошибки.
+
+
+=head2 BH_TssRead
+
+ void *BH_TssRead(int index);
+
+Читает данные из слота TSS/TLS.
+
+
+=head2 BH_TssWrite
+
+ void BH_TssWrite(int index,
+                  void *value);
+
+Записывает данные I<value> в слот TSS/TLS.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Unicode.pod

@@ -0,0 +1,184 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Unicode - Работа с Unicode и UTF кодировками
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Unicode предоставляет набор функций для работы с различными
+кодировками Unicode, включая UTF-8, UTF-16 и UTF-32. Она позволяет
+преобразовывать символы в верхний и нижний регистр, а также кодировать и
+декодировать строки в указанных кодировках.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_UnicodeLower
+
+ uint32_t BH_UnicodeLower(uint32_t unit);
+
+Преобразует Unicode-код I<unit> в нижний регистр.
+
+Преобразование выполняется для символов в Basic Multilingual Plane (т. е. первые
+65 536 кодов).
+
+
+=head2 BH_UnicodeUpper
+
+ uint32_t BH_UnicodeUpper(uint32_t unit);
+
+Преобразует Unicode-код I<unit> в верхний регистр.
+
+Преобразование выполняется для символов в Basic Multilingual Plane (т. е. первые
+65 536 кодов).
+
+
+=head2 BH_UnicodeDecodeUtf8
+
+ size_t BH_UnicodeDecodeUtf8(const char *string,
+                             size_t size,
+                             uint32_t *unit);
+
+Декодирует UTF-8 последовательность из I<string> (с заданной длиной I<size>) и
+записывает код в I<unit>.
+
+Недопустимые последовательности UTF-8 будут преобразованы к коду -1.
+
+В случае успеха функция возвращает количество прочитанных байтов или 0, если
+I<string> содержит только часть последовательности.
+
+
+=head2 BH_UnicodeEncodeUtf8
+
+ size_t BH_UnicodeEncodeUtf8(uint32_t unit,
+                             char *string);
+
+Кодирует UTF-8 последовательность в I<string> из кода I<unit>.
+
+Предполагается, что строка содержит 4 байта свободного места.
+
+В случае успеха функция возвращает количество записанных байтов или 0.
+
+
+=head2 BH_UnicodeDecodeUtf16LE
+
+ size_t BH_UnicodeDecodeUtf16LE(const char *string,
+                                size_t size,
+                                uint32_t *unit);
+
+Декодирует UTF-16LE последовательность из I<string> (с заданной длиной I<size>)
+и записывает код в I<unit>.
+
+Недопустимые последовательности UTF-16LE будут преобразованы к коду -1.
+
+В случае успеха функция возвращает количество прочитанных байтов или 0, если
+I<string> содержит только часть последовательности.
+
+
+=head2 BH_UnicodeDecodeUtf16BE
+
+ size_t BH_UnicodeDecodeUtf16BE(const char *string,
+                                size_t size,
+                                uint32_t *unit);
+
+Декодирует UTF-16BE последовательность из I<string> (с заданной длиной I<size>)
+и записывает код в I<unit>.
+
+Недопустимые последовательности UTF-16BE будут преобразованы к коду -1.
+
+В случае успеха функция возвращает количество прочитанных байтов или 0, если
+I<string> содержит только часть последовательности.
+
+
+=head2 BH_UnicodeEncodeUtf16LE
+
+ size_t BH_UnicodeEncodeUtf16LE(uint32_t unit,
+                                char *string);
+
+Кодирует UTF-16LE последовательность в I<string> из кода I<unit>.
+
+Предполагается, что строка содержит 4 байта свободного места.
+
+В случае успеха функция возвращает количество записанных байтов или 0.
+
+
+=head2 BH_UnicodeEncodeUtf16BE
+
+ size_t BH_UnicodeEncodeUtf16BE(uint32_t unit,
+                                char *string);
+
+Кодирует UTF-16BE последовательность в I<string> из кода I<unit>.
+
+Предполагается, что строка содержит 4 байта свободного места.
+
+В случае успеха функция возвращает количество записанных байтов или 0.
+
+
+=head2 BH_UnicodeDecodeUtf32LE
+
+ size_t BH_UnicodeDecodeUtf32LE(const char *string,
+                                size_t size,
+                                uint32_t *unit);
+
+Декодирует UTF-32LE последовательность из I<string> (с заданной длиной I<size>)
+и записывает код в I<unit>.
+
+Недопустимые последовательности UTF-32LE будут преобразованы к коду -1.
+
+В случае успеха функция возвращает количество прочитанных байтов или 0, если
+I<string> содержит только часть последовательности.
+
+
+=head2 BH_UnicodeDecodeUtf32BE
+
+ size_t BH_UnicodeDecodeUtf32BE(const char *string,
+                                size_t size,
+                                uint32_t *unit);
+
+Декодирует UTF-32BE последовательность из I<string> (с заданной длиной I<size>)
+и записывает код в I<unit>.
+
+Недопустимые последовательности UTF-32BE будут преобразованы к коду -1.
+
+В случае успеха функция возвращает количество прочитанных байтов или 0, если
+I<string> содержит только часть последовательности.
+
+
+=head2 BH_UnicodeEncodeUtf32LE
+
+ size_t BH_UnicodeEncodeUtf32LE(uint32_t unit,
+                                char *string);
+
+Кодирует UTF-32LE последовательность в I<string> из кода I<unit>.
+
+Предполагается, что строка содержит 4 байта свободного места.
+
+В случае успеха функция возвращает количество записанных байтов или 0.
+
+
+=head2 BH_UnicodeEncodeUtf32BE
+
+ size_t BH_UnicodeEncodeUtf32BE(uint32_t unit,
+                                char *string);
+
+Кодирует UTF-32BE последовательность в I<string> из кода I<unit>.
+
+Предполагается, что строка содержит 4 байта свободного места.
+
+В случае успеха функция возвращает количество записанных байтов или 0.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Util.pod

@@ -0,0 +1,241 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Util - Вспомогательные функции
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Библиотека BH_Util предоставляет набор функций для работы с числами в форматах 
+little-endian и big-endian, а также для классификации значений с плавающей 
+точкой.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_ClassifyDouble
+
+ int BH_ClassifyDouble(double value);
+
+Классифицирует значение с плавающей точкой.
+
+Данная функция возвращает комбинацию из следующих значений:
+
+=over
+
+=item B<BH_FP_NORMAL>
+
+Значение является нормальным или субнормальным.
+
+=item B<BH_FP_ZERO>
+
+Значение является положительным или отрицательным нулём.
+
+=item B<BH_FP_INFINITE>
+
+Значение является положительной или отрицательной бесконечностью.
+
+=item B<BH_FP_NAN>
+
+Значение не является числом (NaN).
+
+=item B<BH_FP_NEGATIVE>
+
+Значение является отрицательным.
+
+=back
+
+
+=head2 BH_Read16LEu
+
+ uint16_t BH_Read16LEu(const char *buffer);
+
+Считывает целое 16-битное беззнаковое little-endian число из буфера.
+
+
+=head2 BH_Read16LEs
+
+ int16_t BH_Read16LEs(const char *buffer);
+
+Считывает целое 16-битное знаковое little-endian число из буфера.
+
+
+=head2 BH_Read32LEu
+
+ uint32_t BH_Read32LEu(const char *buffer);
+
+Считывает целое 32-битное беззнаковое little-endian число из буфера.
+
+
+=head2 BH_Read32LEs
+
+ int32_t BH_Read32LEs(const char *buffer);
+
+Считывает целое 32-битное знаковое little-endian число из буфера.
+
+
+=head2 BH_Read64LEu
+
+ uint64_t BH_Read64LEu(const char *buffer);
+
+Считывает целое 64-битное беззнаковое little-endian число из буфера.
+
+
+=head2 BH_Read64LEs
+
+ int64_t BH_Read64LEs(const char *buffer);
+
+Считывает целое 64-битное знаковое little-endian число из буфера.
+
+
+=head2 BH_Read16BEu
+
+ uint16_t BH_Read16BEu(const char *buffer);
+
+Считывает целое 16-битное беззнаковое big-endian число из буфера.
+
+
+=head2 BH_Read16BEs
+
+ int16_t BH_Read16BEs(const char *buffer);
+
+Считывает целое 16-битное знаковое big-endian число из буфера.
+
+
+=head2 BH_Read32BEu
+
+ uint32_t BH_Read32BEu(const char *buffer);
+
+Считывает целое 32-битное беззнаковое big-endian число из буфера.
+
+
+=head2 BH_Read32BEs
+
+ int32_t BH_Read32BEs(const char *buffer);
+
+Считывает целое 32-битное знаковое big-endian число из буфера.
+
+
+=head2 BH_Read64BEu
+
+ uint64_t BH_Read64BEu(const char *buffer);
+
+Считывает целое 64-битное беззнаковое big-endian число из буфера.
+
+
+=head2 BH_Read64BEs
+
+ int64_t BH_Read64BEs(const char *buffer);
+
+Считывает целое 64-битное знаковое big-endian число из буфера.
+
+
+=head2 BH_Write16LEu
+
+ void BH_Write16LEu(char *buffer, 
+                    uint16_t value);
+
+Записывает целое 16-битное беззнаковое little-endian число в буфер.
+
+
+=head2 BH_Write16LEs
+
+ void BH_Write16LEs(char *buffer, 
+                    int16_t value);
+
+Записывает целое 16-битное знаковое little-endian число в буфер.
+
+
+=head2 BH_Write32LEu
+
+ void BH_Write32LEu(char *buffer, 
+                    uint32_t value);
+
+Записывает целое 32-битное беззнаковое little-endian число в буфер.
+
+
+=head2 BH_Write32LEs
+
+ void BH_Write32LEs(char *buffer, 
+                    int32_t value);
+
+Записывает целое 32-битное знаковое little-endian число в буфер.
+
+
+=head2 BH_Write64LEu
+
+ void BH_Write64LEu(char *buffer, 
+                    uint64_t value);
+
+Записывает целое 64-битное беззнаковое little-endian число в буфер.
+
+
+=head2 BH_Write64LEs
+
+ void BH_Write64LEs(char *buffer, 
+                    int64_t value);
+
+Записывает целое 64-битное знаковое little-endian число в буфер.
+
+
+=head2 BH_Write16BEu
+
+ void BH_Write16BEu(char *buffer, 
+                    uint16_t value);
+
+Записывает целое 16-битное беззнаковое big-endian число в буфер.
+
+
+=head2 BH_Write16BEs
+
+ void BH_Write16BEs(char *buffer, 
+                    int16_t value);
+
+Записывает целое 16-битное знаковое big-endian число в буфер.
+
+
+=head2 BH_Write32BEu
+
+ void BH_Write32BEu(char *buffer, 
+                    uint32_t value);
+
+Записывает целое 32-битное беззнаковое big-endian число в буфер.
+
+
+=head2 BH_Write32BEs
+
+ void BH_Write32BEs(char *buffer, 
+                    int32_t value);
+
+Записывает целое 32-битное знаковое big-endian число в буфер.
+
+
+=head2 BH_Write64BEu
+
+ void BH_Write64BEu(char *buffer, 
+                    uint64_t value);
+
+Записывает целое 64-битное беззнаковое big-endian число в буфер.
+
+
+=head2 BH_Write64BEs
+
+ void BH_Write64BEs(char *buffer, 
+                    int64_t value);
+
+Записывает целое 64-битное знаковое big-endian число в буфер.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Vec2f.pod

@@ -0,0 +1,201 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Vec2f - двухмерный вещественный вектор
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math/Vec2f.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Vec2f предоставляет набор функций для работы с двухмерными
+векторами. Он включает в себя операции сложения, вычитания, умножения,
+масштабирования, вычисления скалярного и векторного произведения, а также
+нормализации векторов.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Vec2fAdd
+
+ void BH_Vec2fAdd(const float a[2],
+                  const float b[2],
+                  float out[2]);
+
+Вычисляет сумму двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fSub
+
+ void BH_Vec2fSub(const float a[2],
+                  const float b[2],
+                  float out[2]);
+
+Вычисляет разность двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fMul
+
+ void BH_Vec2fMul(const float a[2],
+                  const float b[2],
+                  float out[2]);
+
+Вычисляет результат перемножения двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fScale
+
+ void BH_Vec2fScale(const float a[2],
+                    float b,
+                    float out[2]);
+
+Вычисляет результат умножения вектора I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fMulAdd
+
+ void BH_Vec2fMulAdd(const float a[2],
+                     const float b[2],
+                     const float c[2],
+                     float out[2]);
+
+Вычисляет результат суммы I<c> и произведения векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fNegate
+
+ void BH_Vec2fNegate(const float in[2],
+                     float out[2]);
+
+Вычисляет противоположный вектор от вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fDot
+
+ float BH_Vec2fDot(const float a[2],
+                   const float b[2]);
+
+Вычисляет скалярное произведение векторов I<a> и I<b>.
+
+
+=head2 BH_Vec2fCross
+
+ float BH_Vec2fCross(const float a[2],
+                     const float b[2]);
+
+Вычисляет векторное произведение векторов I<a> и I<b>.
+
+
+=head2 BH_Vec2fLength
+
+ float BH_Vec2fLength(const float in[2]);
+
+Вычисляет длину вектора I<in>.
+
+
+=head2 BH_Vec2fNormal
+
+ void BH_Vec2fNormal(const float in[2],
+                     float out[2]);
+
+Вычисляет нормализованную форму вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fNormalEx
+
+ float BH_Vec2fNormalEx(const float in[2],
+                        float out[2]);
+
+Вычисляет нормализованную форму вектора I<in> и возвращает его исходную длину.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fMin
+
+ void BH_Vec2fMin(const float a[2],
+                  const float b[2],
+                  float out[2]);
+
+Вычисляет поэлементный минимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fMax
+
+ void BH_Vec2fMax(const float a[2],
+                  const float b[2],
+                  float out[2]);
+
+Вычисляет поэлементный максимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fLerp
+
+ void BH_Vec2fLerp(const float a[2],
+                   const float b[2],
+                   float t,
+                   float out[2]);
+
+Выполняет линейную интерполяцию между двумя векторами I<a> и I<b> с параметром
+I<t>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fProject
+
+ void BH_Vec2fProject(const float a[2],
+                      const float b[2],
+                      float out[2]);
+
+Вычисляет результат проекции вектора I<a> на вектор I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2fBarycentric
+
+ void BH_Vec2fBarycentric(const float a[2],
+                          const float b[2],
+                          const float c[2],
+                          float v,
+                          float w,
+                          float out[2]);
+
+Вычисляет вектор из барицентрических координат I<v>, I<w> и векторов точек I<a>,
+I<b>, I<c>.
+
+Вычисление происходит по формуле A + v*(B-A) + w*(C-A).
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Vec2i.pod

@@ -0,0 +1,115 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Vec2i - двухмерный целочисленный вектор
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Vec2i предоставляет набор функций для работы с двухмерными 
+целочисленными векторами.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Vec2iAdd
+
+ void BH_Vec2iAdd(const int a[2],
+                  const int b[2],
+                  int out[2]);
+
+Вычисляет сумму двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iSub
+
+ void BH_Vec2iSub(const int a[2],
+                  const int b[2],
+                  int out[2]);
+
+Вычисляет разность двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iMul
+
+ void BH_Vec2iMul(const int a[2],
+                  const int b[2],
+                  int out[2]);
+
+Вычисляет результат перемножения двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iScale
+
+ void BH_Vec2iScale(const int a[2],
+                    int b,
+                    int out[2]);
+
+Вычисляет результат умножения вектора I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iMulAdd
+
+ void BH_Vec2iMulAdd(const int a[2],
+                     const int b[2],
+                     const int c[2],
+                     int out[2]);
+
+Вычисляет результат суммы I<c> и результата перемножения векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iNegate
+
+ void BH_Vec2iNegate(const int in[2],
+                     int out[2]);
+
+Вычисляет противоположный вектор от вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iMin
+
+ void BH_Vec2iMin(const int a[2],
+                  const int b[2],
+                  int out[2]);
+
+Вычисляет поэлементный минимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec2iMax
+
+ void BH_Vec2iMax(const int a[2],
+                  const int b[2],
+                  int out[2]);
+
+Вычисляет поэлементный максимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Vec3f.pod

@@ -0,0 +1,202 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Vec3f - трёхмерный вещественный вектор
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Vec3f предоставляет набор функций для работы с трёхмерными
+векторами. Функции позволяют выполнять арифметические операции, вычислять
+скалярные и векторные произведения, нормализовать векторы, а также выполнять
+другие операции над векторами.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Vec3fAdd
+
+ void BH_Vec3fAdd(const float a[3],
+                  const float b[3],
+                  float out[3]);
+
+Вычисляет сумму двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fSub
+
+ void BH_Vec3fSub(const float a[3],
+                  const float b[3],
+                  float out[3]);
+
+Вычисляет разность двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fMul
+
+ void BH_Vec3fMul(const float a[3],
+                  const float b[3],
+                  float out[3]);
+
+Вычисляет результат перемножения двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fScale
+
+ void BH_Vec3fScale(const float a[3],
+                    float b,
+                    float out[3]);
+
+Вычисляет результат умножения вектора I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fMulAdd
+
+ void BH_Vec3fMulAdd(const float a[3],
+                     const float b[3],
+                     const float c[3],
+                     float out[3]);
+
+Вычисляет результат суммы I<c> и результата перемножения векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fNegate
+
+ void BH_Vec3fNegate(const float in[3],
+                     float out[3]);
+
+Вычисляет противоположный вектор от вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fDot
+
+ float BH_Vec3fDot(const float a[3],
+                   const float b[3]);
+
+Вычисляет скалярное произведение векторов I<a> и I<b>.
+
+
+=head2 BH_Vec3fCross
+
+ void BH_Vec3fCross(const float a[3],
+                    const float b[3],
+                    float out[3]);
+
+Вычисляет векторное произведение векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fLength
+
+ float BH_Vec3fLength(const float in[3]);
+
+Вычисляет длину вектора I<in>.
+
+
+=head2 BH_Vec3fNormal
+
+ void BH_Vec3fNormal(const float in[3],
+                     float out[3]);
+
+Вычисляет нормализованную форму вектора I<in>.
+
+
+=head2 BH_Vec3fNormalEx
+
+ float BH_Vec3fNormalEx(const float in[3],
+                        float out[3]);
+
+Вычисляет нормализованную форму вектора I<in> и возвращает его исходную длину.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fMin
+
+ void BH_Vec3fMin(const float a[3],
+                  const float b[3],
+                  float out[3]);
+
+Вычисляет поэлементный минимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fMax
+
+ void BH_Vec3fMax(const float a[3],
+                  const float b[3],
+                  float out[3]);
+
+Вычисляет поэлементный максимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fLerp
+
+ void BH_Vec3fLerp(const float a[3],
+                   const float b[3],
+                   float t,
+                   float out[3]);
+
+Выполняет линейную интерполяцию между двумя векторами I<a> и I<b> с параметром
+I<t>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fProject
+
+ void BH_Vec3fProject(const float a[3],
+                      const float b[3],
+                      float out[3]);
+
+Вычисляет результат проекции вектора I<a> на вектор I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3fBarycentric
+
+ void BH_Vec3fBarycentric(const float a[3],
+                          const float b[3],
+                          const float c[3],
+                          float v,
+                          float w,
+                          float out[3]);
+
+Вычисляет вектор из барицентрических координат I<v>, I<w> и векторов точек I<a>,
+I<b>, I<c>.
+
+Вычисление происходит по формуле A + v*(B-A) + w*(C-A).
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Vec3i.pod

@@ -0,0 +1,115 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Vec3i - трёхмерный целочисленный вектор
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Vec3i предоставляет набор функций для работы с трёхмерными
+целочисленными векторами.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Vec3iAdd
+
+ void BH_Vec3iAdd(const int a[3],
+                  const int b[3],
+                  int out[3]);
+
+Вычисляет сумму двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iSub
+
+ void BH_Vec3iSub(const int a[3],
+                  const int b[3],
+                  int out[3]);
+
+Вычисляет разность двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iMul
+
+ void BH_Vec3iMul(const int a[3],
+                  const int b[3],
+                  int out[3]);
+
+Вычисляет результат перемножения двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iScale
+
+ void BH_Vec3iScale(const int a[3],
+                    int b,
+                    int out[3]);
+
+Вычисляет результат умножения вектора I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iMulAdd
+
+ void BH_Vec3iMulAdd(const int a[3],
+                     const int b[3],
+                     const int c[3],
+                     int out[3]);
+
+Вычисляет результат суммы I<c> и результата перемножения векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iNegate
+
+ void BH_Vec3iNegate(const int in[3],
+                     int out[3]);
+
+Вычисляет противоположный вектор от вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iMin
+
+ void BH_Vec3iMin(const int a[3],
+                  const int b[3],
+                  int out[3]);
+
+Вычисляет поэлементный минимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec3iMax
+
+ void BH_Vec3iMax(const int a[3],
+                  const int b[3],
+                  int out[3]);
+
+Вычисляет поэлементный максимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Vec4f.pod

@@ -0,0 +1,193 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Vec4f - четырёхмерный вещественный вектор
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Vec4f предоставляет набор функций для работы с четырёхмерными
+векторами. Функции позволяют выполнять арифметические операции, нормализацию,
+вычисление скалярного произведения и другие математические операции над 
+векторами.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Vec4fAdd
+
+ void BH_Vec4fAdd(const float a[4],
+                  const float b[4],
+                  float out[4]);
+
+Вычисляет сумму двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fSub
+
+ void BH_Vec4fSub(const float a[4],
+                  const float b[4],
+                  float out[4]);
+
+Вычисляет разность двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fMul
+
+ void BH_Vec4fMul(const float a[4],
+                  const float b[4],
+                  float out[4]);
+
+Вычисляет результат перемножения двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fScale
+
+ void BH_Vec4fScale(const float a[4],
+                    float b,
+                    float out[4]);
+
+Вычисляет результат умножения вектора I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fMulAdd
+
+ void BH_Vec4fMulAdd(const float a[4],
+                     const float b[4],
+                     const float c[4],
+                     float out[4]);
+
+Вычисляет результат суммы I<c> и результата перемножения векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fNegate
+
+ void BH_Vec4fNegate(const float in[4],
+                     float out[4]);
+
+Вычисляет противоположный вектор от вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fDot
+
+ float BH_Vec4fDot(const float a[4],
+                   const float b[4]);
+
+Вычисляет скалярное произведение векторов I<a> и I<b>.
+
+
+=head2 BH_Vec4fLength
+
+ float BH_Vec4fLength(const float in[4]);
+
+Вычисляет длину вектора I<in>.
+
+
+=head2 BH_Vec4fNormal
+
+ void BH_Vec4fNormal(const float in[4],
+                     float out[4]);
+
+Вычисляет нормализованную форму вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fNormalEx
+
+ float BH_Vec4fNormalEx(const float in[4],
+                        float out[4]);
+
+Вычисляет нормализованную форму вектора I<in> и возвращает его исходную длину.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fMin
+
+ void BH_Vec4fMin(const float a[4],
+                  const float b[4],
+                  float out[4]);
+
+Вычисляет поэлементный минимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fMax
+
+ void BH_Vec4fMax(const float a[4],
+                  const float b[4],
+                  float out[4]);
+
+Вычисляет поэлементный максимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fLerp
+
+ void BH_Vec4fLerp(const float a[4],
+                   const float b[4],
+                   float t,
+                   float out[4]);
+
+Выполняет линейную интерполяцию между двумя векторами I<a> и I<b> с параметром
+I<t>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fProject
+
+ void BH_Vec4fProject(const float a[4],
+                      const float b[4],
+                      float out[4]);
+
+Вычисляет результат проекции вектора I<a> на вектор I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4fBarycentric
+
+ void BH_Vec4fBarycentric(const float a[4],
+                          const float b[4],
+                          const float c[4],
+                          float v,
+                          float w,
+                          float out[4]);
+
+Вычисляет вектор из барицентрических координат I<v>, I<w> и векторов точек I<a>,
+I<b>, I<c>.
+
+Вычисление происходит по формуле A + v*(B-A) + w*(C-A).
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>

doc/Manual/ru/BH_Vec4i.pod

@@ -0,0 +1,115 @@
+=encoding UTF-8
+
+
+=head1 НАИМЕНОВАНИЕ
+
+BH_Vec4i - четырёхмерный целочисленный вектор
+
+
+=head1 СИНТАКСИС
+
+ #include <BH/Math.h>
+ 
+ cc prog.c -o prog -lbh
+
+
+=head1 ОПИСАНИЕ
+
+Модуль BH_Vec4i предоставляет набор функций для работы с четырёхмерными 
+целочисленными векторами.
+
+
+=head1 API ВЫЗОВЫ
+
+
+=head2 BH_Vec4iAdd
+
+ void BH_Vec4iAdd(const int a[4],
+                  const int b[4],
+                  int out[4]);
+
+Вычисляет сумму двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iSub
+
+ void BH_Vec4iSub(const int a[4],
+                  const int b[4],
+                  int out[4]);
+
+Вычисляет разность двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iMul
+
+ void BH_Vec4iMul(const int a[4],
+                  const int b[4],
+                  int out[4]);
+
+Вычисляет результат перемножения двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iScale
+
+ void BH_Vec4iScale(const int a[4],
+                    int b,
+                    int out[4]);
+
+Вычисляет результат умножения вектора I<a> на значение I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iMulAdd
+
+ void BH_Vec4iMulAdd(const int a[4],
+                     const int b[4],
+                     const int c[4],
+                     int out[4]);
+
+Вычисляет результат суммы I<c> и результата перемножения векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iNegate
+
+ void BH_Vec4iNegate(const int in[4],
+                     int out[4]);
+
+Вычисляет противоположный вектор от вектора I<in>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iMin
+
+ void BH_Vec4iMin(const int a[4],
+                  const int b[4],
+                  int out[4]);
+
+Вычисляет поэлементный минимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head2 BH_Vec4iMax
+
+ void BH_Vec4iMax(const int a[4],
+                  const int b[4],
+                  int out[4]);
+
+Вычисляет поэлементный максимум двух векторов I<a> и I<b>.
+
+Параметр I<out> описывает результирующий вектор.
+
+
+=head1 СМ. ТАКЖЕ
+
+L<BH>