\documentclass{beamer}
\usetheme{Warsaw}
\usepackage{fontspec,xunicode,xltxtra}
\usepackage[slantfont,boldfont]{xeCJK} % 允许斜体和粗体
\setbeamercovered{transparent}
\usepackage[english]{babel}
% or whatever
\usepackage{hyperref}
\usepackage[T1]{fontenc}
% or whatever
\usefonttheme{professionalfonts}
\usepackage{times}
\usepackage{mathptmx}
\usepackage{tabularx}
% Or whatever. Note that the encoding and the font should match. If T1
% does not look nice, try deleting the line with the fontenc.
\usepackage{xcolor}
\usepackage{booktabs, multirow, enumerate}
\usepackage{animate}
\usepackage{multimedia}

% ... or whatever. Note that the encoding and the font should match.
% If T1 does not look nice, try deleting the line with the fontenc.
\usepackage{lmodern} %optional
\usepackage{listings}

% Delete this, if you do not want the table of contents to pop up at
% the beginning of each subsection:
\AtBeginSection[]
{
    \begin{frame}<beamer>
        \frametitle{内容大纲}
        \tableofcontents[currentsection]
    \end{frame}
}

\setCJKmainfont{Microsoft YaHei}   % 设置缺省中文字体
\setCJKmonofont{SimSun}   % 设置等宽字体
\setmainfont{TeX Gyre Pagella} % 英文衬线字体
\setmonofont{Microsoft YaHei} % 英文等宽字体
\setsansfont{Trebuchet MS} % 英文无衬线字体

\begin{document}

\title[***纹理***]% optional, use only with long paper titles
{ ***纹理***\\[2ex]}

%\subtitle[malloc] %optional
%{malloc\ 实现}

\author[yx] % optional, use only with lots of authors
{
\textcolor[rgb]{0.00, 0.41, 0.66}{yx}
}

% the titlepage
% the plain option removes the sidebar and header from the title page
\begin{frame}[plain]
  \titlepage
\end{frame}
%%%%%%%%%%%%%%%%

\begin{frame}
        \frametitle{内容大纲}
        \tableofcontents
\end{frame}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{研究背景和意义}
%%%%%%%%%%%%%%%%
\begin{frame}{纹理的作用}{}
  \begin{block}<1->{}
    纹理是图形学中增强真实性的重要手段。
  \end{block}
  \begin{block}<2->{}
    应用纹理到三维表面能够有效的表示物体表面的颜色，材质，几何等属性。
  \end{block}
\end{frame}
%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\end{document}

test.uc中：
String strTest = "测试";
String path = "_root.TestFlash.strTest";
SetVariableString(path，strTest);
TestFlash.as中：
var strTest:String;

test.uc中：
local array<String> strArray;
strArray.AddItem("0");
strArray.AddItem("1");
String path = "_root.TestFlash.strTest";
SetVariableStringArray(path，strArray);
TestFlash.as中：
var strArray:Array = new Array();

struct RankData
{
   var string Name;
   var int Rank;
   var double d;
   var float f;
   var bool b;
};
RankData RD;

uc中:
struct RankData
{
   var string Name;
   var int Rank;
   var double d;
   var float f;
   var bool b;
};

function SetFlashVariables()
{
    local GFxObject GfxObj;
    local RankData RD;
    local string path;

    RD.Name = "test";
    RD.Rank = 1;
    RD.d = 1.0;
    RD.f = 1.0;
    RD.b = True;
    GfxObj = CreateObject("Object");
    GfxObj.SetString("Name", RD.Name);
    GfxObj.SetInt("Rank", RD.Rank);
    GfxObj.SetDouble("d", RD.d);
    GfxObj.SetFloat("f", RD.f);
    GfxObj.SetBool("b", RD.b);

    path = "_root.TestFlash.RD"
    SetVariableObject(path, GfxObj);
    GfxObj.DestroyObject();
}

TestFlash.as中:
var RD:Object = new Object();
//在uc中调用了SetFlashVariables函数后，as中就能获得RD的值。
trace(RD.Name);
trace(RD.Name);
trace(RD.f);
trace(RD.d);
trace(RD.b);

native final function SetBool(string Member, bool b);
native final function SetFloat(string Member, float f);
native final function SetDouble(string Member,double d);
native final function SetInt(string Member,int i);
native final function SetString(string Member, string s);
native final function SetObject(string Member, GFxObject val);

//军衔列表每项的数据
struct RankListData
{
    var int Level;//等级
    var string Name;//军衔名
};
var array<RankListData> RankListDatas;
var string path;
function SetFlashRankListDatas()
{
    local int Index;
    local GFxObject GfxRankListDatas;
    local GFxObject GfxTempObj;

    GfxRankListDatas = CreateArray();
    for (Index = 0; Index < RankDatas.Length; Index++)//第0项是多余的
    {        
        GfxTempObj = CreateObject("Object");
        GfxTempObj.SetInt("Level", RankListDatas[Index].Level);
        GfxTempObj.SetString("Name", RankListDatas[Index].Name);
        GfxRankListDatas.SetElementObject(Index, GfxTempObj);
        GfxTempObj.DestroyObject();
    }

    SetVariableObject(path, GfxRankListDatas);
    GfxRankListDatas.DestroyObject();
}

struct AwardData
{
    var string IconSource;
};

struct RankAwardData
{
    var string RankAwardTitle;
    var array<AwardData> AwardDatas;
};
var array<RankAwardData> RankAwardDatas;
var string path;

function SetFlashRankAwardDatas()
{
    local int Index;
    local int i;
    local GFxObject GfxRankAwardDatas;
    local GFxObject GfxTempObj;
    local GFxObject GfxAwardDatas;
    local GFxObject GfxAwardTempObj;

    GfxRankAwardDatas = CreateArray();
    for (Index = 0; Index < RankAwardDatas.Length; Index++)
    {        
        GfxTempObj = CreateObject("Object");
        GfxTempObj.SetString("RankAwardTitle", RankAwardDatas[Index].RankAwardTitle);

        GfxAwardDatas = CreateArray();
        for (i = 0; i < RankAwardDatas[Index].AwardDatas.Length; ++i)
        {
            GfxAwardTempObj = CreateObject("Object");
            GfxAwardTempObj.SetString("IconSource", RankAwardDatas[Index].AwardDatas[i].IconSource);
            GfxAwardDatas.SetElementObject(i, GfxAwardTempObj);
            GfxAwardTempObj.DestroyObject();
        }
        GfxTempObj.SetObject("RankAward", GfxAwardDatas);
        GfxRankAwardDatas.SetElementObject(Index, GfxTempObj);
        GfxAwardDatas.DestroyObject();
        GfxTempObj.DestroyObject();
    }

    SetVariableObject(path, GfxRankAwardDatas);
    GfxRankAwardDatas.DestroyObject();
}

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;
  }
}

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

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;
 }

int CTexture::BuildColorMapTexture()
{
        const int COLOR_SIZE = 240;//红到蓝
        ImageRGBA colorMap(COLOR_SIZE, 1);

        for (int i = 0; i < COLOR_SIZE; ++i)
        {
            colorMap.pixel(i, 0) = Hsv2Rgb(i, 1, 255);
        }

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glGenTextures(1, m_uTexName);
        glBindTexture(GL_TEXTURE_1D, m_uTexName);

        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

        //生成2d的Mipmap纹理
        int nRet = gluBuild1DMipmaps(GL_TEXTURE_1D, 4, COLOR_SIZE, GL_RGBA, GL_UNSIGNED_BYTE,
            colorMap.raw());

        if (nRet != 0)
        {
            return 0;
        }

        return 1;
}

PixelRGBA Hsv2Rgb(float H, float S, float V)
{
        float R, G, B;

        int i;
        float f, p, q, t;
        if(S == 0)
        {
            // achromatic (grey)
            R = G = B = V;
            return V4B(R, G, B, 255);
        }

        H /= 60; // sector 0 to 5
        i = floor( H );
        f = H - i; // factorial part of h
        p = V * ( 1 - S );
        q = V * ( 1 - S * f );
        t = V * ( 1 - S * ( 1 - f ) );

        switch( i )
        {
        case 0:
            R = V;
            G = t;
            B = p;
            break;
        case 1:
            R = q;
            G = V;
            B = p;
            break;
        case 2:
            R = p;
            G = V;
            B = t;
            break;
        case 3:
            R = p;
            G = q;
            B = V;
            break;
        case 4:
            R = t;
            G = p;
            B = V;
            break;
        default: // case 5:
            R = V;
            G = p;
            B = q;
            break;
        }

        return V4B(R, G, B, 255);
}