Tangel

In Time

2012-01-20T16:46:00.001-08:00

电影in time，讲的是一个用时间作为货币的时代。平民每天的劳动换取下一天的生存时间，富人剥削穷人的时间从而得到永生。整个故事逻辑上出现了很多不合情理的地方，但是抱着仅仅想看俊男美女的态度，片子不会让人乏味。
不过现实又何尝不是如此呢，一套房子就足以让很多人麻木的工作大半生，时间被换成利益，最终流入到某些人的手中。庆幸的是他们得到的仅仅是数字而已，到了自然限制的边缘，他们也只能全身插满管子，苟延残喘。
作为一个时间将被换成利益流进别人账户的人，过好每一天，为自己过好每一天，用好上天赋予的永远不可被剥夺的权利，才是生活之道。

破旧工厂的白日梦

2012-01-19T18:06:00.000-08:00

转眼大学毕业了三年了，久未谋面的同学说想起我了。
转眼离开家独立生活七年了，家乡周围的风景已经被开发商改的面目全非。
转眼间已经生活了二十六年了，超过了父母一半的年龄，走过了比他们更远的路。

无忧无虑的生活，苦涩甜蜜的青春，在记忆中渐渐模糊。
痛苦的并不是离去本身，而是送行的过程。

血钻

2011-12-11T21:53:00.001-08:00

看了两遍，故事中Danny Archer是一个机智，果断，执着的人。他在所有的势力中间周旋，为了自己的目标，拿到血钻，离开非洲。
但是影片最后，Archer被子弹擦伤，在离飞机距离已经不远的情况下，却忍受不了身体的创伤，放弃了钻石，放弃了自己生还的机会。
第一遍看完了，这个问题就困扰着我，为什么一个如此执着的人，会在胜利的最后一刻放弃坚持呢？难道是编剧的一个逻辑上的失误？
看完了第二遍，却觉得是编剧有意为之。从前面的剧情铺垫，Archer其实已经深信他永远也离不开这块土地，这块用鲜血染红的土地，这是深入他骨髓的一种哲学价值观。但他不断的告诉自己，要拿到钻石，然后远走高飞，这是他给自己设定的人生，是他的追求。他坚信自己的目的就是离开非洲，并告诉自己拿到钻石只是达到这一结果的条件。但实际上，他的自我暗示和他的信仰是冲突的，他并没有设想过自己离开非洲的情形，并没有对今后生活的憧憬。所以离开非洲，就成为了一个单纯的，没有任何结果的目的，但这个目过于抽象，所以，拿到钻石就成了现实中的目的，他不断的暗示自己，钻石就是所有的希望。
所以，Archer会不择手段的得到钻石。但是当他得到钻石之后呢？就好比到达了宇宙的边缘，他想看看宇宙之外有什么，却发现什么都没有，他只能生活在自己的宇宙里。他达到了目的，却发现目的所有的意义就是目的本身，于是泄气，然后放弃。

想文艺的2B青年

2011-11-21T18:35:00.001-08:00

考试考完的第二天，第一个工作日。
考前总是觉得太累，现在却觉得太闲，好像总是少了点什么。
虽然考的一塌糊涂，可是备考的这段时间还是有很多感触。
时间很多，事情也很多，要走的路很长。
普通青年适应环境生活着，文艺青年改变环境追求着，2B青年逃避环境抱怨着。
三年前的我个普通青年，三个月前的我是个2B青年，现在呢？
希望有一天，我也可以变的文艺一点。

彼得的梦一

2011-07-07T09:04:00.000-07:00

彼得按部就班的完成了所有的步骤，然后开始祈祷，这是平凡的一天。

彼得不是牧师，他是一个程序员，和牧师一样，彼得每天要重复很多个步骤，设计，编码，测试，最后让程序开始运行。可程序一旦运行起来，彼得能做的事情就只剩下祷告，祈祷程序能够产生正确的结果，其实，彼得自己也不知道什么是正确的结果，就好像他不知道自己每天做的事情是否正确一样。好比彼得现在忽然很想唱歌，但为什么要唱，唱是否正确，他都不知道。但是彼得所起到的，就是让自己的程序想唱，想哭，想笑，想做“他”想做的事情。既然足够复杂的大脑细胞以某种方式结合起来可以产生情感，思维，那么与之相同数量的电路也能如此，彼得坚信这一点。

彼得的智能程序虽然很晦涩难懂，原理上其实很简单，核心就是定义一个最小的规则集合，就好比宇宙定义了分子，原子，然后从这一小组规则集合逐渐产生pattern，就像分子按照某种pattern产生了细胞，细胞又按某种规则产生了树木，花草，产生花猫身上的斑点，和孔雀羽毛上的花纹，甚至，人类的意识。到目前为止，这个智能程序已经模拟产生了蚂蚁美丽的巢穴，蜜蜂分工明确的采蜜，所以，在今天看到程序模拟的小狗开始摇尾巴的时候，彼得显得格外的兴奋，因为他的祈祷又奏效了。

从某种角度来说，彼得已经在人工智能领域走到了最前沿，是一名世界级的专家，但他却不确定这一点，因为他所做的一切，都有人在指导。指导他的那个人叫做教授，教授是一个神秘的人，他一直穿着白色的大褂，就好象手术室里的主治医师，他头发苍白，双眼凹陷，却精神矍铄，体力充沛。但至于他的长相，声音，彼得也不是很清楚，因为他和教授交流的方式很特别，他们不需要借助任何的工具，不需要说话，书写，他们可以互相感觉到彼此，在遇到问题的时候，只要彼得问教授，教授就会指导彼得解决，从这个角度上来叫，教授才是真正的专家，而彼得只是实现了教授的想法而已。在彼得很小的时候，确切的说从他有记忆开始，他就认识教授，而且世界上除了彼得，再也没有人知道教授的存在。教授把所有的一切知识，荣誉都交给了彼得。

然而教授也不是完全的付出，他有个唯一的愿望，希望彼得帮他实现。从感情上讲，彼得非常想帮教授完成这个小小愿望，但直到今天，他都没有完成。不过彼得也没有因此感到愧疚，因为这个愿望虽然看起来微不足道，但却是彼得无法控制的。

教授唯一的愿望，就是希望彼得能做一个梦，无论梦到什么，无论梦的长短，唯一需要的，只是彼得的一个梦。说到这里，你应该已经知道了，彼得从来没有做过梦。

其实，对于彼得来说，也并不是从来没有做过梦，甚至他天天都在做梦，因为他似乎是生活在一部时光机器中，每天睡觉醒来，时间都会穿梭到另外一个点，所以明天对于彼得来说是不确定的，今天是他四十岁的一天，一觉醒来，彼得可能在二十岁的大学寝室里，周围都是熟悉的本科同学，也可能是趴在高中的课堂上，从一个小憩中醒来，甚至醒来的时候发现床上已经湿透了，不过彼得已经对这一切习以为常。他每天起床的第一件事情都是问教授，我这是在做梦么？每一次教授都给出了否定的答案，就好像例行公事一样。

所以今天是何年何月对彼得来说无所谓，他从来不关注这些，因为明天总是崭新的一天。不过作为一个故事，在开头总是要交代一下时间和地点，彼得今天在北京的某一个房间里，时间是2035年。

听歌

2011-06-25T19:25:00.000-07:00

这两天一直在听林宥嘉的《说谎》，从他撕心裂肺却稳定的声音说回味一下清纯的疯狂与执着。“人生已经如此的艰难，有些事情就不要拆穿”即便不是作为一首情歌来唱，谁又没有这个样的微不足道的请求呢?

法

2011-04-20T05:58:00.000-07:00

中国老百姓最缺的一部法是什么法，答曰“活法”。

中国最重要的一部法是什么法，答曰“领导的看法”。

About EventSystem

2011-01-12T05:30:00.001-08:00

A typical event system contains the following concepts.
a set of objects {Objects},
a set of event type {EventTypes},
every Object[i] has a EventProc to deal with a Event[j],
every Object[i] is only interested in a set of other objects { IN(Objects[i]) }

use the observer design patter, a simple solution is worked out.

CLASS EventMaker:
+AddListener(EventListener)
+DelListener(EventListener)
+NotifyAll(EventType)
-{IN(this)}

EventMaker::NotifyAll(EventType)
{
foreach listener[i]:
listener[i]->Update(EventType, this)
}

CLASS EventListener:
+EventProc(EventType, EventMaker)

CLASS Object implement EventMaker, EventListener:

In the above implementation,
every EventMaker should keep the set of listeners, (in fact the maker knows who are
listen to it, but the listeners do not know who they are listen to)
every EventListener should be able to process some event at any time immediately.

A simple way to maintain the messages without proc it immediately is to use a table,
for each EventType keep a set of EventMaker that make this event, like this

CLASS EventListener:
for each EventType:
keep a set of makers that make the event.

the space need for this solution is ( all_of_eventtype * number_of_makers ) * size_of_maker,
size_of_maker is usually 4 byte, cause we typically save the address. Another way is for each
EventMaker save that if it makes some kind of event, since the we only need 1 bit for a type of
event, the total size is ( all_of_makers * all_of_eventtype ) * 1 bit. In some case, when
number_of_makers is close to all_of_makers, the latter method will save memory significantly.
For example, there are some workers, who care about each other, and a manager, who cares about all
the workers, and the manager can not processed all the event from workers immediately, so he
should save all the messages and process them together, suppose in each loop, nearly every worker
will report some message(event) to the manager, here comes the problem described above.
Another example, there are set of objects, which does not care about each other, and a
monitor, which keeps all the objects but don't know how to deal with the events they made.
The monitor let some agent to register callbacks to deal all the event for all the objects, then
the above case comes too.

Simple linux tweaks

2010-12-09T05:28:00.000-08:00

use colored shell to distinguish command output from input, add this to .bashrc
PS1='\[\e[0;33m\][\[\e[0;32m\]\u\[\e[0;33m\]@\h:\[\e[0;39m\]\w\[\e[0;33m\]]\$\[\e[0m\] '

cause my Acer Aspire 4741G does have a Caps Lock light, I have to add some notification from Gnome. After some google progress, a working solution is:
1,sudo apt-get install libnotify-bin # add notify-send command
2,new a script of contents below:
#!/bin/bash
# Wizel & nikkpap Allou Programming Team
#
value=$(xset q | grep "LED mask" | sed -r "s/.*LED mask:\s+[0-9a-fA-F]+([0-9a-fA-F]).*/\1/")
if [ "$value" -eq "1" ];
then
notify-send -i icon "                    Caps Lock ON"
elif [ "$value" -eq "3" ];
then
notify-send -i icon "                    Caps Lock ON"
else
notify-send -i icon "                    Caps Lock OFF"
fi
save it in someplace that shell can found it by default.
3,CompizManager Setting Manager->Commands->add this command and bind it to ‘caps lock’
there was a bug, that notify-send command can not support -t(time) parameters as described in its document, so every notification will last for 10 seconds.

蒙特卡罗积分

2010-11-26T07:18:00.000-08:00

关于monte carlo积分，这是一个关于蒙特卡罗积分的小笔记，记的是一个困扰过我的问题。

蒙特卡罗积分简单的说就是，函数f(x)的期望值可以定义为以下公式。

其中，p(x)为概率函数，xi取值满足p(x)分布。令g(x) = f(x)p(x)，

从而可以由取样点估计一个函数的积分值。

realistic ray tracing中Monte Carlo Integration章节中150页有这样一段话，
Choosing p intelligently is called importance sampling, becasue if p is large where g is large, there will be more samples in important regions.
究竟什么是important regions，为什么p(x)的曲线要和g(x)等比例才好?这个就是困扰我的问题。
当N趋紧无穷大的时，上述公式是显然成立的，无论p(x)的形状和采样点的取值。但是在采样点有限的时候，随机数xi的选择即便满足p(x)的分布，右边的结果仍然会产生误差。

如下图所示：

假设g(x) = cos(x)(蓝色), 令p(x) = x(红色), 则f(x)=cos(x)/x(绿色),
则采样点的选择应该是满足p(x)的分布，直觉的说，就是在x较大的部分分布密集，在x小的部分出现的几率比较少，比如，在x取到0~0.1的范围内的概率为

假设一个极端情况，我们只在p(x)的定义域内随机选择一个采样点，来估算这个结果，那么如果这个采样点不幸落在0.0~0.1区域内（小概率事件，0.005），那么估算出来的值于期望的值是相差很大的，如图所示，在x趋近于0的时候，f(x)是趋近于无穷大的。
所以，理想情况下，我们希望f(x)(绿色曲线)越平滑越好，这样，无论采样点如何选择，估算出的结果都不会相差很大，这也就是important sampling的原理。

音乐小记（一）

2010-11-24T07:32:00.000-08:00

今天忽然想写写这么多年来喜欢听的音乐，回忆一下过去那段成长的岁月。
记得很小的时候，我很喜欢画画，而且不知道为什么，那时候的我好像认为画画和音乐不能同时喜欢，所以我一直不怎么喜欢听音乐。
直到有印象里第一首很喜欢的歌，是《真心英雄》，那时候我应该是小学高年级。当时觉得这首哥太朗朗上口了，简直就好像是上天已经谱好，并且已经放在每一个人心中一样，只要有第一个人唱出来，听到的人就自动回忆起它熟悉的旋律。
有一天，和一个比我大十岁左右的表哥谈论起最喜欢的歌，我告诉他说是《真心英雄》，他反驳我说那种歌有什么好听的，他说最好听的歌一定是《海阔天空》，我当然不同意他的看法，甚至觉得他有点不可理喻，但是这件事情无可避免的让我在之后的两年里深深的爱上了beyond。
那时候的我有个黑色的磁带播放机，不如两面带两个大喇叭的录音机大，也远没有单放机那么小，它是我唯一的电器，严格的说，我还有一盏台灯，相对而言，它和一盘beyond的磁带无可争议的成为了我的最爱。现在回忆起来，那盘磁带中收录的歌曲不知道是某一整张专辑，还是那时候盗版磁带流行的精选集。但里面的确有许多经典，《光辉岁月》《真的爱你》《大地》《俾面派对》《冷雨夜》，当然，还有《海阔天空》。
到了初中，我和班上的三个男生成立了一个四人小组，天天在一起玩，其中一个人家里面有周华健的MTV，我们经常过去看。久而久之，就喜欢上了周华健，他还是有很多经典歌曲的，清新的，缠绵的。后来，几乎的同样的方式喜欢上了张信哲，他真的适合情歌，也适合那个情窦初开的年龄。初中的前半段几乎就听着他们的歌过去了，当然也有零零星星听过一些其他歌手的歌，但是，他们无疑是的主流。那时，听歌的方式主要还是靠买磁带，也正是初中时候，开始和同学一起去逛街，而逛街的主要目的就是去逛磁带店，记得当时的盗版磁带一般要5，6块钱，正版的要12到14块钱，不过正版会送一个精美的歌词册子。逛完磁带店，我们就会去买海报，女生就去买明星，男生就去买灌篮高手，初中无疑才是真正的追星年代。
也就是2000年左右，男孩组合非常的流行，后街男孩如日中天，西城男孩也红遍世界，Nsync超级男孩《byebyebye》MTV中的木偶戏新颖夺目，我印象里还有个98度，四个人都是超级精肉人。那时的羽泉也初露光芒，我很快就喜欢上了他们，不过热情没有持续太久，《冷酷到底》之后，就没有再关注过了。
也就是初中的时候，电视上开始有了印象里的第一个音乐节目，是湖南卫视的，主持人叫李好，节目内容就是随意的放一些MTV。在那个讯息闭塞的年代，这种节目无疑是开拓视野的最好方式，你总会在有意无意之中听到一些喜欢的歌，而如果你错过了那首歌的名字，就只好把旋律记在心里，期望着她的再出现。
·

软件异常

2010-11-23T07:18:00.000-08:00

关于异常（exception）
在了解exception control flow的时候，我就一直有一个疑问。机器在运行的过程中是如何check exception的，EOF可能发生在代码执行的任意时刻，所以在理论上每一条机器指令执行的过程中都需要检查当前是否有异常发生。这将是多么大的运行开销？
但是知道的processer的流水线作业之后，这个check的开销有硬件流水线完成，从宏观上看基本可以忽略不计，所以硬件实现的异常check在效率上不存在问题。但是如果异常由软件实现，比如JAVA中的exception是如何实现的呢？在执行完任何一条语句之后，都有可能带着错误信息直接返回。那么虚拟机是在每次执行一条语句之后都需要check是否有异常发生么？

软件异常通常都是指同步异常，同步异常是在本身的logic control flow中触发的，如果throw语句可以知道调用者catch的位置，那么在某个函数throw的时候，程序就可以直接跳到调用者catch的位置。所以调用者不需要去检查异常，而是异常触发的时候就自动跳转到了处理异常的位置,从而可以快速的向上传递异常而不至于有太大的check开销。

其实，在每条语句执行之后check异常这个说法也是有问题的，程序中的每条语句，在可执行文件中可能对应于一条机器指令，也可能对应于一个复杂的过程。所以在每一条语句之后check这个说法是有问题的。准确的说，程序应该是在执行catch的时候check，检查与上一次catch之间有没有throw 语句触发，但是如果这样，在一条语句执行完之后，即便它throw一个异常，也会按照逻辑控制流向前执行，而带着异常继续执行一段程序无疑是危险的，从 catch的角度来说，也是失职的。

程序就像是一条时间轴，指令不断的在这条轴上向前执行。在执行的过程中，只能通过在时间轴上放上固定的测试点，来捕捉这一段间隔中发生的异常。硬件通过每条指令执行完后测试，而软件通过catch语句加上测试点。值得庆幸的是，同步异常中，我们清楚的知道下一个测点的位置。比如，在throw之后，我们清楚的指导catch的位置，所以不需要在每一条语句执行之后都去check，而是让throw直接跳到catch的位置，从而降低了check的开销。

重装ubuntu小记

2010-11-22T06:26:00.000-08:00

重新安装ubuntu 10.04过程：
1,修改 /etc/apt/sources.list 内容如下：
deb http://ubuntu.srt.cn/ubuntu/ lucid main restricted universe multiverse
deb http://ubuntu.srt.cn/ubuntu/ lucid-security main restricted universe multiverse
deb http://ubuntu.srt.cn/ubuntu/ lucid-updates main restricted universe multiverse
deb http://ubuntu.srt.cn/ubuntu/ lucid-proposed main restricted universe multiverse
deb http://ubuntu.srt.cn/ubuntu/ lucid-backports main restricted universe multiverse
deb-src http://ubuntu.srt.cn/ubuntu/ lucid main restricted universe multiverse
deb-src http://ubuntu.srt.cn/ubuntu/ lucid-security main restricted universe multiverse
deb-src http://ubuntu.srt.cn/ubuntu/ lucid-updates main restricted universe multiverse
deb-src http://ubuntu.srt.cn/ubuntu/ lucid-proposed main restricted universe multiverse
deb-src http://ubuntu.srt.cn/ubuntu/ lucid-backports main restricted universe multiverse

2,安装中文输入法
sudo apt-get install ibus-pinyin ibus-pinyin-db-android
在.bashrc中添加
export GTK_IM_MODULE=ibus
export XMODIFIERS=@im=ibus
export QT_IM_MODULE=ibus
设置自动启动ibus
System — Preferences — Startup Applications，增加：
Name: ibus-daemon
Command: ibus-daemon -d -x -r

3,安装dropbox以及修改hosts
http://hi.baidu.com/okenjian/blog/item/f500fa51913068838d543091.html
安装过程如上述网址所述
修改hosts为notebook中所记载的地址
(文章已经被删除，如果需要搜索即可得到方法）

4,修改字体
创建符号连接 69-language-selector-zh-cn.conf
cd /etc/fonts/conf.d/
ln -s ../conf.avail/69-language-selector-zh-cn.conf
然后刷新字体缓存
sudo fc-cache -vf

5,vim显示中文,在vimrc中加入两行
let &termencoding=&encoding
set fileencodings=utf-8,gbk,ucs-bom,cp936

6，安装chromium浏览器，但是与ibus输入法不兼容，卸载chromium之后装chrome state版本，问题亦然存在。
现在的问题是，只要按backspace键，输入就会停止（无法在继续弹出中文候选框）

先到这里，这样系统就基本可用，至少在日常上网时于windows不会有什么不同。
上大学的时候想用ubuntu却怎么也用不习惯，因为在windows下面总是有很多的程序的功能在ubuntu下找不到对应，在web应用逐渐成为主流的今天，用什么操作系统已经逐渐淡化，稳定快捷的linux毫无争议的成为了我的首选。

指针强转

2010-11-20T19:37:00.000-08:00

指针强转。
本文只涉及到最初等的强制转换问题，并没有讨论到C++中各种cast所用的机制。
我
一直以为，C/C++中的指针类型强制转换，唯一的作用就是告诉编译器用另外一种看法看待这一块数据，其中不涉及到对这块数据的任何操作。比如：可以将一
个指针转型成一个unsigned
int,在32位机器上这种转型是完全合理的，在处理内存的时候转成一个unsigned会让对指针的操作更明显易懂。可以将一块buffer的内容强转
成一个对象，从而实现这个对象的持久化。甚至可以将一个整数强转成一个函数指针，从而得到某个私有函数的引用。强转的威力是巨大的，它可以改变编译器对一
块数据的思维方式。

上面的强转都不涉及到数据的变化，但是从一个int强转成一个float，编译器就
有工作了，这个变化中涉及到好几个浮点数命令，从浮点数转化为整数亦然。今天忽然想到的这个问题就是：对于一个C++的对象作强制转换，编译器会去怎么样
操作呢？如何寻找合适的虚指针呢？是在编译时还是在运行时呢？

class IInterfaceA { public: virtual void funcA() = 0; };

class IInterfaceB { public: virtual void funcB() = 0; };

class ClassC: public IInterfaceA, IInterfaceB
{
public:
void funcA() {}
void funcB() {}
void funcC() {}
};

上面的ClassC继承自两个接口，我们不考虑这个ClassC中数据的具体分布方式，可以肯定的是，这个类的对象里包含两个虚函数指针，分别指向两个接口的虚函数表（这个实际的对象中，两个虚指针分别指向ClassC中的两个位置，这两个指针分别是在两个不同接口中声明的虚函数的起始地址）。

ClassC* pc = new ClassC();
IInterfaceA* pa = (IInterfaceA*)pc;
IInterfaceB* pb = (IInterfaceB*)pc;

pa和pb分别得到这个对象的两个接口的地址，在这之后，凡是引用到pa的地方，编译起就认为这个对象是IInterfaceA这个接口，pb亦然。也就是说，以后引用pa的地方，函数的地址只是从IInterfaceA接口的相对位置找到的，如下：

pa->funcA();

假设pa这个指针的地址是ADDR(pa)，它的虚指针的地址是VPTR((ADDR(pa)),那么编译器通过这个地址，从IInterfaceA的定义中找到funcA的地址，

ADDR(funcA) = VPTR((ADDR(pa)) + Offset(funcA),

VPTR()是从某个对象的地址中找到它的虚函数表的地址，Offset()是从虚函数表中找到特定的函数的offset。VPTR,Offset()这两个函数的值都是从IInterface的定义得到，与ClassC的定义没有任何关系。

于是，可以想象，ADDR(pa) 和ADDR(pb)
不是同一个值，因为如果他们是一样的地址address，VPTR(address)将得到相同的虚函数表，从而失去多态的效果，如果你将pa和pb的地
址打印出来，可以证明这个结论。pa和pb的地址分别是pc中两个虚指针的地址。

那么不同的强转结果是在编译时期得到的还是在运行时得到的呢？应该是在编译时期，因
为在任意时刻，任何一个对象，编译器都会知道它的类型（虽然这个类型的行为是在运行时得到的，但是每一个对象的确有一个确定的类型），在对这个类型强转成
父类的时候，编译器知道这个类的继承关系，从而知道哪一个虚指针对应到转型之后的结果上，查看汇编代码可以验证这个结果。如下：

IInterfaceA* pa = (IInterfaceA*)pc;
pa->funcA();
IInterfaceB* pb = (IInterfaceB*)pc;
pb->funcB();

leal 24(%esp), %eax //get pc's address
movl %eax, 36(%esp) //back up %eax
movl 36(%esp), %eax
movl (%eax), %eax //get virtual table of pa
movl (%eax), %edx //get virtual function from vtable
movl 36(%esp), %eax //restore %eax
movl %eax, (%esp) //prepare stack
call *%edx // call function
leal 24(%esp), %eax
addl $4, %eax //get offset of pb
movl %eax, 32(%esp)
movl 32(%esp), %eax
movl (%eax), %eax
movl (%eax), %edx
movl 32(%esp), %eax
movl %eax, (%esp)
call *%edx

反之，如果将一个对象强制向下转型编译器所能维护的也就是从两个类的定义中找到他们内存分布的相对位置，如果转型失败，后果可想而知。

iterator 模式

2010-11-20T02:22:00.001-08:00

iterator 模式
首先，container有暴露内部的数据的需求，如果是无状态的需求的话，那么container可以通过方法及他的参数来得到所请求的数据。
但是如果是带状态的请求，那么可以由应用者来保存这个状态，比如说线性容器的遍历访问，for (int i = 0; i < container.count(); i ++) 其中，i就是保存的状态，但是
如果是容器不是线性的，那么用户来描述这个状态就会出现困难。

也可以由container来保存状态，那么应用起来是这样，
while (container.hasNext()) {
element = container.getNext();
do some thing!!
container.moveNext();
}
但是这样做如果有两个地方同时需要维护自己的状态，container自己保存就无法处理多个状态的情况。

这样的话，就出现了iterator，这个类就是要维护一个状态，从而提供遍历容器的方法。

从实现上来说，一个典型的iterator应该提供以下方法
bool hasNext();
void moveNext();
TYPE getRefence();
对于JAVA这种从一个object继承下来的类语言来说，可以直接获得一个TYPE的指针，然后向下强转成所需要的类型
但是对于C++这种语言，对于某个TYPE，就需要一个container和一个iterator，所以，用模板不失为一个好办法

C++中的二进制兼容

2010-11-20T02:13:00.000-08:00

一个二进制的文件，只要在特定的机器可以运行，那么他已经被翻译成了机器命令一级兼容的文件，它所用的所有的操作都是在这个机器支持的命令集内，这一层的兼容编译器已经帮我们完成。

同样的，如果它能在特定的操作系统上运行，那么它已经兼容了这个操作系统loader的格式，即它的格式满足loader对程序所占用内存的分布，可以被操作系统所正确加载，这同样也是编译器帮我们完成的。

虽然编译器各有不同，但是他们必须遵循机器和操作系统的约定，才能跑的起来，所以能跑的起来的程序，已经做到了这两个层次的兼容。

那么二进制的兼容到底是解决的是什么问题呢？在什么情况下，不同厂商或者是不同版本的编译器会编译出来不同的结果呢？

1，函数参数压栈的顺序，有些假设从左到右压栈，有些采用从右到左压栈，即便是同一个编译器，也有不同的参数来制定，stdcall就是这样一个编译器关键字。

2，函数或者是全局变量的symbol，任何一个可链接的文件，无论是静态链接还是动态链接，都需要保存一个完成的symbol table，这样在链接的时候就可以对所有的symbol resolution，从而得到某个函数或者是全局变量的引用。不同的编译器采用不同的symbol命名规则，导致链接的时候二进制不兼容。

问题1的解决办法就是需要协同工作的文件采用同样的calling conversion，问题2的解决办法就是让动态链接器知道所有的命名规则。（静态链接器是编译器工具链提供的，他只懂得自己的命名规则就足够了）

同一个编译器编译出的二进制动态链接文件如何兼容呢？

首先这个文件中的任何函数都不能改变定义（既不能改变它的参数和返回值类型，也不能改变它的名字从而导致symbol的改变），其次，不能改变这个文件中定义的任何数据结构的内存布局，也就是说不能改变任何struct。

其中第二个条件让能做的事情几乎微乎其微，因为新的版本所用到新的算法，几乎不可避免的会改变一些关键的数据结构。庆幸的是，数据结构可以从来不被引用到其他的模块中，所有的关于这个结构的公开的函数结构都可以用指针来表示这个数据结构。这样，只要函数接口不变，就可以做到二进制的兼容。

上面只是c语言中的一些概念，扩展到C++中来，就是所有的类都是暴露接口到API层，任何操作都只针对接口，并且所有的关于这个模块中的所有的class作参数的函数都用接口指针来表示，这样就实现了二进制的兼容，

读COM本质论第一章有感。

服务

2010-05-14T02:55:00.001-07:00

Service( A requester's perspective)

1, What does the service offer?

2, How to request a service?

3, How to translation information between the server and the requester?

example 1

川菜服务

1，提供川菜这种菜肴。

2，到×××川菜馆，服务员会listening your request。

3，通过点菜，服务员上菜来传递你的需求和服务的结果。

（付款和服务应该是相辅相成的，但是他并不属于服务本身）

example 2

OS kernel Service

1, Offer process management, memory management, I/O management....

2, Through Trap(System Call), an software exception to translate to kernel mode.

3, Translate service entry and parameters via registers.

那为什么一般不说game engine提供某种service呢？

service的提供者和请求者之间应该有明显的不同，并且服务的提供者和请求者之间应该是一对多的关系。

如果是一对一的关系的话，他们之间就可以绑定起来，而其中没有服务这种关系。

这样看来，game engine的确提供了一种服务，为不同的游戏提供资源，显示，声音等服务。

twitter也提供了一种服务，为不同的人提供发送和收取消息的服务。

人民网CCTV没有提供一种服务，因为它和使用它的人绑定了起来。

今天是公司的年会，大家一起吃了晚饭

2010-01-22T07:04:00.001-08:00

今天是公司的年会，又抽到了一个三等奖品，我真是个经济适用男，当然，奖品也配得上经济适用的称号，sennheiser的耳机。今天上午，公司还组织大家看了一场电影，名叫《阿凡达》，这也是这篇博客的主题。

avatar已经火爆了很久了，回想起他刚刚出来的时候在豆瓣上看到的一个影评，说是看完之后一行几个人都被震坏了，而且几个人都是国内的导演，然后又说中国的电影技术和最先进水平相差五十年，而电影文化相差五千年。当时看到这则影评的时候觉得有点好笑，不知道震坏了是怎么一个状态，也不知道他的文化上相差五千年是怎么得到的，但我相信五十年的技术差距，如果闭关锁国，相差五千年也不是难事。不过，看到了这么一则影评，心中总是有点恋恋不忘，就好比是一个魔术，无论别人怎么形容，在你最终看到之前，无论怎么猜想，在看到之后，又总是无法相信自己的眼睛。我想，《阿凡达》达到了这样的魔术效果。

在这么一个于理想相距甚远的世界里，有太多的事情是无奈的，是可欲不可求的。但是，如果没有了想象力，那只能是自己的错。

不知道有多少人想过，爬上一座悬浮的山头，骑上一头会飞的龙，和心爱的人在满是萤火虫的森林中散步，想从高处贴着悬崖俯冲，想拿着武器保护自己的爱人。但是现实最终把我们拉了回来，摘掉我们的氧气罩，让我们托着疲惫的身躯，勉强的喘气。电影中所讲述的，就是我们以往的心中的幻想。让人在匆匆的现实中，体会这短暂的梦境，体会逐渐远离我们的梦境。

说不定我们就像是黑客帝国中所说的一样，所看到的一切都只是假象，如果释放想象力，我们可以成为一个潘多拉人，如果失去了想象力，我们就只能回到培养皿中。所以为什么要迷信现实呢，去梦想吧，毕竟，比起导演来，我们都还年轻。不是么？就到这里吧，看来我也被震坏了，回头一看，语无伦次。

snev上的东西

2010-01-02T03:23:00.001-08:00

    我在googlecode上开了一个小工程，上面保留了前一段时间写的一些代码，在这里做一些简单的介绍。介绍自己的丑代码需要一些勇气，这一点现在感受颇深。
    snev是一个这个功臣的名字，但是里面却是一些彼此无关的代码。其中有很多只是些代码片段，或者说一些小代码玩具。
    trunk/source/billiard 是一个桌球小游戏，是开始学习opengl的时候的一个小练习。如果想编译执行，需要glewt和glut扩展，得到源代码之后make就行，make是手写的，在mingw和cygwin下面都测试过。这个小程序内容很简单，就是20个球在桌子上碰来碰去，最简单的包围球碰撞检测，代码生成的球体模型，shadow volume做的阴影，之前想做成一个3D桌球的游戏，后来因为时间关系不想写了。
    trunk/tlab/heap下面是内存分配的代码，有heap和heap2两个实现，其中heap就是的最简单的单链表，每次查找时在freelist中找到第一个可以非配的块作为分配块，效率极低。heap2是一个优化过的版本，优化的基本思想是，不止保存一个free list，而是保存32个free list，第i个free list里保存的是大小为 2^i ~ 2^(i+1),2的i次幂到（i+1）次幂大小的块，每次需要分配一块M大小的内存时，找到这个块所对应的一个free list，算法在网上很容易就可以找到，如果要具体的复杂度分析可以自行搜索。heap2在进行了这个小的优化之后，比heap中使用的但链表要快了很多，但是从我的测结果来看，在windows xp下，比系统提供的慢2/3,也就是说效率是malloc的1/3，但是已经比最简单的heap快了千倍。看来看去，好像这个heap1就是个托，他的使命就是告诉大家，虽然heap2也不是很快，但是已经比我快了好几百倍了。但是这个托也没有做什么坏事，对比他的同行，cctv的实习生和五毛党，你托出了素质，脱出了水平，傻的高尚，慢的光荣。heap2虽然慢，但是在内存块中可以自定义数据，所以可以很容易的查出来内存泄露，也是他最他的功能了，不过heap2遇到stl就死循环，这是一粒硕大无比的bug，不得不说。
   trunk/tlab/math里面有一个matrix的实现，用的是右手坐标系加列向量的存储的方式，总之，可以完全替掉OpenGL中的matrix操作就是了。另一个是一个sintable的生成，就是把三角函数吧0-2PI均分成很多个点，在每个点上取得这个点所对应的sin值，如果要取的数值在某两个点之间的话，再用线性差值就行了。但是我得到的这个sintable于在其他地方看到的一个sintable中的值有一些略微的差别，我想可能是他做了一些线性回归的原因。
   trunk/tlab/regexp里面是一个简单的正则表达式引擎。只能处理最基本的三种运算（连接，或，闭包）运算，也就是ab（连接），a|b（或者）, a*（闭包），当然也支持小括号。具体的过程和编译原理上的差不多，也就是由正则表达是生成NFA，由NFA生成DFA，然后判断的过程。由于这个代码使用的都是c的东西，所以看起来很是纠结，对，纠结。
    trunk/tlab/CsScripts里一个小的脚本引擎，一个解释型的脚本语言。函数是以&开头的一个字符串，不支持函数定义，只能在cpp文件里内置函数（继承Function借口并定义Compute函数），我内置了一个print函数。动态变量定义，内置支持NULL，Float，Int，String四种变量，变量名和php中一样，以$开头。int，float支持几乎所有的运算（不支持位运算，这个脚本也不是用来科学计算的语言，他的目的在于把一些逻辑从cpp文件中移出来，这样的话，死机的时候其他的程序员对着你喊“我这里又挂了”的时候，你可以大声的告诉他，“别找我，找那个臭屁的designer吧，是他写的这个该死的脚本），支持if-elif-else语句，while-break语句，当然这些都是无限嵌套的，不过他们其实也不是无限潜逃的，有一个固定的栈的大小，在程序到达三米宽之前，我想，这个栈是不会轻易溢出的。具体的不多说，下面有一段具体的脚本语言，源代码里面也有很多脚本的例子。需要注明的是这个语言里面的所有的出错信息都是我写的，你得忍受我蹩脚的英语，还得忍受错误位置有时候报的不太精确。以下就是这个脚本的一些语法。
1 {
2         $m = -7
3         &print( $m )
4         $m = - 7.0 + 3
5         &print( $m )
6         $var1 = 5
7         $var2 = 5
8
9         if ( $var1 == 5 ) {
10                 if ( $var2 == 5 ) {
11                         &print( "$var1 == 10 && $var2 == 15" )
12
13                         $i = 0
14                         while ( $i < $var1 ) {
15                                 $j = 0
16                                 while ( $j < $var2 ) {
17                                         if ( $i == 3 && ($j == 3) ) {
18                                                 &print( "hello", "tangel" )
19                                         }
20                                         else
21                                         {
22                                                 &print( $i, $j)
23                                         }
24                                         $j = $j + 1
25                                 }
26                                 $i = $i + 1
27                         }
28                 }
29         }
30         else {
31         }
32 }
    这就是我这一年来写的一些小程序，小结到此结束。

blog 序言

2010-01-02T02:10:00.001-08:00

    每天在网上闲逛很久，一半时间是在看别人的博客，不免想自己写一个，但一直未曾落实。去年的时候在blogger上开了一个，写了几篇后blogger就被封掉了，第一个博客也就这样草草收场，一年之后的今天，在这个无聊的元旦的下午，又想起了写博客一事，于是就是现在看到的这个博客。
    在写这个博客之前，先明确一下这个博客在2010年的短暂目标。
    第一，想写一些技术性的文章，写作是清楚的思考，把东西些下来的过程中或许会想到很多之前没有发现的问题，也可以获得一些网友的意见，纠正一些错误。
    第二，想写一些随笔的文章，这段时间有如此多的荒诞的，离奇的，劲爆的故事可以写，不记下来真是个不小的遗憾。
    第三，摆脱每天寝室，公司的二元化生活，给自己一个小的思考空间，大学毕业之后到现在的时间，我的记忆几乎是空白，可不希望这个空白延续到2011年。

    最后，不管有没有人来看我的文章，这第一篇文章还是得做一下自我介绍，我目前在上海的一个游戏公司工作，平时喜欢写代码，玩游戏，看八卦，如果具体到这三个事情的优先级，顺序应该反过来。我的推特 pastangel, gmail: march1896 at gmail.com, 我贡献的一些代码 snev.googlecode.com
    第一篇博客，就到这里了。

小聚

2009-11-22T06:12:00.001-08:00

    11.21.2009 和张磊和navy聚了一下，好久没有看到navy了啊，大三之后就再也没有见过了吧。
    总是看到一群北漂的人经常聚会，不禁有点羡慕，毕竟我们东流的的人少，分布的地方也散。人都还是没有变，听起navy讲技术还是那么一套一套的，他是我到现在为止看到过的最执著的技术人员了吧，希望他有朝一日能在编译器方面做出点东西，明年他毕业了就要去深圳的一个startup的小公司工作了，说不定过几年就成刘总了。
    张磊还是老样子，昨天竟然没有提他的大熊猫小熊猫，真是一个不大不小的奇迹。昨天他涨了薪水，所以饭钱自然就他出了，我们浑浑噩噩的进了一个什么烧烤，进去了跟着服务员走了很深，进去了发现小间太雅致了，服务员太多了，吃饭的人太少了，三个人坐下来，拿到菜单，发现太不靠谱了，一次得吃掉半个月工资，于是我们灰溜溜的溜了出来，下次去什么没有标价的地方吃饭一定要现问清楚人均消费大概多少才进去，实在是太窘。后来去了和记小菜，加钱靠谱，味道平平。
    总之，和朋友聚一下心情好了不少，振作起来，奋斗吧。

关于alpha，透明物体

2009-11-18T07:17:00.001-08:00

    在画一个距离较远的透明物体和一个距离较近的半透明物体的时候，一般来说需要先画远端的不透明物体，再画近端的透明物体，通过适当的blend就能绘制出正确的结果。
    反之，如果先画的是近端的透明物体的，更新了zbuffer的值，在画远端的半透明物体的时候，会因为depth test检测失败，而显示近端透明物体的一块有色区域。

    如果在程序中不知道所画物体的顺序，怎么解决这一矛盾呢，办法就是，在画透明物体的时候直接裁剪调透明的部分，即在像素到达framebuffer之前裁掉这些透明的像素点，这样
也就不会更新frame里的颜色值，也不会更新z buffer里面的信息，透明区域就好比没有画过一样。GL中的alphafunc就可以做到这一点，但是这样的做必须使透明区域的alpha值低于
某一特定值，会对美术资源有更高的要求。

折腾

2009-11-15T03:35:00.000-08:00

早上，天气不错，升级ubuntu到9.10,ubuntu的软件中心功能看起来真的把安装软件简化到比windows还傻瓜的地步了，这个困扰linux beginner的大问题莫非就这样解决了。下载和安装升级都用了45分钟左右，暂时没有遇到什么问题，真是个愉快的升级过程。唯一的不爽之处就是flashplugin-installer的安装，速度奇慢无比，随时有断线的可能，装的时候总是让人提心吊胆的，相信很多人有过同样的经历，以前搜过解决办法，未果。

中午出去买吃的。传了一件秋衣一件薄外套，冻的瑟瑟发抖。不过好天气依旧。

下午趴在床上睡着了，幸好睡之前传上了羽绒服，不然铁定着凉。醒来的时候外面下着小雨，又湿又冷。

忽然又想写一个博客，忽然想起这里还有一个，就用gapproxy翻墙出来，也就是现在的更新了。

上海的日子真是无聊，不知道是因为毕业了，还是因为上海这座城市。浮躁。

好久没来这里了

2009-11-15T02:23:00.000-08:00

虽说有各种翻墙的办法，可是该死的功夫网还是让我离开了这里。

不过这段时间也没有什么可以写的，或许我要到其他的地方去重开一个博客吧，不过在天朝，还真想不出有什么好的博客hosting。

这段时间一直出在愤怒的状态里，偶尔还会狂怒。愤怒不是暴燥，愤怒是一种状态，而不是一种情绪。处在这种平和的愤怒的状态里，让我感觉还有点年轻。:(

虚拟存储器

2009-05-19T02:55:00.001-07:00

    虚拟存储器，最近看了虚拟存储器一张，基本的了解了一点存储器的工作原理，这是一篇学习笔记。
    计算机系统中有很多级的存储设备，而且这些设备的容量与速度成反比。这样，就有了容量较小的一级作为下一级的高速缓存。由于每一级与下一级的容量与速度比不同（也就是说有些级别的速度相差较大，有些级别的容量相差较大），这样就产生了缓存不命中(在缓存中没有找到想要找的值）的开销问题。cpu告诉缓存和主存这两极速度相差不大（大约10倍左右），所以缓存不命中的开销较小，但是在主存和硬盘之间，速度相差很大，这样的的话，缓存不命中的开销就很大。
    缓存的工作原理，CPU告诉缓存作用时。用的缓存算法是硬件实现的，主要思路如下，讲主存看作是一个大的二维数组，其中的每一个元素作为一个缓存块，也就是说，一个缓存块可以存我们需要的大小，可以是一个bit，一个byte，或者是100个byte。现在这个二维数组就是整个主存的大小，高速缓存就是其中的一行，或者是几行的大小。以高速缓存为主存的一行为例，这时候主存是m[M][N],告诉缓存是c[N],如果要访问m[i][j]这个数据，就看c[j]中的信息，c[j]中存放了标记，和值两部分，如果标记为等于i的话，就叫做缓存命中，就返回c[j]中存放的值，如果标记为不等于i，就产生了缓存不命中，这时候就要到主存中查找，返回主存中的值，并将这个值缓存到c[j]中。总的来说缓存是应用了程序的局部性原理，也就是一个程序在某个时间段总是倾向于使用某一段内存。这种告诉缓存对程序员是不可见的，只是在写程序的时候，为了提高存贮器的利用效率，应该更倾向于使用连续的内存，换句话说，假设要操作一个二维数组，因为数组中的元素在存储器中是按行存放的，所以应该更倾向于使用按行的访问方式，即最内存的循环是对行操作的。
    虚拟存储器就是在主存与硬盘之间建立的一个映射关系，即把主存作为硬盘的缓存，假设程序在硬盘上执行。对于32位主机，需要4G的主存，而编译器编译之后将每一个程序的可用的地址空间都视为4G，这样可以简化编译器的很多工作。而且可以是程序内存地址变得更加统一，可以简化共享。这样，就需要在主存和硬盘上建立一个对应关系，完成地址翻译过程，地址翻译通常有专门的硬件和一些操作系统算法完成，完成地址翻译之后，其他所有的对内存的操作就是对于虚拟内存的操作了。由于主存的不命中开销很大，所以操作系统使用了一些硬件加软件算法来避免这种开销，地址的翻译过程也就是页面调度的过程。这些过程也是对程序员不可见的，有操作系统完成，在页面调度的过程中，操作系统可以添加并维护一些权限信息，保证内存访问的安全性。对程序员可见的是虚拟内存，对每个程序这片4G的虚拟内存分为很多区域，堆栈，堆，以及程序的代码区，和静态变量区域等等。动态内存分配，也就是操作系统自带的malloc，free函数是用来操作堆的一组api，这些api直接动态管理一块虚拟内存，这些操作对程序员是可见的，也就是说程序员可以用自己的管理函数集合来操作堆，对于不同的程序达到最好的时间与空间平衡，当然这些操作是在页面调度（虚拟地址与硬件地址的翻译过程）之上的，就是说无论怎么改写动态分配函数，最后还是要经过操作系统的页面调度，从而访问实际的物理地址的。
    这样，实现动态内存分配的方式实际上相当简单，就是init的时候在堆申请一块大内存，可以用操作系统底层提供的函数，也可以直接用操作系统的malloc，这两种方式实际上是一样的，基本上没有效率与空间上的区别。申请到之后，就可以自动态维护这一部分内存了，主要有隐式链表和显式链表两种方式，隐式链表用当前的块的大小作为指针的差，显示链表直接指向下一块的位置，就好比用绝对定位和相对定位的区别。可以全部重写动态内存管理函数，也就是全部使用自己的malloc和free，也可以部分使用自己的动态内存分配。因为malloc和free在效率与空间上做了一定程度的折中，所以我们可以在某些时候分配一块堆内存，在这一块内存中使用自己重写的一些简单的分配和释放函数，达到更高的效率，这样就在内存中形成了一个内存池。用内存池技术可以在小范围内对空间和时间进行更好的处理。
    综上就是我对虚拟存储器的暂时的理解，如有错误或是不全面之处，敬请指正。

braid，很久没有这样完全的玩通过一个游戏了，这种激情几乎可以追溯到78...

2009-04-22T00:19:00.001-07:00

    braid，很久没有这样完全的玩通过一个游戏了，这种激情几乎可以追溯到78年前。这次玩的时候机器语言环境没有设置正确，所有的字符都是乱码，很有当年玩FC日文RPG的味道。

    由于字符都是乱码，所以开始的时候没有注意到情节，只觉得是一个设计的很别致的解密游戏，每一关都利用了一种不同的时空的特性让玩家体会一种不同的时空的思维模式，而我也是在适应这些思维模式的过程中体会那种小学时候玩游戏的单纯的快乐。游戏的音乐很好听，感觉有点爱尔兰的味道，纯正欢快，画面也很简洁明快，绿色的主色调使人感觉轻松惬意。

   可是每次到了游戏拼图的时候，却是给人另外一种感觉。音乐听起来很压抑，拼板内容也显得沉重。狰狞或是痴呆的表情，充满暴力的城市，油画风格的拼板就好象记忆的裂痕一样被tim慢慢找到，他好像在时间中游走，去寻找他失去的记忆，寻找那个时间，那个时间的真实面貌，而这些发现只是他慢慢长路上的一个个脚印，他的最高的，唯一的目的就是救出被坏人掠走的公主。

    围绕着这条主线，tim找遍了各个地方，可是公主都已经提前离去。。。。。。

    最终他看到了公主，公主从一个人的怀中跳了下来，大呼救命，可是tim和他并不在一条路上，tim要尽快到达公主的身边，tim和公主向着同一个方向跑去，互相帮住打开前方的路障，在和时间赛跑了一段时间之后，tim终于来到了公主的闺房之前，而公主也躺下来入睡了。这个时候，时间停止了，所有的一切好像都是假象，所有的一切都颠倒了。

    公主从床上醒来，看到在外面的tim，公主尽力想要逃跑，逃到了和tim不同的路上，他们互相放下对方路上的路上，tim想使公主停下来，公主想摆脱tim的抓捕，后来公主被困在一个地方大呼救命，一个骑士冲过来，把公主搂在怀里抱走了。故事就是这样，这才是真实的世界，在tim的颠倒的世界里，他想和爱恋的公主团聚，而在现实世界里，公主却是想尽办法摆脱他。

    这是一个颠倒的世界，tim在时间的中穿梭，想寻找一个自己理想的世界，一个完美的世界，一个颠倒的世界。
    。。。。。。
    玩完了之后，在网上看了一下评论，才知道，tim是个核物理学家，他制造出来威力无穷的世界并引爆了，世界在那一刻坍塌了，时间停止不前，宇宙回到了初始的状态。
    网友评论，原来公主象征着原子弹，一个一个谜题解释了tim的道德的一点一点的转变，他作为一个科学怪人的微妙的情感变化。
    。。。。。。

    一万个人眼中有一万个哈姆莱特，在我看来，
    tim是一个科学怪人，他从小有着与众不同的想法，有着与世界格格不入的判断标准，但是他也有着人类固有的对爱的执着，对生活的渴望。可是他搞杂了，她为什么会喜欢上一个科学怪人呢，一个怪癖的，不食人间烟火的怪人呢，对，没有人会喜欢上这样的人。tim去找过她，想告诉她他的深深的纯洁感情，想敞开他情窦初开的内心，说出所有的情话，或许，他什么也说不出都，他只是想见到她，想看到她的微笑。所以，tim来到了她的窗前，她醒了，看见tim如同看见怪物一般，她开始疯狂的逃去，扑向了别人的怀抱。tim静静的站在那里，脑中一片空白，绝望，嫉妒，愤怒。为了忘记这一切，tim陷入的疯狂的研究中，他每天扑在实验室里，脑中确实挥之不去的她的影子。有一天，他发现，他制造出来了可以毁灭一切的炸弹，可是毁掉这个空间，甚至可以毁掉整个时间，他可以回到过去，他可以重新拥有生活，或许他还有机会，或许他还可以看到她的微笑。迷茫中，糊涂中，渴望中，他引爆了炸弹。一切都消失了，一切都毁灭了，tim来到了一个似有似无，时空混淆的空间，他可以在空间中任意的穿梭，然而，这是一个没有意义的世界，没有人有存在的意义，他也没有，一切都消失了，唯一剩下的一点，tim唯一知道的一点，就是公主被人偷走了，公主在等待着tim的营救，tim在时空中穿梭，到处寻找着公主。。。。。
    却在找到公主的那一刻，tim醒了，他洞悉了一切，他知道了自己设下的陷阱，他不想再陪自己玩下去了，一切都已经晚了。。。。。。

psp.tga.header

2009-04-08T23:03:00.001-07:00

PSP中自带的sample，都是用头文件去表示的图片，所以想要快速显示你自定义的tga，
比如说，想测试一下设计稿在psp上的显示效果，不能像在windows下直接读取tga文件，交给渲染引擎渲染。

headers.exe 读取一个tga文件，生成psp所需要的header文件，
其中Tga.h用的nehe_sdk中的tgaloader.cpp和tga.h文件。可以在nehe的官网上下到。
只得主意的是 tgaloader.cpp 函数中有这样一句话
*bits[cswap] ^= *bits[cswap+2] ^= *bits[cswap] ^= *bits[cswap+2];
这句话大概的意思解释如下
// Tangel
// this procedure just move the first two elements to the last
// for example, for array 0 1 2 3 4 5 6
// after the procedure will be 2 3 4 5 6 0 1
// The following procedure swap two bytes
// byte a, b;
// a = a^b;
// b = a^b;
// a = a^b;
// So, it can be written like this
// a ^= ( b ^= ( a ^= b ) )
// a ^= b ^= a ^= b;
但是在这里这句话好像有问题，改动如下
(*bits)[cswap] ^= (*bits)[cswap+2] ^= (*bits)[cswap] ^= (*bits)[cswap+2];

错误是由于括号的优先级高于*号的优先级造成的。
经过这个改动，正常显示图片。
header.cpp 文件如下，得主义tga中有alpha值和没有alpha值的分别处理。

// headers.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Tga.h"

int main(int argc, char* argv[])
{
int width, height;
bool alpha;
BYTE *data=NULL;

int a = 1234;
printf("%08X\n", a );

#ifdef _DEBUG
NeHe::LoadTGA( "coolkids.tga", width, height, alpha, &data );
#else
if ( argc != 2 ) return 0;
NeHe::LoadTGA( argv[1], width, height, alpha, &data );
#endif

FILE *output;
output = fopen( "my8888.h", "w" );

printf("%d %d %d\n", width, height, alpha );
fprintf( output, "int width = %d, height = %d;\n", width, height );
fprintf( output, "const unsigned int mypix_pf8888[%d] __attribute__((aligned(16))) = {\n", width*height );

int *pd = (int*)data;
if ( alpha ){
for (int j=0; j<height; j++ )
{
for (int i=0; i<width; i++)
{
//fprintf(output, "%x,", data[(j*width+i)*sizeof(int)] );
fprintf(output, "0x%08X,", pd[((height-1-j)*width+i)] );
}
fprintf(output, "\n" );
}
}else {
for (int j=0; j<height; j++ )
{
for (int i=0; i<width; i++)
{
//fprintf(output, "%x,", data[(j*width+i)*3] );
int *m = (int*)&data[((height-1-j)*width+i)*3];
*m |= 0x000000ff;
fprintf(output, "0x%08X,", *m );
}
fprintf(output, "\n" );
}
}
fprintf(output, "};\n" );

fclose( output );

system("pause");
return 0;
}

==

骨骼动画学习笔记

2009-04-03T23:35:00.001-07:00

    看了wiki上面的一篇文章（http://gpwiki.org/index.php/OpenGL:Tutorials:Basic_Bones_System#What_is_a_bone_system）
    骨骼动画中所谓的正向运动(forword kinematic)和反向运动(inverse kinematic)的区别就是，前向运动是从根节点每一帧设置每一个儿子节点相对于父亲节点的相对运动，而反向运动每一帧直接设置叶子节点的运动，从而带动父亲节点的运动一直到根节点。当然，inverse kinematic 所需要的计算量大，计算方法也更复杂。
    如果要应用IK（inverse kinematic）就必须限制每一个节点的度（degree），每一个关节只能在一定范围内运动。

    SDL(Simple DirectMedia Layer)可以用来替代windows的窗口控制，消息响应，并且是跨平台的，有机会得学习一下。

ertern和static关键字

2009-04-03T23:33:00.001-07:00

extern, static 关键字
extern 和 static 都是用来修饰申明（变量和函数）的关键字
extern 申明在其他位置定义过的变量或者函数，修饰函数时候可选，
不带函数体的函数名连同参数表或返回值，自动地作为一个声明。
void func();
extern void func();
是等同的。

static 将变量的作用域统一到“文件”级，
static 修饰全局变量或函数，将使这些变量函数对其他文件不可见
static 修饰局部变量，它就改变了局部变量的存放位置，将其由原
来的栈中存放改为全局静态储存区，但是没有改变变量的作用域，
还是局限在局部的{}里

LINE && FILE

2009-03-24T20:05:00.000-07:00

/*和脚本语言一样，C++允许获得当前的文件及行数，在处理异常时，可以作为输出信息，等等*/
/*Dev-C++ 4.9.9.2*/
#include "iostream"
using namespace std;

int main()
{
cout << __LINE__ << " " << __FILE__ << endl;
cin.get();
return 0;
}

函数，函数指针

2009-03-23T20:18:00.000-07:00

#include "iostream"
using namespace std;

int add( int a, int b ){return a + b;}

typedef int (* func_p)(int, int);
typedef int (func)(int, int );

/*
函数名可以被当作是地址，也可以被当作是值
调用时，可以直接用地址调用，也可以用值调用
：）说的好像很不明白，代码如下
测试环境 DEV-C++ 4.9.9.2
*/

int main()
{
int a = 10, b = 5;
int *pa = &a;

int (*f1)(int, int) = add;
func_p f2= add; // f1 and f2 are the same as add;

func& fr = add;
func* fp = add;
//func fv = add; error!

cout << add(a, b ) << endl;
cout << (&add)( a, b ) << endl;
cout << (*add)( a, b ) << endl << endl;

cout << fr( a, b ) << endl;
cout << (&fr)( a, b ) << endl; //take fr as a value,
cout << (*fr)( a, b ) << endl << endl; //take fr as a address,

cout << fp( a, b ) << endl; // fp is a pointer to function
cout << (*fp)( a, b ) << endl;
//cout << (&fp)( a, b ) << endl; error!

getchar();
return 0;
}

博客铭

2009-03-19T05:57:00.000-07:00

这两天一直在网上闲逛，看新闻，看博客，瞎想。
我一直不想写blog，自己心里的话写不出来，能写出来的又不是自己真想说的话。但是逛着逛着，觉得事实不是如此。所以开这个博客，也想学学其他的同龄人，写下自己的所见，所为，所悟。这是我的第一个blog，希望他能健康的成长。

星球大战

2009-03-19T02:13:00.000-07:00

telnet towel.blinkenlights.nl

Total Commander with Compare Tool

2009-03-18T02:33:00.001-07:00

TC 自带的comparer不好用，可以使用第三方的比较工具，就像是将F4设为定义的viewer一样。不过options里面好像没有这项设置，可以在wincmd.ini文件里设置 CompareTool=D:\Program Files\Beyond Compare\BC2.exe,在后在tc中选中比较文件，就会使用自定义的comparer。wincmd.ini文件可能不是安装文件夹下的，可能在系统文件夹中windows。。。。。