回到主题，记录一下镜面反射矩阵的推导。

在用Irrlicht和RTT做镜面效果的时候，用到了反射矩阵。 就是需要把摄相机镜像，渲染一个RT，贴到镜面模型上。这个其实还纠结了许久，因为之前做水面渲染的时候，水面是平的，很好计算摄相机在水面以下的位置。 但是换成镜面，就不一样了，因为镜面可能是任意面。 于是就需要一个通用的反射矩阵。

反射矩阵的计算是基于平面的，因为，任何反射，都需要一个反射面。

所以，我们先给出平面表示 Plane(nx,ny,nz,d); 其中(nx,ny,nz)已经单位化。

然后，我们假设空间中有任意一点P(x,y,z,1)

设这个点P以Plane为反射面的镜像点为P1(x1,y1,z1,w)。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

根据定理，我们知道， 若两个点以某一点为镜像，则两个点的坐标之和除以2，就刚好是中点。

这个理论我们用到这里的话， 那这个中点就刚好是平面上的一个点。 平面上的这个点就是 P(x,y,z,1) - (nx,ny,nz,0)*D .  其中D就是点P到平面的距离

而D=Plane dot P = (x*nx+y*ny+z*nz+d);

由上面的描述，我们马上想到，那么要求点P1的话，就是这样 

(P+P1)/2 = P(x,y,z,1) - (nx,ny,nz,0)*D

=> P1 = P(x,y,z,1) - 2(nx,ny,nz,0)*D

=>P1 = P(x,y,z,1) - 2(nx,ny,nz,0)*(x*nx+y*ny+z*nz+d)

换成矩阵形式则为

                            ｜1-2*nx*nx   -2*nx*ny         -2*nx*nz         0  |

                             | -2*ny*nx     1 - 2*ny*ny     -2*ny*nz         0  |

P1 = {x,y,z,1}   x   | -2*nz*nx     -2*nz*ny         1-2*nz*nz        0  |

                             | -2*d*nx      -2*d*ny           -2*d*nz           1  |

大功告成

btw:这是行主矩阵表示法

剖析 epoll ET/LT 触发方式的性能差异误解（定性分析）

平时大家使用 epoll 时都知道其事件触发模式有默认的 level-trigger 模式和通过 EPOLLET 启用的 edge-trigger 模式两种。从 epoll 发展历史来看，它刚诞生时只有 edge-trigger 模式，后来因容易产生 race-cond 且不易被开发者理解，又增加了 level-trigger 模式并作为默认处理方式。

二者的差异在于 level-trigger 模式下只要某个 fd 处于 readable/writable 状态，无论什么时候进行 epoll_wait 都会返回该 fd；而 edge-trigger 模式下只有某个 fd 从 unreadable 变为 readable 或从 unwritable 变为 writable 时，epoll_wait 才会返回该 fd。

通常的误区是：level-trigger 模式在 epoll 池中存在大量 fd 时效率要显著低于 edge-trigger 模式。

但从 kernel 代码来看，edge-trigger/level-trigger 模式的处理逻辑几乎完全相同，差别仅在于 level-trigger 模式在 event 发生时不会将其从 ready list 中移除，略为增大了 event 处理过程中 kernel space 中记录数据的大小。

然而，edge-trigger 模式一定要配合 user app 中的 ready list 结构，以便收集已出现 event 的 fd，再通过 round-robin 方式挨个处理，以此避免通信数据量很大时出现忙于处理热点 fd 而导致非热点 fd 饿死的现象。统观 kernel 和 user space，由于 user app 中 ready list 的实现千奇百怪，不一定都经过仔细的推敲优化，因此 edge-trigger 的总内存开销往往还大于 level-trigger 的开销。

一般号称 edge-trigger 模式的优势在于能够减少 epoll 相关系统调用，这话不假，但 user app 里可不是只有 epoll 相关系统调用吧？为了绕过饿死问题，edge-trigger 模式的 user app 要自行进行 read/write 循环处理，这其中增加的系统调用和减少的 epoll 系统调用加起来，有谁能说一定就能明显地快起来呢？

实际上，epoll_wait 的效率是 O(ready fd num) 级别的，因此 edge-trigger 模式的真正优势在于减少了每次 epoll_wait 可能需要返回的 fd 数量，在并发 event 数量极多的情况下能加快 epoll_wait 的处理速度，但别忘了这只是针对 epoll 体系自己而言的提升，与此同时 user app 需要增加复杂的逻辑、花费更多的 cpu/mem 与其配合工作，总体性能收益究竟如何？只有实际测量才知道，无法一概而论。不过，为了降低处理逻辑复杂度，常用的事件处理库大部分都选择了 level-trigger 模式（如 libevent、boost::asio等）

结论：
• epoll 的 edge-trigger 和 level-trigger 模式处理逻辑差异极小，性能测试结果表明常规应用场景 中二者性能差异可以忽略。
• 使用 edge-trigger 的 user app 比使用 level-trigger 的逻辑复杂，出错概率更高。
• edge-trigger 和 level-trigger 的性能差异主要在于 epoll_wait 系统调用的处理速度，是否是 user app 的性能瓶颈需要视应用场景而定，不可一概而论。

欢迎就此话题进行深入调研、讨论！

参考资料：
• linux kernel source：fs/eventpoll.c
• “Comparing and Evaluating epoll, select, and poll Event
Mechanisms”：http://bcr2.uwaterloo.ca/~brecht/papers/getpaper.php?file=ols-2004.pdf
• “Edge-triggered interfaces are too difficult?”：http://lwn.net/Articles/25137/

By QingWu

这里不是主要说内存池，只是觉得这个内存池中的指针用得很飘逸！

 1template <class T,int AllocSize = 50>   
 2class MemPool   
 3{   
 4public:   
 5    static void* operator new(size_t allocLength)   
 6    {   
 7        if(!mStartPotinter)   
 8        {   
 9            MyAlloc();   
10        }   
11        //将当前指向空闲内存起始地址作为反回地址   
12        unsigned char* p = mStartPotinter;   
13        //取出空闲区域前4字节的值，赋值给空闲地址   
14        //因为前四字节中存放了下一个BLOCK的地址   
15        mStartPotinter = *(unsigned char**)mStartPotinter;   
16        return p;   
17    }   
18  
19    static void operator delete(void* deleteP)   
20    {   
21//      assert(deletePointer);   
22        *(unsigned char**)deleteP = mStartPotinter;   
23        mStartPotinter = (unsigned char*)deleteP;   
24    }   
25  
26    static void MyAlloc()   
27    {   
28        //预分配内存   
29        mStartPotinter = new unsigned char[sizeof(T)*AllocSize];   
30        //构造BLOCK之间的关系    
31        //每个BLOCK的前4BYTE存放了下一个BLOCK的地址   
32        unsigned char** next = (unsigned char**)mStartPotinter;   
33        unsigned char* p = mStartPotinter;   
34  
35        for(int i = 0; i< AllocSize;++i)   
36        {   
37            p +=sizeof(T);//步进   
38            *next = p;//赋值   
39            next = (unsigned char**)p;//步进   
40        }   
41        *next = NULL;   
42    }   
43  
44    static unsigned char* mStartPotinter;   
45};   
46  
47template <class T,int AllocSize>   
48unsigned char* MemPool<T,AllocSize>::mStartPotinter = NULL;  
49
50
51本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wqjqepr/archive/2010/05/03/5552322.aspx

简单提示一下： unsigned char** next = (unsigned char**)mStartPotinter;

mStartPotinter作为二维指针的时候，相当于是一系列的unsigned char* [].

对于第一个 *next 相当于(unsigned char*)mStartPointer[0].

第二个相当于(unsigned char*)mStartPointer[sizeof(T)*1];

第三个相当于(unsigned char*)mStartPointer[sizeof(T)*2];

所以，构造BLOCK之间关系的时候，也可以写成

1for(int i = 0; i< AllocSize;++i)   
2{   
3 p +=sizeof(T);//步进   
4 unsigned char* pp = (unsigned char*)(p[sizeof(T)*i]);   
5 pp = p;//赋值   
6} 

不想多解释了，累。估计多看几分种啥都明白了！

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。
下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。
一般继承（无虚函数覆盖）
下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：
 

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：
对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：
1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。
我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。
一般继承（有虚函数覆盖）
覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：
 

我们从表中可以看到下面几点，
1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
2）没有被覆盖的函数依旧。
这样，我们就可以看到对于下面这样的程序，
Base *b = new Derive();
b->f();
由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。
多重继承（无虚函数覆盖）
下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：
1） 每个父类都有自己的虚表。
2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）
这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。
多重继承（有虚函数覆盖）
下面我们再来看看，如果发生虚函数覆盖的情况。
下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：
 

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：
Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()
安全性
每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。
一、通过父类型的指针访问子类自己的虚函数
我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：
Base1 *b1 = new Derive();
b1->f1(); //编译出错
任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）
二、访问non-public的虚函数
另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。
如：
class Base {
private:
virtual void f() { cout << "Base::f" << endl; }
};
class Derive : public Base{
};
typedef void(*Fun)(void);
void main() {
Derive d;
Fun pFun = (Fun)*((int*)*(int*)(&d)+0);
pFun();
}

前些天，编程序是用到了很久以前写的C程序，想把里面的函数利用起来，连接发现出现了找不到具体函数的错误：

以下是假设旧的C程序库

C的头文件

/*-----------c.h--------------*/
#ifndef _C_H_
#define _C_H_
extern int add(int x, int y);
#endif

C的源文件

/*-----------c.c--------------*/
int add(int x, int y){
	return x+y;
}

C++的调用

/*-----------cpp.cpp--------------*/
#include "c.h"
void main()
{
	add(1, 0);
}

这样编译会产生错误cpp.obj : error LNK2001: unresolved external symbol "int __cdecl add(int,int)" (?add@@YAHHH@Z)，原因是找不到add的目标模块

这才令我想起C++重载的函数命名方式和C函数的命名方式，让我们回顾一下：C中函数编译后命名会在函数名前加以"_",比如add函数编译成obj文件时的实际命名为_add，而c++命名则不同，为了实现函数重载同样的函数名add因参数的不同会被编译成不同的名字

例如

int add(int , int)==>add@@YAHHH@Z,

float add(float , float )==>add@@YAMMM@Z,

以上是VC6的命名方式，不同的编译器会不同，总之不同的参数同样的函数名将编译成不同目标名，以便于函数重载是调用具体的函数。

编译cpp.cpp中编译器在cpp文件中发现add(1, 0);的调用而函数声明为extern int add(int x, int y);编译器就决定去找add@@YAHHH@Z，可惜他找不到，因为C的源文件把extern int add(int x, int y);编译成_add了；

为了解决这个问题C++采用了extern "C",这就是我们的主题，想要利用以前的C程序库，那么你就要学会它，我们可以看以下标准头文件你会发现，很多头文件都有以下的结构

#ifndef __H
#define __H
#ifdef __cplusplus
extern "C" {
#endif

extern int f1(int, int);
extern int f2(int, int);
extern int f3(int, int);

	
#ifdef __cplusplus
}
#endif

#endif /*__H*/

如果我们仿制该头文件可以得到

#ifndef _C_H_
#define _C_H_
#ifdef __cplusplus
extern "C" {
#endif

extern int add(int, int);

#ifdef __cplusplus
}
#endif

#endif /* _C_H_ */ 

这样编译

/*-----------c.c--------------*/
int add(int x, int y){
return x+y;
}

这时源文件为*.c，__cplusplus没有被定义，extern "C" {}这时没有生效对于C他看到只是extern int add(int, int);
add函数编译成_add(int, int);

而编译c++源文件

/*-----------cpp.cpp--------------*/
#include "c.h"
void main()
{
add(1, 0);
}
这时源文件为*.cpp,__cplusplus被定义,对于C++他看到的是extern "C" {extern int add(int, int);}编译器就会知道 add(1, 0);调用的C风格的函数，就会知道去c.obj中找_add(int, int)而不是add@@YAHHH@Z；

通过例子学习Lua(1) ---- Hello World

1.前言
游戏中少不了用到脚本语言. Lua是一种和C/C++结合非常紧密的脚本语言，效率极高。
一般是对时间要求比较高的地方用C++写，而经常需要改动的地方用Lua写。

偶最近在学习Lua, 所以写出心得和大家共享. Lua是一种完全免费的脚本语言,
它的官方网站在http://www.lua.org.在网站上可以下载到lua的源码, 没有可
执行版本, 不过不用担心, 因为lua源码可以在任何一种C/C++的编译器上编译.

如果要学习Lua, 官方网站上的Reference是必备的，上面有每个命令的用法，非常详
细。
参考手册 http://www.lua.org/manual/5.0/
作者写的Programming in Lua http://www.lua.org/pil/

2.编译
如果用的VC, 可以下载所需的project文件,地址在
http://sourceforge.net/project/showfiles.php?group_id=32250&package_id=115604
偶用的是cygwin和linux, 打入以下命令即可,
tar -zxvf lua-5.0.2.tar.gz
cd lua-5.0.2
sh ./configure
make
这样就OK了。
为了以后使用方便，最好把bin目录加入到path里面。

3."Hello, world!"
现在开始偶们的第一个小程序"Hello, world!"
把以下程序打入文件e01.lua

例1:e01.lua
-- Hello World in Lua
print("Hello World.")

Lua有两种执行方式，一种是嵌入到C程序中执行，还有一种是直接从命令行方式下执
行。
这里为了调试方便，采用第二种方式，执行命令 lua e01.lua

输出结果应该是：
Hello World.

4.程序说明
第一行 -- Hello World in Lua
这句是注释，其中--和C++中的//意思是一样的
第二行 print("Hello World.")
调用lua内部命令print，输出"Hello World."字符串到屏幕，Lua中的字符串全部是
由"括起来的。
这个命令是一个函数的调用，print是lua的一个函数，而"Hello World."是print的参
数。

5.试试看
在Lua中有不少字符串的处理操作，本次的课后试试看的内容就是，找出连接两个字符串
的操作，
并且print出来。
--

通过例子学习Lua(2) --- Lua基础

1. 函数的使用
以下程序演示了如何在Lua中使用函数, 及局部变量
例e02.lua
-- functions
function pythagorean(a, b)   
       local c2 = a^2 + b^2   
       return sqrt(c2)
end
print(pythagorean(3,4))

运行结果
5

程序说明
在Lua中函数的定义格式为:
function 函数名(参数)
       ...
end
与Pascal语言不同, end不需要与begin配对, 只需要在函数结束后打个end就可以了.
本例函数的作用是已知直角三角形直角边, 求斜边长度. 参数a,b分别表示直角边长,
在函数内定义了local形变量用于存储斜边的平方. 与C语言相同, 定义在函数内的代
码不会被直接执行, 只有主程序调用时才会被执行.
local表示定义一个局部变量, 如果不加local刚表示c2为一个全局变量, local的作用域
是在最里层的end和其配对的关键字之间, 如if ... end, while ... end等。全局变量
的
作用域是整个程序。

2. 循环语句
例e03.lua
-- Loops
for i=1,5 do   
       print("i is now " .. i)
end

运行结果
i is now 1
i is now 2
i is now 3
i is now 4
i is now 5

程序说明
这里偶们用到了for语句
for 变量 = 参数1, 参数2, 参数3 do
       循环体
end
变量将以参数3为步长, 由参数1变化到参数2
例如:   
for i=1,f(x) do print(i) end
for i=10,1,-1 do print(i) end

这里print("i is now " .. i)中，偶们用到了..，这是用来连接两个字符串的，
偶在(1)的试试看中提到的，不知道你们答对了没有。
虽然这里i是一个整型量，Lua在处理的时候会自动转成字符串型，不需偶们费心。

3. 条件分支语句
例e04.lua
-- Loops and conditionals
for i=1,5 do
       print(“i is now “ .. i)
         if i < 2 then       
               print(“small”)   
         elseif i < 4 then       
               print(“medium”)   
         else       
               print(“big”)   
         end
end

运行结果
i is now 1
small
i is now 2
medium
i is now 3
medium
i is now 4
big
i is now 5
big

程序说明
if else用法比较简单, 类似于C语言, 不过此处需要注意的是整个if只需要一个end,
哪怕用了多个elseif, 也是一个end.
例如
    if op == "+" then
      r = a + b
    elseif op == "-" then
      r = a - b
    elseif op == "*" then
      r = a*b
    elseif op == "/" then
      r = a/b
    else
      error("invalid operation")
    end

4.试试看
Lua中除了for循环以外, 还支持多种循环, 请用while...do和repeat...until改写本文
中的for程序

--
通过例子学习Lua(3) ---- 数据结构

1.简介
Lua语言只有一种基本数据结构, 那就是table, 所有其他数据结构如数组啦,
类啦, 都可以由table实现.

2.table的下标
例e05.lua
-- Arrays
myData = {}
myData[0] = “foo”
myData[1] = 42

-- Hash tables
myData[“bar”] = “baz”

-- Iterate through the
-- structure
for key, value in myData do
print(key .. “=“ .. value)
end

输出结果
0=foo
1=42
bar=baz

程序说明
首先定义了一个table myData={}, 然后用数字作为下标赋了两个值给它. 这种
定义方法类似于C中的数组, 但与数组不同的是, 每个数组元素不需要为相同类型,
就像本例中一个为整型, 一个为字符串.

程序第二部分, 以字符串做为下标, 又向table内增加了一个元素. 这种table非常
像STL里面的map. table下标可以为Lua所支持的任意基本类型, 除了nil值以外.

Lua对Table占用内存的处理是自动的, 如下面这段代码
a = {}
a["x"] = 10
b = a -- `b' refers to the same table as `a'
print(b["x"]) --> 10
b["x"] = 20
print(a["x"]) --> 20
a = nil -- now only `b' still refers to the table
b = nil -- now there are no references left to the table
b和a都指向相同的table, 只占用一块内存, 当执行到a = nil时, b仍然指向table,
而当执行到b=nil时, 因为没有指向table的变量了, 所以Lua会自动释放table所占内存

3.Table的嵌套
Table的使用还可以嵌套，如下例
例e06.lua
-- Table ‘constructor’
myPolygon = {
color=“blue”,
thickness=2,
npoints=4;
{x=0, y=0},
{x=-10, y=0},
{x=-5, y=4},
{x=0, y=4}
}

-- Print the color
print(myPolygon[“color”])

-- Print it again using dot
-- notation
print(myPolygon.color)

-- The points are accessible
-- in myPolygon[1] to myPolygon[4]

-- Print the second point’s x
-- coordinate
print(myPolygon[2].x)

程序说明
首先建立一个table, 与上一例不同的是，在table的constructor里面有{x=0,y=0},
这是什么意思呢？ 这其实就是一个小table, 定义在了大table之内, 小table的
table名省略了.
最后一行myPolygon[2].x，就是大table里面小table的访问方式.

--
通过例子学习Lua(4) -- 函数的调用

1.不定参数
例e07.lua
-- Functions can take a
-- variable number of
-- arguments.
function funky_print (...)
for i=1, arg.n do
print("FuNkY: " .. arg)
end
end

funky_print("one", "two")

运行结果
FuNkY: one
FuNkY: two

程序说明
* 如果以...为参数, 则表示参数的数量不定.
* 参数将会自动存储到一个叫arg的table中.
* arg.n中存放参数的个数. arg[]加下标就可以遍历所有的参数.


2.以table做为参数
例e08.lua
-- Functions with table
-- parameters
function print_contents(t)
for k,v in t do
print(k .. "=" .. v)
end
end
print_contents{x=10, y=20}

运行结果
x=10
y=20

程序说明
* print_contents{x=10, y=20}这句参数没加圆括号, 因为以单个table为参数的时候,
不需要加圆括号
* for k,v in t do 这个语句是对table中的所有值遍历, k中存放名称, v中存放值


3.把Lua变成类似XML的数据描述语言
例e09.lua
function contact(t)
-- add the contact ‘t’, which is
-- stored as a table, to a database
end

contact {
name = "Game Developer",
email = "hack@ogdev.net",
url = "http://www.ogdev.net,
quote = [[
There are
10 types of people
who can understand binary.]]
}

contact {
-- some other contact
}

程序说明
* 把function和table结合, 可以使Lua成为一种类似XML的数据描述语言
* e09中contact{...}, 是一种函数的调用方法, 不要弄混了
* [[...]]是表示多行字符串的方法
* 当使用C API时此种方式的优势更明显, 其中contact{..}部分可以另外存成一配置文
件

4.试试看
想想看哪些地方可以用到例e09中提到的配置方法呢？

--

通过例子学习Lua(5) ---- Lua与C交互入门

1.简介

Lua与C/C++结合是很紧密的, Lua与C++交互是建立在Lua与C的基础上的, 所
以偶先从Lua与C讲起.

正如第一讲所说, 运行Lua程序或者说调用Lua主要有两种方式:
* 通过命令行执行"Lua"命令
* 通过Lua的C库
虽然此前偶们一直用第一种方式, 但偶要告诉你, 通过Lua的C库执行才是游戏中
常用的方式.

2.Lua的C库

Lua的C库可以做为Shared Library调用, 但一般开发游戏时会把Lua的所有源程序
都包含在内, 并不把Lua编译成共享库的形式. 因为Lua程序只有100多K, 而且几乎
可以在任何编译器下Clean Compile. 带Lua源程序的另一个好处时, 可以随时对Lua
本身进行扩充, 增加偶们所需的功能.

Lua的C库提供一系列API:
* 管理全局变量
* 管理tables
* 调用函数
* 定义新函数, 这也可以完全由C实现
* 垃圾收集器Garbage collector, 虽然Lua可以自动进行, 但往往不是立即执行的,
所以对实时性要求比较高的程序, 会自己调用垃圾收集器
* 载入并执行Lua程序, 这也可以由Lua自身实现
* 任何Lua可以实现的功能, 都可以通过Lua的C API实现, 这对于优化程序的运行速度
有帮助. 经常调用的共用的Lua程序片断可以转成C程序, 以提高效率. 连Lua都是C写的
还有什么C不能实现呢?

3.Lua与C集成的例子
例e10.c
/* A simple Lua interpreter. */
#include <stdio.h>
#include <lua.h>
int main(int argc, char *argv[]) {
char line[BUFSIZ];
lua_State *L = lua_open(0);
while (fgets(line, sizeof(line), stdin) != 0)
lua_dostring(L, line);
lua_close(L);
return 0;
}

编译
Linux/Cygwin
* 先编译Lua, 并把头文件放入include路径
* gcc e10.c -llua -llualib -o e10

VC6/VC2003
* 先编译Lua, 在Option中设置头文件和库文件路径
* 新建工程,在工程配置中加入附加库lua.lib和lualib.lib
* 编译成exe

运行结果
本程序的功能是实现一个Lua解释器, 输入的每行字符都会被解释成Lua并执行.

程序说明
* #include <lua.h> 包含lua头文件, 然后才可以使用API
* lua_State *L = lua_open(0) 打开一个Lua执行器
* fgets(line, sizeof(line), stdin) 从标准输入里读入一行
* lua_dostring(L, line) 执行此行
* lua_close(L) 关闭Lua执行器


例e11.c
/* Another simple Lua interpreter. */
#include <stdio.h>
#include <lua.h>
#include <lualib.h>
int main(int argc, char *argv[]) {
char line[BUFSIZ];
lua_State *L = lua_open(0);
lua_baselibopen(L);
lua_iolibopen(L);
lua_strlibopen(L);
lua_mathlibopen(L);
while (fgets(line, sizeof(line), stdin) != 0)
lua_dostring(L, line);
lua_close(L);
return 0;
}

运行结果
本程序的功能是实现一个Lua解释器, 输入的每行字符都会被解释成Lua并执行.
与上例不同的是, 本例调用了Lua的一些标准库.

程序说明
* #include <lualib.h> 包含Lua的标准库
* 以下这几行是用来读入Lua的一些库, 这样偶们的Lua程序就可以有更多的功能.
lua_baselibopen(L);
lua_iolibopen(L);
lua_strlibopen(L);
lua_mathlibopen(L);

4.试试看
把上面两个小例子在你熟悉的编译器中编译执行, 并试试能否与Lua源码树一起编译

--
通过例子学习Lua(6) ---- C/C++中用Lua函数

参考英文文档http://tonyandpaige.com/tutorials/lua2.html

1.简介
偶们这次主要说说怎么由Lua定义函数, 然后在C或者C++中调用. 这里偶们
暂不涉及C++的对象问题, 只讨论调用函数的参数, 返回值和全局变量的使用.

2.
这里偶们在e12.lua里先定义一个简单的add(), x,y为加法的两个参数,
return 直接返回相加后的结果.

例e12.lua
-- add two numbers
function add ( x, y )
return x + y
end

在前一次里, 偶们说到 lua_dofile() 可以直接在C中执行lua文件. 因为偶们
这个程序里只定义了一个add()函数, 所以程序执行后并不直接结果, 效果相当
于在C中定义了一个函数一样.

Lua的函数可以有多个参数, 也可以有多个返回值, 这都是由栈(stack)实现的.
需要调用一个函数时, 就把这个函数压入栈, 然后顺序压入所有参数, 然后用
lua_call()调用这个函数. 函数返回后, 返回值也是存放在栈中. 这个过程和
汇编执行函数调用的过程是一样的.

例e13.cpp 是一个调用上面的Lua函数的例子
#include <stdio.h>

extern "C" { // 这是个C++程序, 所以要extern "C",
// 因为lua的头文件都是C格式的
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

/* the Lua interpreter */
lua_State* L;

int luaadd ( int x, int y )
{
int sum;

/* the function name */
lua_getglobal(L, "add");

/* the first argument */
lua_pushnumber(L, x);

/* the second argument */
lua_pushnumber(L, y);

/* call the function with 2
arguments, return 1 result */
lua_call(L, 2, 1);

/* get the result */
sum = (int)lua_tonumber(L, -1);
lua_pop(L, 1);

return sum;
}

int main ( int argc, char *argv[] )
{
int sum;

/* initialize Lua */
L = lua_open();

/* load Lua base libraries */
lua_baselibopen(L);

/* load the script */
lua_dofile(L, "e12.lua");

/* call the add function */
sum = luaadd( 10, 15 );

/* print the result */
printf( "The sum is %d\n", sum );

/* cleanup Lua */
lua_close(L);

return 0;
}

程序说明:
main中过程偶们上次已经说过了, 所以这次只说说luaadd的过程
* 首先用lua_getglobal()把add函数压栈
* 然后用lua_pushnumber()依次把x,y压栈
* 然后调用lua_call(), 并且告诉程序偶们有两个参数一个返回值
* 接着偶们从栈顶取回返回值, 用lua_tonumber()
* 最后偶们用lua_pop()把返回值清掉

运行结果:
The sum is 25

编译方法
Linux下把程序存成e13.cpp
g++ e13.cpp -llua -llualib -o e13
./e13

VC下编译方法
* 首先建立一个空的Win32 Console Application Project
* 把e13.cpp加入工程中
* 点project setting,然后设置link选项, 再加上lua.lib lualib.lib两个额外的库
* 最后编译

建立好的project可以在这里下载
VC http://tonyandpaige.com/tutorials/luaadd.zip
Linux http://tonyandpaige.com/tutorials/luaadd.tar.gz

3.全局变量
上面偶们用到了lua_getglobal()但并没有详细讲, 这里偶们再举两个小例子来说下全局
变量
lua_getglobal()的作用就是把lua中全局变量的值压入栈
lua_getglobal(L, "z");
z = (int)lua_tonumber(L, 1);
lua_pop(L, 1);
假设Lua程序中定义了一个全局变量z, 这段小程序就是把z的值取出放入C的变量z中.

另外Lua中还有一个对应的函数lua_setglobal(), 作用是用栈顶的值填充指定的全局变
量
lua_pushnumber(L, 10);
lua_setglobal(L, "z");
例如这段小程序就是把lua中的全局变量z设为10, 如果lua中未定义z的话, 就会自动创
建一个
全局变量z并设为10.

4.试试看
自己写个函数用C/C++来调用下试试

--
通过例子学习Lua(7) ---- Lua中调用C/C++函数

1.前言
上次偶说到从C/C++中调用Lua的函数, 然后就有朋友问从Lua中如何调用C/C++的
函数, 所以偶们这次就来说说这个问题. 首先偶们会在C++中建立一个函数, 然后
告知Lua有这个函数, 最后再执行它. 另外, 由于函数不是在Lua中定义的, 所以
无法确定函数的正确性, 可能在调用过程中会出错, 因此偶们还会说说Lua出错处
理的问题.

2.Lua中调用C函数
在lua中是以函数指针的形式调用函数, 并且所有的函数指针都必须满足如下此种
类型:
typedef int (*lua_CFunction) (lua_State *L);

也就是说, 偶们在C++中定义函数时必须以lua_State为参数, 以int为返回值才能
被Lua所调用. 但是不要忘记了, 偶们的lua_State是支持栈的, 所以通过栈可以
传递无穷个参数, 大小只受内存大小限制. 而返回的int值也只是指返回值的个数
真正的返回值都存储在lua_State的栈中. 偶们通常的做法是做一个wrapper, 把
所有需要调用的函数都wrap一下, 这样就可以调用任意的函数了.

下面这个例子是一个C++的average()函数, 它将展示如何用多个参数并返回多个值

例e14.cpp
#include <stdio.h>

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

/* the Lua interpreter */
lua_State* L;

static int average(lua_State *L)
{
/* get number of arguments */
int n = lua_gettop(L);
double sum = 0;
int i;

/* loop through each argument */
for (i = 1; i <= n; i++)
{
/* total the arguments */
sum += lua_tonumber(L, i);
}

/* push the average */
lua_pushnumber(L, sum / n);

/* push the sum */
lua_pushnumber(L, sum);

/* return the number of results */
return 2;
}

int main ( int argc, char *argv[] )
{
/* initialize Lua */
L = lua_open();

/* load Lua base libraries */
lua_baselibopen(L);

/* register our function */
lua_register(L, "average", average);

/* run the script */
lua_dofile(L, "e15.lua");

/* cleanup Lua */
lua_close(L);

return 0;
}

例e15.lua
-- call a C++ function

avg, sum = average(10, 20, 30, 40, 50)

print("The average is ", avg)
print("The sum is ", sum)


程序说明:
* lua_gettop()的作用是返回栈顶元素的序号. 由于Lua的栈是从1开始编号的,
所以栈顶元素的序号也相当于栈中的元素个数. 在这里, 栈中元素的个数就
是传入的参数个数.
* for循环计算所有传入参数的总和. 这里用到了数值转换lua_tonumber().
* 然后偶们用lua_pushnumber()把平均值和总和push到栈中.
* 最后, 偶们返回2, 表示有两个返回值.
* 偶们虽然在C++中定义了average()函数, 但偶们的Lua程序并不知道, 所以需
要在main函数中加入

/* register our function */
lua_register(L, "average", average);

这两行的作用就是告诉e15.lua有average()这样一个函数.
* 这个程序可以存成cpp也可以存成c, 如果以.c为扩展名就不需要加extern "C"

编译的方法偶们上次说过了, 方法相同.
e15.lua执行的方法只能用上例中的C++中执行, 而不能用命令行方式执行.

3.错误处理
在上例中, 偶们没有对传入的参数是否为数字进行检测, 这样做不好. 所以这里偶
们再加上错误处理的片断.

把这段加在for循环之内:
if (!lua_isnumber(L, i)) {
lua_pushstring(L, "Incorrect argument to 'average'");
lua_error(L);
}
这段的作用就是检测传入的是否为数字.

加上这段之后, 偶们debug的时候就会简单许多. 对于结合两种语言的编程, 它们之
间传递数据的正确性检测是非常重要的.

这里有别人写好的例子:
VC的 http://tonyandpaige.com/tutorials/luaavg.zip
Linux的 http://tonyandpaige.com/tutorials/luaavg.tar.gz

至此, Lua与C的结合就基本讲完了, 下次偶要开始说说Lua与面向对象.
但是偶自己还没有学完, 所以大家可能要多等两天了. Sorry!

--

//用于2字节（DWORD)数据填充的函数
inline  void Mem_Set_WORD(VOID *dest, USHORT data, int count )
{
     _asm
          {
           mov  edi, dest  ; edi指向目标内存
　　　　　 mov  ecx, count  ;要移动的16位字数
　　　　　 mov  ax, data   ;16位数据
　　　　　 rep  stosw    ;移动数据
　　　　　｝//end asm
 }//end Mem_Set_WORD

int Partition(int a[],int l,int r)
{
 int p = a[l];//取首元素作为划分点

 while(l<r)
 {
  while(l<r&& a[r]>=p)
   --r;
  a[l] = a[r];

  while(l<r&& a[l]<=p)
   ++l;
  a[r] = a[l];
 }
 a[l] = p;
 return l;
}

void QSort(int a[],int l,int r)
{
 int p;
 if(l<r)
 {
  p = Partition(a,l,r);
  for(int i = l; i< r;++i)
  {
   cout<<a[i]<<" ";
  }
  cout<<endl;

  QSort(a,l,p-1);
  QSort(a,p+1,r);
 }
}