還是剛才那句話，沒源碼能讓你發(fā)瘋。
無論是kismet還是matinee還是材質(zhì)編輯器，都非常牛叉。其實(shí)還有更多的資料沒有公用許可，需要花美刀去購買的。其實(shí)Epic這么干無非是先讓你嘗鮮，然后再勾引你去買，這樣的話他的目的就達(dá)到了，就像微軟并沒有真正意義上的變態(tài)的打擊盜版一樣。。。55555555555.。。樓主，以后多聯(lián)系。。。不過很少上cppblog.祝你愉快。
光是UDK用起來還是沒有有代碼好，至少有代碼上手比較快。當(dāng)然有代碼也有悲劇的時(shí)候，特別是遇到有的時(shí)候升級(jí)造成的難以察覺的Bug。我就遇到過Content瀏覽器的一個(gè)Bug，哎，悲劇~~
郁悶的是UDK都免費(fèi)了，nFringe卻收費(fèi)了，郁悶啊，那該死的UDE也太難用了，還是VS用著爽。可惜可惜。
悲劇啊，最新版的nfringe貌似收費(fèi)了啊，郁悶。要在VS里面調(diào)試的話，還得用老版本，還好我有老版本可以用，要不然就徹底悲劇了。
re: 游戲中CPU使用率的控制 董波 2009-06-16 08:33
這個(gè)方法不佳。。。
誰有沒有更好的方法提出來哈，呵呵。
6.2. Requirements for Call Wrapper Types
TR1 defines some additional terms that are used to describe requirements for callable types.
First, INVOKE(fn, t1, t2, ..., tN) describes the effect of calling a callable object fn with the arguments t1, t2, ..., tN. Naturally, the effect depends on the type of the callable object. INVOKE is defined as follows:
(t1.*fn)(t2, ..., tN) when fn is a pointer to a member function of a class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T
((*t1).*fn)(t2, ..., tN) when fn is a pointer to a member function of a class T and t1 is not one of the types described in the previous item
t1.*fn when fn is a pointer to member data of a class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T
(*t1).*fn when fn is a pointer to member data of a class T and t1 is not one of the types described in the previous item
fn(t1, t2, ..., tN) in all other cases
What this amounts to is that when the callable object is an ordinary function or a pointer to an ordinary function, INVOKE means to call that function, passing the rest of the arguments to the function call. When the callable object is a pointer to member, the next argument refers to the object that it should be applied to. That argument is the object itself, a reference to the object, a pointer to the object, or some kind of smart pointer that points to the object. The rest of the arguments are passed to the function call.
Second, INVOKE_R(fn, t1, t2, ..., tN, Ret) describes the effect of calling a callable object fn with an explicit return type, Ret. It is defined as INVOKE(fn, t1, t2, ..., tN) implicitly converted to Ret.[5]
[5] In the TR, this metafunction is named INVOKE; although I'm one of the people responsible for this name overloading, I've now concluded that it's too clever and shouldn't be used.
Third, some call wrapper types have a weak result type; this means that they have a nested member named result_type that names a type determined from the call wrapper's target type, Ty.
If Ty is a function, reference to function, pointer to function, or pointer to member function, result_type is a synonym for the return type of Ty
If Ty is a class type with a member type named result_type, result_type is a synonym for Ty::result_type
Otherwise, result_type is not defined[6]
[6] That is, not defined as a consequence of having a weak result type. Some call wrapper types have a weak result type in certain circumstances, have a specific type named result_type
A few examples will help clarify what this rather dense text means:
struct base {
void f();
int g(double);
int h(double,double);
};
struct derived : base {
};
base b;
derived d;
base& br = d;
With these definitions, rule 1 gives the following meanings to these uses of INVOKE .
Phrase
Meaning
INVOKE (&base::f, b)
(b.*f)()
INVOKE (&base::g, d, 1.0)
(d.*f)(1.0)
INVOKE (&base::h, br, 1.0, 2.0)
(br.*f)(1.0, 2.0)
That is, the pointer to member function is called on the object or reference named by t1:
derived *dp = new derived;
base *bp = dp;
shared_ptr<base> sp(bp);
With these additional definitions, rule 2 gives the following meanings to these uses of ( INVOKE):
Phrase
Meaning
INVOKE (&base::f, bp)
((*bp).*f)()
INVOKE (&base::g, dp, 1.0)
((*dp).*f)(1.0)
INVOKE (&base::h, sp, 1.0, 2.0)
((*sp).*f)(1.0, 2.0)
That is, the pointer to member function is called on the object that the argument t1 points to. Since it uniformly dereferences that argument, the rule works for any type whose operator* returns a reference to a suitable object. In particular, the rule works for shared_ptr objects.
Rules 3 and 4 give similar meanings to INVOKE uses that apply pointers to member data:
void func(base&);
struct fun_obj {
void operator()() const;
bool operator()(int) const;
};
fun_obj obj;
With these additional definitions, rule 5 gives the following meanings to these uses of INVOKE:
Phrase
Meaning
INVOKE (func, d)
func(d)
INVOKE (obj)
obj()
INVOKE (obj, 3)
obj(3)
@金慶
呵呵，我是說這個(gè)名字怎么這么面熟呢？
有時(shí)間把a(bǔ)sio翻譯翻譯吧，哈哈。。。
我英語不是很好，簡單點(diǎn)的還成，稍微復(fù)雜點(diǎn)的句子就迷糊了，呵呵。
asio東拼西湊的看了一些資料，由于沒有完整的理解到所有的東西，所以用的時(shí)候總是畏首畏尾的，呵呵。
樓主，學(xué)習(xí)C++和Boost的時(shí)候看到了您的很多資料，非常感謝您的無私奉獻(xiàn)！
現(xiàn)在大學(xué)要畢業(yè)了，以后可能沒這么多時(shí)間像現(xiàn)在一樣學(xué)習(xí)了，呵呵。
感謝樓主!感謝金慶。
您是google的boost翻譯組的嗎？我看到了您的一些貢獻(xiàn)。
re: 一本好書[未登錄] 董波 2009-05-24 19:55
《實(shí)時(shí)計(jì)算機(jī)圖形學(xué)》第三版都出了，強(qiáng)烈期待中文翻譯版本啊，英文我瞅不懂。