在逆战的界面开发中,一般只需要从uc往flash中单向传输数据,因此这里只总结从uc->flash的数据流动方法。flash->uc的数据流动,其实有相对应的方式,比如SetVariableBool函数有对应的GetVariableBool函数。

在unrealscript中,使用scaleform的界面类,都继承自GfxMoviePlayer。

一、传输变量

阅读全文 »

我不知道现在的win8和win10系统上是不是自动显示tga格式的缩略图的。我的win7系统确实有时候显示不了。为什么有这样的需求了,因为我现在的工作是开发游戏,虽然这几个月在写界面。在网上搜到有一个这样的软件MysticThumbs。这显然是外国友人做的东西,肯定是要注册的,官网上面下载的肯定是的,要交钱的。伟大的天朝人民肯定有破解版本了。

下面分享下我下载到的破解版本,里面有使用说明,MysticThumbs破解版本。虽然说里面有破解说明,既然写了这篇文章,我就是想更简略的说明下如何使用。

1.打开之后,直接运行MysticThumbs3.0.0.Multi+Pt FULL。假设安装到默认路径。

阅读全文 »

7月26号封闭培训,到部门来已经是8月10号了。刚开始懵懵懂懂的,不知道干啥。部门上课的那几天,把新人手册的步骤做了一遍。悲伤的是,做完之后不少忘记了。编译脚本的addin插件至今没有显示出来,虽然有几天它显示过。除此之外,还有不少纠结过的问题。让我一一道来吧。配置vs字体和颜色,va快捷键,查找快捷键无效,F12查看定义无效,uc断点无效,调试uc时候游戏进程掉了。。。下面来说说成功解决掉的几个问题吧,非常感谢jerry哥和vivin姐的帮忙。

1.vs的字体和颜色。默认字体是新宋体,这个字体据说不是很好,推荐consolas字体。颜色的话,有个网站叫做https://studiostyl.es/
可以去里面选自己喜欢的风格,设置好就行。值得注意的是,安装nfringe后,字体颜色设置面板里面会出现unrealscript相关的设置,注意修改。
如图所示,

另一个需要注意的地方是,与.uc文件不同,.cpp中的代码颜色是在visual assist x中修改的,这个我找了半天才反应过来。

阅读全文 »

vector是一直在用的东西,太常用了,数组的替代品。大多数时候,都想不出理由不用vector,改用list,deque之类的。从功能来看,vector就是一个动态的数组而已。使用vector时候,唯一需要注意的是,当重新申请更大空间时候,是去了一块新内存,而不是直接在原地址增加,所有迭代器是都会失效的。当然还有其它操作造成某些迭代器失效。

下面来看看vector的部分定义。全部定义过于冗长了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
template <class T, class Alloc = alloc>  // 預設使用 alloc 為配置器
class vector {
public:
// 以下標示 (1),(2),(3),(4),(5),代表 iterator_traits<I> 所服務的5個型別。
typedef T value_type; // (1)
typedef value_type* pointer; // (2)
typedef const value_type* const_pointer;
typedef const value_type* const_iterator;
typedef value_type reference; // (3)
typedef const value_type const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type; // (4)
// 以下,由於vector 所維護的是一個連續線性空間,所以不論其元素型別為何,
// 原生指標都可以做為其迭代器而滿足所有需求。
typedef value_type* iterator;

protected:
// 專屬之空間配置器,每次配置一個元素大小
typedef simple_alloc<value_type, Alloc> data_allocator;

// vector採用簡單的線性連續空間。以兩個迭代器start和end分別指向頭尾,
// 並以迭代器end_of_storage指向容量尾端。容量可能比(尾-頭)還大,
// 多餘即備用空間。
iterator start;
iterator finish;
iterator end_of_storage;

void insert_aux(iterator position, const T x);
void deallocate() {
if (start)
data_allocator::deallocate(start, end_of_storage - start);
}

void fill_initialize(size_type n, const T value) {
start = allocate_and_fill(n, value); // 配置空間並設初值
finish = start + n; // 調整水位
end_of_storage = finish; // 調整水位
}

public:
iterator begin() { return start; }
const_iterator begin() const { return start; }
iterator end() { return finish; }
const_iterator end() const { return finish; }
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
size_type size() const { return size_type(end() - begin()); }
size_type max_size() const { return size_type(-1) / sizeof(T); }
size_type capacity() const { return size_type(end_of_storage - begin()); }
bool empty() const { return begin() == end(); }
reference operator[](size_type n) { return *(begin() + n); }
const_reference operator[](size_type n) const { return *(begin() + n); }

vector() : start(0), finish(0), end_of_storage(0) {}
// 以下建構式,允許指定大小 n 和初值 value
vector(size_type n, const T value) { fill_initialize(n, value); }
vector(int n, const T value) { fill_initialize(n, value); }
vector(long n, const T value) { fill_initialize(n, value); }
explicit vector(size_type n) { fill_initialize(n, T()); }

vector(const vector<T, Alloc> x) {
start = allocate_and_copy(x.end() - x.begin(), x.begin(), x.end());
finish = start + (x.end() - x.begin());
end_of_storage = finish;
}

vector(const_iterator first, const_iterator last) {
size_type n = 0;
distance(first, last, n);
start = allocate_and_copy(n, first, last);
finish = start + n;
end_of_storage = finish;
}

~vector() {
destroy(start, finish); // 全域函式,建構/解構基本工具。
deallocate(); // 先前定義好的成員函式
}
vector<T, Alloc> operator=(const vector<T, Alloc> x);
void reserve(size_type n) {
if (capacity() < n) {
const size_type old_size = size();
iterator tmp = allocate_and_copy(n, start, finish);
destroy(start, finish);
deallocate();
start = tmp;
finish = tmp + old_size;
end_of_storage = start + n;
}
}

// 取出第一個元素內容
reference front() { return *begin(); }
const_reference front() const { return *begin(); }
// 取出最後一個元素內容
reference back() { return *(end() - 1); }
const_reference back() const { return *(end() - 1); }
// 增加一個元素,做為最後元素
void push_back(const T x) {
if (finish != end_of_storage) { // 還有備用空間
construct(finish, x); // 直接在備用空間中建構元素。
++finish; // 調整水位高度
}
else // 已無備用空間
insert_aux(end(), x);
}

void pop_back() {
--finish;
destroy(finish); // 全域函式,建構/解構基本工具。
}
// 將迭代器 position 所指之元素移除
iterator erase(iterator position) {
if (position + 1 != end()) // 如果 p 不是指向最後一個元素
// 將 p 之後的元素一一向前遞移
copy(position + 1, finish, position);

--finish; // 調整水位
destroy(finish); // 全域函式,建構/解構基本工具。
return position;
}
iterator erase(iterator first, iterator last) {
iterator i = copy(last, finish, first);
destroy(i, finish); // 全域函式,建構/解構基本工具。
finish = finish - (last - first);
return first;
}
void resize(size_type new_size, const T x) {
if (new_size < size())
erase(begin() + new_size, end());
else
insert(end(), new_size - size(), x);
}
void resize(size_type new_size) { resize(new_size, T()); }
// 清除全部元素。注意,並未釋放空間,以備可能未來還會新加入元素。
void clear() { erase(begin(), end()); }

protected:
iterator allocate_and_fill(size_type n, const T x) {
iterator result = data_allocator::allocate(n); // 配置n個元素空間
// 全域函式,記憶體低階工具,將result所指之未初始化空間設定初值為 x,n個
// 定義於 <stl_uninitialized.h>。
uninitialized_fill_n(result, n, x);
return result;
}
}
阅读全文 »

很久没更新博客了。额,一直想写这个来着。记得以前写过绘制三维标量场的文章,方法是找的渐变颜色纹理图片,然后用一维纹理坐标映射贴上去的。后面发现根本不需要去找图片,这种渐变色本来就是一种颜色空间的定义。请看hsv颜色模型,这种颜色模型类似于rgb,也是三个分量h(色调),s(饱和度),v(亮度)。h表示的绕圆锥的一周,也就是纯颜色的渐变,正是我们需要的东西。s表示从圆心到圆边缘的半径,0-1的范围,表示颜色纯度。v则是垂直的轴,表示亮度。如下图,我们要的就是绕圈一周的颜色渐变。

总体思路就是数值0-1,映射到hsv颜色空间的(0-360,1,255)。实现标量场的方法是,首先,将hsv的(0-360,1,255)转换为rgb,保存为一维数组。以该数组为数据,生成一维纹理,数值0-1作为纹理坐标,再贴图即可生成标量场。下面是用该方法生成标量场的相关代码。首先是构造一维纹理数组,然后用其生成1d纹理。

阅读全文 »

很久没骑这么远了。第一次骑三天都不知道是怎么坚持过来的。总的感觉,身体比去年好太多了。虽然脚累,但是呼吸完全不乱,完全不会心累。中午吃错东西了,一开始就来个闹肚子、过敏。我对某种食物强过敏,当时就在为自己生命安全思考了。本打算骑到附近的梅溪湖算了,但是吹了下风,觉得过敏消散了,就坚持走走看吧。

雷锋大道真的好远,从河西走完整个望城。经过去年的洗心禅寺,发现好近额。为啥去年我走这么点距离会觉得好累了。有些改变确实在不知不觉。不管是身,还是心。永远健康充满活力的身体,是追寻幸福的必要条件。

最后,附图一张。

阅读全文 »

排序的重要性就不用说了。stl里面的很多容器都是自序的,比如set和map,从begin到end就是一个顺序,毕竟最基本的概念就是一颗搜索树。另外,stack、queue、priority_queue的顺序也是内部实现决定的,不用多说了。list则不支持随机迭代器,内部也提供sort函数。所以,stl里面的sort泛型算法针对的是vector,deque,原生数组之类的数据。正常情况下,用的最多的也就是vector了。

插入排序和快速排序大家都知道是什么。但是,stl里面的sort并不仅仅是一个快速排序,而是一个复杂的组合体,有人把它叫做intro_sort。下面说一下introsort的几点要点。

1> 递归层次的限制,超过一定层次直接堆排序剩余数据。

阅读全文 »

这里只讲解稀疏矩阵表示的线性系统。最新版本的eigen已经支持稀疏矩阵,以及相关操作了。eigen相对其它库的最大优势,默认情况下,只需要eigen的头文件即可,不需要其它依赖库,除非用对应的加速解法(需要更快的库支持)。所以,eigen就是个牛逼的模板矩阵库。虽然在使用的时候需要套用不少模板参数,有点麻烦。

eigen里面定义稀疏矩阵,然后加入数据的一种方式如下:

1
2
3
4
5
6
7
8
Eigen::SparseMatrix<float> smA(m_nRow, m_nColumn);

std::sort(m_pSI, m_pSI + m_nNum);//排序,列主序
for (int i = 0; i < m_nNum; ++i)// 初始化非零元素
{
smA.insert(m_pSI[i].r, m_pSI[i].c) = m_pSI[i].v;
}
smA.makeCompressed();
阅读全文 »

以前写过一篇C++调用MATLAB引擎计算特征向量,里面讲了如何配置环境等等。现在又有一个新的需求,求解线性系统。又想起了MATLAB这个工具,于是又写了个小类。这里要求解的是AX=B。其中,A是m*n的矩阵,X是n维行向量,B是m维列向量。MATLAB里面求解很简单X=A\B。

该类的头文件如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//求解线性系统AX = B.
//A是Row*Column的矩阵,B是Row*1的列向量
class CLinearSystem
{
public:
CLinearSystem() {}
CLinearSystem(double* pMatrixA, int nRow, int nColumn, double* pColumnB);
~CLinearSystem() {}

public:
void GetResult(double* pX);//pX保证能输出m_nColumn个元素

private:
double* m_pMatrixA;
double* m_pColumnB;
int m_nRow;
int m_nColumn;
};
阅读全文 »

这是一个很老的话题了。所谓的反射机制,其实就是MFC里面的对象动态创建。比如说,给一个字符串代表类名,比如”CMesh”,根据这个字符串创建出一个CMesh对象。有不同的实现方法,在MFC里面是用一张巨大的链表网络把所有的类的信息链接起来,里面存储了类名和构造函数,动态创建的时候按照一定的顺序去里面搜索创建函数(构造函数)。

与其用一张链表网,不如用一个字典保存起来,键是类名字符串,值是对应的构造函数。看起来很简单的样子,确实也很简单额。只是实现起来有些trick,比如字典一般是类的静态成员等。。。假设只有无参数的构造函数,首先定义上面所述的内容,类的字典。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//头文件
typedef void* (*CreateFuntion)(void);

class CClassFactory
{
public:
CClassFactory() {}
~CClassFactory() {}

public:
static void* GetClassByName(std::string name)
{
std::map<std::string, CreateFuntion>::const_iterator find;
find = m_clsMap.find(name);

if(find==m_clsMap.end())
{

return NULL;
}
else
{
return find->second();
}

}

static void RegistClass(std::string name, CreateFuntion method)
{
m_clsMap.insert(std::make_pair(name,method));
}

private:
static std::map<std::string,CreateFuntion> m_clsMap;
};
//源文件
std::map<std::string, CreateFuntion> CClassFactory::m_clsMap;
阅读全文 »