狂想的天空
狂想的天空
搬家啦！ 新家地址：http://www.cppblog.com/lijinshui 欢迎您来做客！
文章
关于#pragma warning
1. #pragma warning只对当前文件有效（对于.h，对包含它的cpp也是有效的），而不是对整个工程的所有文件有效。当该文件编译结束，设置也就失去作用。
2. #pragma warning(push)
存储当前报警设置。
#pragma warning(push, n)
存储当前报警设置，并设置报警级别为n。n为从1到4的自然数。
3. #pragma warning(pop)
恢复之前压入堆栈的报警设置。在一对push和pop之间作的任何报警相关设置都将失效。
4. #pragma warning(disable: n)
将某个警报置为失效
5. #pragma warning(default: n)
将报警置为默认
6. 某些警告如C4309是从上到下生效的。即文件内#pragma warning从上到下遍历，依次生效。
例如：
void func()
{
#pragma warning(disable: 4189)
char s;
s = 128;
#pragma warning(default: 4189)
char c;
c = 128;
}
则s = 128不会产生C4309报警，而C4309会产生报警。
7. 某些警告例如C4189是以函数中最后出现的#pragma warning设置为准的，其余针对该报警的设置都是无效的。
例如：
void func()
{
#pragma warning(disable: 4189)
int x = 1;
#pragma warning(default: 4189)
}
则C4189仍然会出现，因为default指令是函数的最后一条。在该文件内的其他函数中，如果没有重新设置，C4189也是以#pragma warning(default: 4189)为准。如果重新设置，同样是按照其函数中的最后一个#pragma warning为准。
8. 某些警告（MSDN认为是大于等于C4700的警告）是在函数结束后才能生效。
例如：
#pragma warning(disable:4700)
void Func()
{
int x;
int y = x;
#pragma warning(default:4700)
int z= x;
}
则y = x和z = x都不会产生C4700报警。只有在函数结束后的后的另外一个函数中，#pragma warning(default:4700)才能生效。
Alpha混合浅谈
alpha混合技术对熟悉游戏的人来说不会陌生，这种技术在如今的游戏特效里已经被用烂了。3D的游戏就
不说了，2D的游戏里，这种技术也是满眼皆是。
alpha混合听上去很神秘，实际非常简单，其作用就是要实现一种半透明效果。假设一种不透明东西
的颜色是A，另一种透明的东西的颜色是B，那么透过B去看A，看上去的颜色C就是B和A的混合颜色，可以
用这个式子来近似，设B物体的透明度为alpha(取值为0-1，0为完全透明，1为完全不透明)
R(C)=alpha*R(B)+(1-alpha)*R(A)
G(C)=alpha*G(B)+(1-alpha)*G(A)
B(C)=alpha*B(B)+(1-alpha)*B(A)
R(x)、G(x)、B(x)分别指颜色x的RGB分量。看起来这个东西这么简单，可是用它实现的效果绝对不简
单，应用alpha混合技术，可以实现出最眩目的火光、烟雾、阴影、动态光源等等一切你可以想象的出来
的半透明效果。
火光、烟雾的效果是事先做好一个火或雾的图和一个alpha通道图(用过Photoshop的人都该知道什么
是alpha通道)，画上去的时候每点每点计算，得到的就是火光掩映的效果。雾化效果在3D里还需要模糊一
下，在这里就免了，本来alpha混合就有不小的计算量了，算法再不优化再加上模糊或其它的一些什么原
因，那么你就是在看幻灯片了。(关于优化，网上见仁见智，我再找时候再讲)。
动态光源，听起来高深的一塌。那我先讲一下阴影，这个就简单了，以往的游戏也有阴影(象《仙剑
》)，不过我们把它升一下级，从不透明变成半透明而已。就是把一个影子图放在地表上面作alpha混合(
而且可以简化，因为影子的alpha值可以是一定的，这样就可以大幅提高计算速度)就OK了。
该讲动态光源了。我们把没有光源的地方想象成一张黑幕蒙在屏幕上，没光也就什么都看不到。那么
我们就加上一个光源，相当于在黑幕上挖了一个洞，这个洞的大小就是被照亮的范围，现在我们可以看到
下面的东西了。但现在这个效果说是光源，倒不如说是个窗户，要显得象光源，就要让光源的中心最亮，
逐渐向四周暗下去，最后到什么都看不见，这才象个光源。具体实现就是alpha混合啦，蒙版的颜色是黑
，中心alpha值为0，完全透明，到光源的尽头alpha值为1，完全不透明，成果就是这个样子，象这么回事
吧！光源做好了，动态的光源就是实时生成一个动态的alpha蒙版，然后盖上去就行了。
不难吧！游戏里(其实也不只游戏，好多算法也是这样)的一些技术听起来很玄，说通了也就是那么回
事，只不过不是一下子就能想到就是了。
Diablo里面就大量应用了alpha混合技术(至少我看上去象)，那些眩目的魔法产生出来的半透明效果
，还有乱飞的火球照亮迷宫，每个火球也就是个小的光源，一堆光源产生出来的蒙版(就是对应的alpha相
加，超过255就截断)再蒙上去。(真正的光源应该是这样的：当alpha值超过255时，alpha=alpha-255，
alpha是一个Byte时也就是回绕，同时该点蒙版的色彩变为白色，这才是对的，不过简单起见，还是原来
那样就可以了)。
from: http://www.gameres.com/
字符，字节和编码
字符，字节和编码[from：http://www.regexlab.com/zh/encoding.htm] 级别：中级
引言“字符与编码”是一个被经常讨论的话题。即使这样，时常出现的乱码仍然困扰着大家。虽然我们有很多的办法可以用来消除乱码，但我们并不一定理解这些办法的内在原理。而有的乱码产生的原因，实际上由于底层代码本身有问题所导致的。因此，不仅是初学者会对字符编码感到模糊，有的底层开发人员同样对字符编码缺乏准确的理解。
1. 编码问题的由来，相关概念的理解1.1 字符与编码的发展从计算机对多国语言的支持角度看，大致可以分为三个阶段：
字符串在内存中的存放方法： 在 ASCII 阶段，单字节字符串使用一个字节存放一个字符（SBCS）。比如，"Bob123" 在内存中为：
在使用 ANSI 编码支持多种语言阶段，每个字符使用一个字节或多个字节来表示（MBCS），因此，这种方式存放的字符也被称作多字节字符。比如，"中文123" 在中文 Windows 95 内存中为7个字节，每个汉字占2个字节，每个英文和数字字符占1个字节：
在 UNICODE 被采用之后，计算机存放字符串时，改为存放每个字符在 UNICODE 字符集中的序号。目前计算机一般使用 2 个字节（16 位）来存放一个序号（DBCS），因此，这种方式存放的字符也被称作宽字节字符。比如，字符串 "中文123" 在 Windows 2000 下，内存中实际存放的是 5 个序号：
一共占 10 个字节。
1.2 字符，字节，字符串理解编码的关键，是要把字符的概念和字节的概念理解准确。这两个概念容易混淆，我们在此做一下区分：
由于不同 ANSI 编码所规定的标准是不相同的，因此，对于一个给定的多字节字符串，我们必须知道它采用的是哪一种编码规则，才能够知道它包含了哪些“字符”。而对于 UNICODE 字符串来说，不管在什么环境下，它所代表的“字符”内容总是不变的。
1.3 字符集与编码各个国家和地区所制定的不同 ANSI 编码标准中，都只规定了各自语言所需的“字符”。比如：汉字标准（GB2312）中没有规定韩国语字符怎样存储。这些 ANSI 编码标准所规定的内容包含两层含义：
各个国家和地区在制定编码标准的时候，“字符的集合”和“编码”一般都是同时制定的。因此，平常我们所说的“字符集”，比如：GB2312, GBK, JIS 等，除了有“字符的集合”这层含义外，同时也包含了“编码”的含义。 “UNICODE 字符集”包含了各种语言中使用到的所有“字符”。用来给 UNICODE 字符集编码的标准有很多种，比如：UTF-8, UTF-7, UTF-16, UnicodeLittle, UnicodeBig 等。
1.4 常用的编码简介简单介绍一下常用的编码规则，为后边的章节做一个准备。在这里，我们根据编码规则的特点，把所有的编码分成三类：
我们实际上没有必要去深究每一种编码具体把某一个字符编码成了哪几个字节，我们只需要知道“编码”的概念就是把“字符”转化成“字节”就可以了。对于“UNICODE 编码”，由于它们是可以通过计算得到的，因此，在特殊的场合，我们可以去了解某一种“UNICODE 编码”是怎样的规则。
2. 字符与编码在程序中的实现2.1 程序中的字符与字节在 C++ 和 Java 中，用来代表“字符”和“字节”的数据类型，以及进行编码的方法：
以上需要注意几点：
2.2 C++ 中相关实现方法声明一段字符串常量：
UNICODE 字符串的 I/O 操作，字符与字节的转换操作：
在 Visual C++ 中，UNICODE 字符串常量有更简单的表示方法。如果源程序的编码与当前默认 ANSI 编码不符，则需要使用 #pragma setlocale，告诉编译器源程序使用的编码：
以上需要注意 #pragma setlocale 与 setlocale(LC_ALL, "") 的作用是不同的，#pragma setlocale 在编译时起作用，setlocale() 在运行时起作用。
2.3 Java 中相关实现方法字符串类 String 中的内容是 UNICODE 字符串：
字符串 I/O 操作，字符与字节转换操作。在 Java 包 java.io.* 中，以“Stream”结尾的类一般是用来操作“字节串”的类，以“Reader”，“Writer”结尾的类一般是用来操作“字符串”的类。
如果 java 的源程序编码与当前默认 ANSI 编码不符，则在编译的时候，需要指明一下源程序的编码。比如：
以上需要注意区分源程序的编码与 I/O 操作的编码，前者是在编译时起作用，后者是在运行时起作用。
3. 几种误解，以及乱码产生的原因和解决办法3.1 容易产生的误解
第一种误解，往往是导致乱码产生的原因。第二种误解，往往导致本来容易纠正的乱码问题变得更复杂。 在这里，我们可以看到，其中所讲的“误解一”，即采用每“一个字节”就是“一个字符”的转化方法，实际上也就等同于采用 iso-8859-1 进行转化。因此，我们常常使用 bytes = string.getBytes("iso-8859-1") 来进行逆向操作，得到原始的“字节串”。然后再使用正确的 ANSI 编码，比如 string = new String(bytes, "GB2312")，来得到正确的“UNICODE 字符串”。
3.2 非 UNICODE 程序在不同语言环境间移植时的乱码非 UNICODE 程序中的字符串，都是以某种 ANSI 编码形式存在的。如果程序运行时的语言环境与开发时的语言环境不同，将会导致 ANSI 字符串的显示失败。 比如，在日文环境下开发的非 UNICODE 的日文程序界面，拿到中文环境下运行时，界面上将显示乱码。如果这个日文程序界面改为采用 UNICODE 来记录字符串，那么当在中文环境下运行时，界面上将可以显示正常的日文。 由于客观原因，有时候我们必须在中文操作系统下运行非 UNICODE 的日文软件，这时我们可以采用一些工具，比如，南极星，AppLocale 等，暂时的模拟不同的语言环境。
3.3 网页提交字符串当页面中的表单提交字符串时，首先把字符串按照当前页面的编码，转化成字节串。然后再将每个字节转化成 "%XX" 的格式提交到 Web 服务器。比如，一个编码为 GB2312 的页面，提交 "中" 这个字符串时，提交给服务器的内容为 "%D6%D0"。 在服务器端，Web 服务器把收到的 "%D6%D0" 转化成 [0xD6, 0xD0] 两个字节，然后再根据 GB2312 编码规则得到 "中" 字。 在 Tomcat 服务器中，request.getParameter() 得到乱码时，常常是因为前面提到的“误解一”造成的。默认情况下，当提交 "%D6%D0" 给 Tomcat 服务器时，request.getParameter() 将返回 [0x00D6, 0x00D0] 两个 UNICODE 字符，而不是返回一个 "中" 字符。因此，我们需要使用 bytes = string.getBytes("iso-8859-1") 得到原始的字节串，再用 string = new String(bytes, "GB2312") 重新得到正确的字符串 "中"。
3.4 从数据库读取字符串通过数据库客户端（比如 ODBC 或 JDBC）从数据库服务器中读取字符串时，客户端需要从服务器获知所使用的 ANSI 编码。当数据库服务器发送字节流给客户端时，客户端负责将字节流按照正确的编码转化成 UNICODE 字符串。 如果从数据库读取字符串时得到乱码，而数据库中存放的数据又是正确的，那么往往还是因为前面提到的“误解一”造成的。解决的办法还是通过 string = new String( string.getBytes("iso-8859-1"), "GB2312") 的方法，重新得到原始的字节串，再重新使用正确的编码转化成字符串。
3.5 电子邮件中的字符串当一段 Text 或者 HTML 通过电子邮件传送时，发送的内容首先通过一种指定的字符编码转化成“字节串”，然后再把“字节串”通过一种指定的传输编码（Content-Transfer-Encoding）进行转化得到另一串“字节串”。比如，打开一封电子邮件源代码，可以看到类似的内容：
最常用的 Content-Transfer-Encoding 有 Base64 和 Quoted-Printable 两种。在对二进制文件或者中文文本进行转化时，Base64 得到的“字节串”比 Quoted-Printable 更短。在对英文文本进行转化时，Quoted-Printable 得到的“字节串”比 Base64 更短。 邮件的标题，用了一种更简短的格式来标注“字符编码”和“传输编码”。比如，标题内容为 "中"，则在邮件源代码中表示为：
其中，
如果“传输编码”改为 Quoted-Printable，同样，如果标题内容为 "中"：
如果阅读邮件时出现乱码，一般是因为“字符编码”或“传输编码”指定有误，或者是没有指定。比如，有的发邮件组件在发送邮件时，标题 "中"：
这样的表示，实际上是明确指明了标题为 [0x00D6, 0x00D0]，即 "ÖÐ"，而不是 "中"。
4. 几种错误理解的纠正误解：“ISO-8859-1 是国际编码？”非也。iso-8859-1 只是单字节字符集中最简单的一种，也就是“字节编号”与“UNICODE 字符编号”一致的那种编码规则。当我们要把一个“字节串”转化成“字符串”，而又不知道它是哪一种 ANSI 编码时，先暂时地把“每一个字节”作为“一个字符”进行转化，不会造成信息丢失。然后再使用 bytes = string.getBytes("iso-8859-1") 的方法可恢复到原始的字节串。 误解：“Java 中，怎样知道某个字符串的内码？”Java 中，字符串类 java.lang.String 处理的是 UNICODE 字符串，不是 ANSI 字符串。我们只需要把字符串作为“抽象的符号的串”来看待。因此不存在字符串的内码的问题。
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
二叉树的创建、遍历、深度、叶子节点个数
D3DX Utility library(转载)
Smart Pointer
Smart Pointer是C++中的一个大题目，要说清楚他的所有好处很需要费点力气。我就一个功能一个功能的说。有我理解不透的地方希望大家指点。
1.copy-to-write
当生成一个C++ object的时候如果这个class很大，这个object会占用很多空间。那么每生成一个就占用一片空间，这样会占用很多系统资源。同时降低效率。一个解决方法就是对用拷贝构造函数生成的object，让他不存储数据，而只存储一个指向原来object数据的指针。这样空间就节省了很多。但问题在于这样两个object完全联结在了一起。如果修改了其中一个，另一个也跟着变了。所以这种方法不可取。这里讲的copy-to-write技术就是解决这类问题的方法。当通过引用一个已有object去拷贝构造新object时，新object只有一个指向已有object的指针。这两个object共享数据。直到其中一个需要修改数据的时候，再把这两块数据分离。这里举一个最简化的例子。假设一个class叫CLargeObject，里面存有很多数据。我们用一个inner class来把所有数据放在一起，叫CData。CData里面存有大量数据，例如一个数据库。这里用最简单的模型来表示，假设只有一个整数int m_nVal; CData里面需要包含另一个变量。叫作索引数目(reference count)。它记录了指向这个CData object的来自CLargetObject类的指针各数。也就是说，总共有多少CLargeObject的object正在引用着当前的CData object。
class CLargeObject
{
private:
struct CData
{
private:
int m_nVal;
int m_nReferenceCount;
}
};
对于每个CLargeObject的object，我们用一个CData类的指针来指向其数据。
CData *m_pData;
CLargeObject至少有两个构造函数。第一个是标准的构造函数，初始化其数据。这时数据是唯一的，所以必须新生成一个CData的object来存储数据。
CLargeObject::CLargeObject(int nVal)
{
m_pData = new Data(nVal);
}
而对于CData类的构造函数而言，初始化他的CLargeObject是第一个指向他的，这一时刻索引数目m_nReferenceCount是1。
CLargeObject::Data::Data(int nVal) : m_nVal(nVal), m_nReferenceCount(1) {}
CLargeObject的第二个构造函数是拷贝构造(copy constructor)。这样生成的object不需要有新的数据，和已有的object共享数据就可以了。这是索引数目需要加1。表示又有一个object指向当前的CData了。
CLargeObject::CLargeObject(const CLargeObject &ob) // copy constructor
{
ob.m_pData->m_nReferenceCount++;
m_pData = ob.m_pData;
}
这样CLargeObject就构造好了，使用了可能的最少的内存。下面看看他的析够函数(destructor)。当一个object被delete的时候，它的数据不一定无效，如果别的object还在引用着这个数据，数据需要留下来。当然，数据的索引数目无论如何都要减1。
CLargeObject::~CLargeObject()
{
if (--m_pData->m_nReferenceCount == 0)
delete m_pData;
}
下面看一看赋值操作。先说用已有的CLargeObject赋值给这个CLargeObject。这时当前CLargeObject里面的数据要指向已有的这个object，就搞定了。
CLargeObject& CLargeObject::operator = (const CLargeObject& ob) // copy assignment
{
ob.m_pData->m_nReferenceCount++;
if (--m_pData->m_nReferenceCount == 0)
delete m_pData;
m_pData = ob.m_pData;
return *this;
}
再来看看如何对CLargeObject里面的数据进行真正的修改。这样就一定需要对当前的object独立操作了，否则就影响到了其它指向同一块数据的CLargeObject。这样CData类需要一个新的函数，生成只用于当前CLargetObject的数据。如果当前的引用数目是1，那么当然这个CData就是只用于这个CLargeObject的了。否则就重新new一个CData返回。
Data* CLargeObject::CData::get_own_copy() // clone if necessary
{
if (m_nReferenceCount==1)
return this;
m_nReferenceCount--;
return new Data(m_nVal);
}
CLargeObject修改前用这个函数得到唯一的object，然后对它赋值。
void CLargeObject::SetVal(int nNewVal)
{
m_pData = m_pData->get_own_copy();
m_pData->m_nVal = nNewVal;
}
对于所有可能改变CData值的操作，都需要用这种方法。
下面是只读函数，简单。直接返回值，什么特殊的都不用作。
int CLargeObject::GetVal() const
{
return m_pData->m_nVal;
}
这样copy-to-write技术就实现了。下面把完整的程序写一下：
class CLargeObject
{
public:
CLargeObject(int nVal);
CLargeObject(const CLargeObject &ob);
~CLargeObject();
CLargeObject& operator = (const CLargeObject& ob);
void SetVal(int nNewVal);
int GetVal() const;
private:
struct Data
{
public:
Data(int nVal) : m_nVal(nVal), m_nReferenceCount(1) {}
private:
friend class CLargeObject;
Data* get_own_copy() // clone if necessary
{
if (m_nReferenceCount==1)
return this;
m_nReferenceCount--;
return new Data(m_nVal);
}
// control variables.
int m_nReferenceCount;
// actual data portion
int m_nVal;
};
Data *m_pData;
};
CLargeObject::CLargeObject(int nVal)
{
m_pData = new Data(nVal);
}
CLargeObject::CLargeObject(const CLargeObject &ob) // copy constructor
{
ob.m_pData->m_nReferenceCount++;
m_pData = ob.m_pData;
}
CLargeObject::~CLargeObject()
{
if (--m_pData->m_nReferenceCount == 0)
delete m_pData;
}
CLargeObject& CLargeObject::operator = (const CLargeObject& ob) // copy assignment
{
ob.m_pData->m_nReferenceCount++;
if (--m_pData->m_nReferenceCount == 0)
delete m_pData;
m_pData = ob.m_pData;
return *this;
}
void CLargeObject::SetVal(int nNewVal)
{
m_pData = m_pData->get_own_copy();
m_pData->m_nVal = nNewVal;
}
int CLargeObject::GetVal() const
{
return m_pData->m_nVal;
}
很多存储数据的系统class，如string，CString等都有这种设计。所以记住这个应用是很有必要的。
转载：
from:http://www.bc-cn.net/
Direct3D中的HLSL(上)
ogre的主要渲染流程
from:http://www.gameres.com
很早以前就想写一些关于OGRE的文章了，一直没机会。
理解一个渲染引擎，我觉得最重要的是先抓住了它的主架构，它的主线，渲染流程，不然的话，一个引擎几万行，甚至几十万行的代码，光是打开solution就能吓你一跳了，OGRE也有十几万行的代码量，我一开始看它的时候也是无从下手，感觉代码太多了，不知道从哪开始看好，这个class看看，那个class看看，由于对整个引擎没有一个清晰的认识，看过了也印象不深，所以，最后，还是决定先找出它的主线，了解它的渲染流程，这样才能有机地把各个部分联系起来。
这篇短文也是对OGRE的主要渲染流程的一个介绍，可能对一些class不会太多地去介绍具体的实现细节。我所用的代码都是取自于OGRE的最新的CVS版本。
读者最好对OGRE有一定的了解，至少得看懂它的example，不然可能一些东西理解起来比较困难。对D3D，OPENGL有一定了解更好。
如果你看过D3D SDK中带的例子，你一定知道一个比较简单的3D程序要运行起来，至少都会涉及以下的几部分：
首先是数据的来源，包括顶点数据，纹理数据等，这些数据可以从文件中读取，也可以在程序运行时生成。
接下来，我们会建立顶点缓冲区把顶点保存起来，建立texture对象来表示texture，对顶点组成的物体设置它在世界坐标系下的坐标，设置摄像机的位置，视点，设置view