lzx's Blog

Nexus One 拆机揭秘

liuzaoxingseu@gmail.com(lzx) — Thu,07 Jan 2010 20:41:55 +0800

见机就拆的iFixit网站已经完成了对Nexus One的解剖，最大的收获是发现了FM发射/接收器，这是Google之前没有提到的。

拆开后盖，绿色部分为保修贴纸，撕毁无效，桔色部分为LED闪光灯模块，红色部分为500万像素摄像头，而黄色部分则是外置喇叭：

Nexus One整合度很高，在卸下三颗螺丝之后就需要借助iPod拆解工具了，先拆下电池仓再说：
还是在iPod拆卸工具的帮助下，继续翘开上侧的盖子，下面隐藏有很多金属引脚：
从下面慢慢抽出包着主板的一块黑色外壳，主板的下方显现出来了，里面真是五彩斑斓，桔色、绿色、黄色、深灰色一大堆东西：

接下来继续卸螺丝，之后终于可以把整个主板抽出来了：

拿下华丽的AMOLED触摸屏幕：

仔细看看Synaptics触摸屏幕控制器，芯片上写着“T1007A, 2 0927, AMP08P”，可惜的是我们现在还找不到这颗芯片的资料：

看看我们都看到什么芯片了，有Samsung 943 KA1000015M-AJTT（红色），Skyworks SKY77336 GSM 功放 (SKY77336-21 3888833 1P 0940 MX桔色)，一个高通的芯片（黄色）和一个不知名的芯片（绿色）：

高通的Snapdragon大芯片QSD8250是Nexus One速度取胜的关键，主板上一共有三颗高通的芯片。左侧还有一个RTR6285 RF接收器：

还有一枚不明身份的小东东：

这里是蓝牙和802.11n无线芯片Broadcom BCM4329（BCM4329EKUBG CD0942 P21 937322 5EA），802.11n的速度可比只有802.11g的iPhone 3GS快老鼻子了，不过这颗芯片在第三代iPod touch里也有，就是说iPhone OS 4.0可能会开启第三代iPod touch的802.11n上网功能，iPhone第四代肯定也会是这样：

还有三个芯片，但都被焊接剂给盖住了：

【自己动手】ACER笔记本电脑的Insybe bios的刷写教程，激活WIN7必需

liuzaoxingseu@gmail.com(lzx) — Thu,24 Dec 2009 20:37:55 +0800

   ACER的Insybe bios一直比较难修改，很不方便，对于一些新手上手比较麻烦。不像ASUS的AMI的BIOS很好修改。在这里，我提供一份PDF，希望使用ACER的Insybe bios本子的朋友能够顺利装上WIN7。
  提供在google docs的链接，请查看教程查看请点这里

比较完善的3DS导入OPENGL的C++代码

liuzaoxingseu@gmail.com(lzx) — Fri,18 Dec 2009 16:25:21 +0800

源程序下载（下载后请去掉.chm）：
点击下载此文件

以下是3DS.cpp:
#include "main.h"
#include "3ds.h"

//  构造函数的功能是初始化tChunk数据
CLoad3DS::CLoad3DS()
{
    m_CurrentChunk = new tChunk;                // 初始化并为当前的块分配空间
    m_TempChunk = new tChunk;                    // 初始化一个临时块并分配空间
}

//  打开一个3ds文件，读出其中的内容，并释放内存
bool CLoad3DS::Import3DS(t3DModel *pModel, char *strFileName)
{
    char strMessage[255] = {0};

    // 打开一个3ds文件
    m_FilePointer = fopen(strFileName, "rb");

    // 确保所获得的文件指针合法
    if(!m_FilePointer)
    {
        sprintf(strMessage, "Unable to find the file: %s!", strFileName);
        MessageBox(NULL, strMessage, "Error", MB_OK);
        return false;
    }

    // 当文件打开之后，首先应该将文件最开始的数据块读出以判断是否是一个3ds文件
    // 如果是3ds文件的话，第一个块ID应该是PRIMARY

    // 将文件的第一块读出并判断是否是3ds文件
    ReadChunk(m_CurrentChunk);

    // 确保是3ds文件
    if (m_CurrentChunk->ID != PRIMARY)
    {
        sprintf(strMessage, "Unable to load PRIMARY chuck from file: %s!", strFileName);
        MessageBox(NULL, strMessage, "Error", MB_OK);
        return false;
    }

    // 现在开始读入数据，ProcessNextChunk()是一个递归函数

    // 通过调用下面的递归函数，将对象读出
    ProcessNextChunk(pModel, m_CurrentChunk);

    // 在读完整个3ds文件之后，计算顶点的法线
    ComputeNormals(pModel);

    // 释放内存空间
    CleanUp();

    return true;
}

//  下面的函数释放所有的内存空间，并关闭文件
void CLoad3DS::CleanUp()
{

    fclose(m_FilePointer);                        // 关闭当前的文件指针
    delete m_CurrentChunk;                        // 释放当前块
    delete m_TempChunk;                            // 释放临时块
}

//  下面的函数读出3ds文件的主要部分
void CLoad3DS::ProcessNextChunk(t3DModel *pModel, tChunk *pPreviousChunk)
{
    t3DObject newObject = {0};                    // 用来添加到对象链表
    tMaterialInfo newTexture = {0};                // 用来添加到材质链表
    unsigned int version = 0;                    // 保存文件版本
    int buffer[50000] = {0};                    // 用来跳过不需要的数据

    m_CurrentChunk = new tChunk;                // 为新的块分配空间

    //  下面每读一个新块，都要判断一下块的ID，如果该块是需要的读入的，则继续进行
    //  如果是不需要读入的块，则略过

    // 继续读入子块，直到达到预定的长度
    while (pPreviousChunk->bytesRead < pPreviousChunk->length)
    {
        // 读入下一个块
        ReadChunk(m_CurrentChunk);

        // 判断块的ID号
        switch (m_CurrentChunk->ID)
        {
        case VERSION:                            // 文件版本号

            // 在该块中有一个无符号短整型数保存了文件的版本

            // 读入文件的版本号，并将字节数添加到bytesRead变量中
            m_CurrentChunk->bytesRead += fread(&version, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);

            // 如果文件版本号大于3，给出一个警告信息
            if (version > 0x03)
                MessageBox(NULL, "This 3DS file is over version 3 so it may load incorrectly", "Warning", MB_OK);
            break;

        case OBJECTINFO:                        // 网格版本信息

            // 读入下一个块
            ReadChunk(m_TempChunk);

            // 获得网格的版本号
            m_TempChunk->bytesRead += fread(&version, 1, m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer);

            // 增加读入的字节数
            m_CurrentChunk->bytesRead += m_TempChunk->bytesRead;

            // 进入下一个块
            ProcessNextChunk(pModel, m_CurrentChunk);
            break;

        case MATERIAL:                            // 材质信息

            // 材质的数目递增
            pModel->numOfMaterials++;

            // 在纹理链表中添加一个空白纹理结构
            pModel->pMaterials.push_back(newTexture);

            // 进入材质装入函数
            ProcessNextMaterialChunk(pModel, m_CurrentChunk);
            break;

        case OBJECT:                            // 对象的名称

            // 该块是对象信息块的头部，保存了对象了名称

            // 对象数递增
            pModel->numOfObjects++;

            // 添加一个新的tObject节点到对象链表中
            pModel->pObject.push_back(newObject);

            // 初始化对象和它的所有数据成员
            memset(&(pModel->pObject[pModel->numOfObjects - 1]), 0, sizeof(t3DObject));

            // 获得并保存对象的名称，然后增加读入的字节数
            m_CurrentChunk->bytesRead += GetString(pModel->pObject[pModel->numOfObjects - 1].strName);

            // 进入其余的对象信息的读入
            ProcessNextObjectChunk(pModel, &(pModel->pObject[pModel->numOfObjects - 1]), m_CurrentChunk);
            break;

        case EDITKEYFRAME:

            // 跳过关键帧块的读入，增加需要读入的字节数
            m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;

        default:

            //  跳过所有忽略的块的内容的读入，增加需要读入的字节数
            m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;
        }

        // 增加从最后块读入的字节数
        pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;
    }

    // 释放当前块的内存空间
    delete m_CurrentChunk;
    m_CurrentChunk = pPreviousChunk;
}

//  下面的函数处理所有的文件中对象的信息
void CLoad3DS::ProcessNextObjectChunk(t3DModel *pModel, t3DObject *pObject, tChunk *pPreviousChunk)
{
    int buffer[50000] = {0};                    // 用于读入不需要的数据

    // 对新的块分配存储空间
    m_CurrentChunk = new tChunk;

    // 继续读入块的内容直至本子块结束
    while (pPreviousChunk->bytesRead < pPreviousChunk->length)
    {
        // 读入下一个块
        ReadChunk(m_CurrentChunk);

        // 区别读入是哪种块
        switch (m_CurrentChunk->ID)
        {
        case OBJECT_MESH:                    // 正读入的是一个新块

            // 使用递归函数调用，处理该新块
            ProcessNextObjectChunk(pModel, pObject, m_CurrentChunk);
            break;

        case OBJECT_VERTICES:                // 读入是对象顶点
            ReadVertices(pObject, m_CurrentChunk);
            break;

        case OBJECT_FACES:                    // 读入的是对象的面
            ReadVertexIndices(pObject, m_CurrentChunk);
            break;

        case OBJECT_MATERIAL:                // 读入的是对象的材质名称

            // 该块保存了对象材质的名称，可能是一个颜色，也可能是一个纹理映射。同时在该块中也保存了
            // 纹理对象所赋予的面

            // 下面读入对象的材质名称
            ReadObjectMaterial(pModel, pObject, m_CurrentChunk);
            break;

        case OBJECT_UV:                        // 读入对象的UV纹理坐标

            // 读入对象的UV纹理坐标
            ReadUVCoordinates(pObject, m_CurrentChunk);
            break;

        default:

            // 略过不需要读入的块
            m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;
        }

        // 添加从最后块中读入的字节数到前面的读入的字节中
        pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;
    }

    // 释放当前块的内存空间，并把当前块设置为前面块
    delete m_CurrentChunk;
    m_CurrentChunk = pPreviousChunk;
}

//  下面的函数处理所有的材质信息
void CLoad3DS::ProcessNextMaterialChunk(t3DModel *pModel, tChunk *pPreviousChunk)
{
    int buffer[50000] = {0};                    // 用于读入不需要的数据

    // 给当前块分配存储空间
    m_CurrentChunk = new tChunk;

    // 继续读入这些块，知道该子块结束
    while (pPreviousChunk->bytesRead < pPreviousChunk->length)
    {
        // 读入下一块
        ReadChunk(m_CurrentChunk);

        // 判断读入的是什么块
        switch (m_CurrentChunk->ID)
        {
        case MATNAME:                            // 材质的名称

            // 读入材质的名称
            m_CurrentChunk->bytesRead += fread(pModel->pMaterials[pModel->numOfMaterials - 1].strName, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;

        case MATDIFFUSE:                        // 对象的R G B颜色
            ReadColorChunk(&(pModel->pMaterials[pModel->numOfMaterials - 1]), m_CurrentChunk);
            break;

        case MATMAP:                            // 纹理信息的头部

            // 进入下一个材质块信息
            ProcessNextMaterialChunk(pModel, m_CurrentChunk);
            break;

        case MATMAPFILE:                        // 材质文件的名称

            // 读入材质的文件名称
            m_CurrentChunk->bytesRead += fread(pModel->pMaterials[pModel->numOfMaterials - 1].strFile, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;

        default:

            // 掠过不需要读入的块
            m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;
        }

        // 添加从最后块中读入的字节数
        pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;
    }

    // 删除当前块，并将当前块设置为前面的块
    delete m_CurrentChunk;
    m_CurrentChunk = pPreviousChunk;
}

//  下面函数读入块的ID号和它的字节长度
void CLoad3DS::ReadChunk(tChunk *pChunk)
{
    // 读入块的ID号，占用了2个字节。块的ID号象OBJECT或MATERIAL一样，说明了在块中所包含的内容
    pChunk->bytesRead = fread(&pChunk->ID, 1, 2, m_FilePointer);

    // 然后读入块占用的长度，包含了四个字节
    pChunk->bytesRead += fread(&pChunk->length, 1, 4, m_FilePointer);
}

//  下面的函数读入一个字符串
int CLoad3DS::GetString(char *pBuffer)
{
    int index = 0;

    // 读入一个字节的数据
    fread(pBuffer, 1, 1, m_FilePointer);

    // 直到结束
    while (*(pBuffer + index++) != 0) {

        // 读入一个字符直到NULL
        fread(pBuffer + index, 1, 1, m_FilePointer);
    }

    // 返回字符串的长度
    return strlen(pBuffer) + 1;
}

//  下面的函数读入RGB颜色
void CLoad3DS::ReadColorChunk(tMaterialInfo *pMaterial, tChunk *pChunk)
{
    // 读入颜色块信息
    ReadChunk(m_TempChunk);

    // 读入RGB颜色
    m_TempChunk->bytesRead += fread(pMaterial->color, 1, m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer);

    // 增加读入的字节数
    pChunk->bytesRead += m_TempChunk->bytesRead;
}

//  下面的函数读入顶点索引
void CLoad3DS::ReadVertexIndices(t3DObject *pObject, tChunk *pPreviousChunk)
{
    unsigned short index = 0;                    // 用于读入当前面的索引

    // 读入该对象中面的数目
    pPreviousChunk->bytesRead += fread(&pObject->numOfFaces, 1, 2, m_FilePointer);

    // 分配所有面的存储空间，并初始化结构
    pObject->pFaces = new tFace [pObject->numOfFaces];
    memset(pObject->pFaces, 0, sizeof(tFace) * pObject->numOfFaces);

    // 遍历对象中所有的面
    for(int i = 0; i < pObject->numOfFaces; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            // 读入当前面的第一个点
            pPreviousChunk->bytesRead += fread(&index, 1, sizeof(index), m_FilePointer);

            if(j < 3)
            {
                // 将索引保存在面的结构中
                pObject->pFaces[i].vertIndex[j] = index;
            }
        }
    }
}

//  下面的函数读入对象的UV坐标
void CLoad3DS::ReadUVCoordinates(t3DObject *pObject, tChunk *pPreviousChunk)
{
    // 为了读入对象的UV坐标，首先需要读入UV坐标的数量，然后才读入具体的数据

    // 读入UV坐标的数量
    pPreviousChunk->bytesRead += fread(&pObject->numTexVertex, 1, 2, m_FilePointer);

    // 分配保存UV坐标的内存空间
    pObject->pTexVerts = new CVector2 [pObject->numTexVertex];

    // 读入纹理坐标
    pPreviousChunk->bytesRead += fread(pObject->pTexVerts, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);
}

//  读入对象的顶点
void CLoad3DS::ReadVertices(t3DObject *pObject, tChunk *pPreviousChunk)
{
    // 在读入实际的顶点之前，首先必须确定需要读入多少个顶点。

    // 读入顶点的数目
    pPreviousChunk->bytesRead += fread(&(pObject->numOfVerts), 1, 2, m_FilePointer);

    // 分配顶点的存储空间，然后初始化结构体
    pObject->pVerts = new CVector3 [pObject->numOfVerts];
    memset(pObject->pVerts, 0, sizeof(CVector3) * pObject->numOfVerts);

    // 读入顶点序列
    pPreviousChunk->bytesRead += fread(pObject->pVerts, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);

    // 现在已经读入了所有的顶点。
    // 因为3D Studio Max的模型的Z轴是指向上的，因此需要将y轴和z轴翻转过来。
    // 具体的做法是将Y轴和Z轴交换，然后将Z轴反向。

    // 遍历所有的顶点
    for(int i = 0; i < pObject->numOfVerts; i++)
    {
        // 保存Y轴的值
        float fTempY = pObject->pVerts[i].y;

        // 设置Y轴的值等于Z轴的值
        pObject->pVerts[i].y = pObject->pVerts[i].z;

        // 设置Z轴的值等于-Y轴的值
        pObject->pVerts[i].z = -fTempY;
    }
}

//  下面的函数读入对象的材质名称
void CLoad3DS::ReadObjectMaterial(t3DModel *pModel, t3DObject *pObject, tChunk *pPreviousChunk)
{
    char strMaterial[255] = {0};            // 用来保存对象的材质名称
    int buffer[50000] = {0};                // 用来读入不需要的数据

    // 材质或者是颜色，或者是对象的纹理，也可能保存了象明亮度、发光度等信息。

    // 下面读入赋予当前对象的材质名称
    pPreviousChunk->bytesRead += GetString(strMaterial);

    // 遍历所有的纹理
    for(int i = 0; i < pModel->numOfMaterials; i++)
    {
        //如果读入的纹理与当前的纹理名称匹配
        if(strcmp(strMaterial, pModel->pMaterials[i].strName) == 0)
        {
            // 设置材质ID
            pObject->materialID = i;

            // 判断是否是纹理映射，如果strFile是一个长度大于1的字符串，则是纹理
            if(strlen(pModel->pMaterials[i].strFile) > 0) {

                // 设置对象的纹理映射标志
                pObject->bHasTexture = true;
            }
            break;
        }
        else
        {
            // 如果该对象没有材质，则设置ID为-1
            pObject->materialID = -1;
        }
    }

    pPreviousChunk->bytesRead += fread(buffer, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);
}

//  下面的这些函数主要用来计算顶点的法向量，顶点的法向量主要用来计算光照
// 下面的宏定义计算一个矢量的长度
#define Mag(Normal) (sqrt(Normal.x*Normal.x + Normal.y*Normal.y + Normal.z*Normal.z))

// 下面的函数求两点决定的矢量
CVector3 Vector(CVector3 vPoint1, CVector3 vPoint2)
{
    CVector3 vVector;

    vVector.x = vPoint1.x - vPoint2.x;
    vVector.y = vPoint1.y - vPoint2.y;
    vVector.z = vPoint1.z - vPoint2.z;

    return vVector;
}

// 下面的函数两个矢量相加
CVector3 AddVector(CVector3 vVector1, CVector3 vVector2)
{
    CVector3 vResult;

    vResult.x = vVector2.x + vVector1.x;
    vResult.y = vVector2.y + vVector1.y;
    vResult.z = vVector2.z + vVector1.z;

    return vResult;
}

// 下面的函数处理矢量的缩放
CVector3 DivideVectorByScaler(CVector3 vVector1, float Scaler)
{
    CVector3 vResult;

    vResult.x = vVector1.x / Scaler;
    vResult.y = vVector1.y / Scaler;
    vResult.z = vVector1.z / Scaler;

    return vResult;
}

// 下面的函数返回两个矢量的叉积
CVector3 Cross(CVector3 vVector1, CVector3 vVector2)
{
    CVector3 vCross;

    vCross.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y));

    vCross.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z));

    vCross.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x));

    return vCross;
}

// 下面的函数规范化矢量
CVector3 Normalize(CVector3 vNormal)
{
    double Magnitude;

    Magnitude = Mag(vNormal);                    // 获得矢量的长度

    vNormal.x /= (float)Magnitude;
    vNormal.y /= (float)Magnitude;
    vNormal.z /= (float)Magnitude;

    return vNormal;
}

//  下面的函数用于计算对象的法向量
void CLoad3DS::ComputeNormals(t3DModel *pModel)
{
    CVector3 vVector1, vVector2, vNormal, vPoly[3];

    // 如果模型中没有对象，则返回
    if(pModel->numOfObjects <= 0)
        return;

    // 遍历模型中所有的对象
    for(int index = 0; index < pModel->numOfObjects; index++)
    {
        // 获得当前的对象
        t3DObject *pObject = &(pModel->pObject[index]);

        // 分配需要的存储空间
        CVector3 *pNormals        = new CVector3 [pObject->numOfFaces];
        CVector3 *pTempNormals    = new CVector3 [pObject->numOfFaces];
        pObject->pNormals        = new CVector3 [pObject->numOfVerts];

        // 遍历对象的所有面
        for(int i=0; i < pObject->numOfFaces; i++)
        {
            vPoly[0] = pObject->pVerts[pObject->pFaces[i].vertIndex[0]];
            vPoly[1] = pObject->pVerts[pObject->pFaces[i].vertIndex[1]];
            vPoly[2] = pObject->pVerts[pObject->pFaces[i].vertIndex[2]];

            // 计算面的法向量

            vVector1 = Vector(vPoly[0], vPoly[2]);        // 获得多边形的矢量
            vVector2 = Vector(vPoly[2], vPoly[1]);        // 获得多边形的第二个矢量

            vNormal  = Cross(vVector1, vVector2);        // 获得两个矢量的叉积
            pTempNormals[i] = vNormal;                    // 保存非规范化法向量
            vNormal  = Normalize(vNormal);                // 规范化获得的叉积

            pNormals[i] = vNormal;                        // 将法向量添加到法向量列表中
        }

        //  下面求顶点法向量
        CVector3 vSum = {0.0, 0.0, 0.0};
        CVector3 vZero = vSum;
        int shared=0;
        // 遍历所有的顶点
        for (i = 0; i < pObject->numOfVerts; i++)
        {
            for (int j = 0; j < pObject->numOfFaces; j++)    // 遍历所有的三角形面
            {                                                // 判断该点是否与其它的面共享
                if (pObject->pFaces[j].vertIndex[0] == i ||
                    pObject->pFaces[j].vertIndex[1] == i ||
                    pObject->pFaces[j].vertIndex[2] == i)
                {
                    vSum = AddVector(vSum, pTempNormals[j]);
                    shared++;
                }
            }

            pObject->pNormals[i] = DivideVectorByScaler(vSum, float(-shared));

            // 规范化最后的顶点法向
            pObject->pNormals[i] = Normalize(pObject->pNormals[i]);

            vSum = vZero;
            shared = 0;
        }

        // 释放存储空间，开始下一个对象
        delete [] pTempNormals;
        delete [] pNormals;
    }
}

/*
值得注意的是OpenGL的坐标系和3DS Max的坐标系是不同的，3D Studio Max中的模型的Z轴是指向上的，
而OpenGL中模型的Z轴是垂直屏幕指向用户的，因此需要将顶点的坐标的y和z翻转过来。
什么是块？
块ID是标识该块中数据类型的独一无二的代码，同时也标识是否存在子块。它占用了两个字节。
块的长度表示的是紧跟在该块后续的数据的长度。它占用了四个字节。

*/

以下是Init.cpp:
#include "main.h"

//  从文件中创建纹理
void CreateTexture(UINT textureArray[], LPSTR strFileName, int textureID)
{
    AUX_RGBImageRec *pBitmap = NULL;

    if(!strFileName)                                    // 如果无此文件，则直接返回
        return;

    pBitmap = auxDIBImageLoad(strFileName);                // 装入位图，并保存数据

    if(pBitmap == NULL)                                    // 如果装入位图失败，则退出
        exit(0);

    // 生成纹理
    glGenTextures(1, &textureArray[textureID]);

    // 设置像素对齐格式
    glPixelStorei (GL_UNPACK_ALIGNMENT, 1);

    glBindTexture(GL_TEXTURE_2D, textureArray[textureID]);

    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pBitmap->sizeX, pBitmap->sizeY, GL_RGB, GL_UNSIGNED_BYTE, pBitmap->data);

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);

    if (pBitmap)                                        // 释放位图占用的资源
    {
        if (pBitmap->data)
        {
            free(pBitmap->data);
        }

        free(pBitmap);
    }
}

void ChangeToFullScreen()
{
    DEVMODE dmSettings;

    memset(&dmSettings,0,sizeof(dmSettings));

    if(!EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&dmSettings))
    {
        MessageBox(NULL, "Could Not Enum Display Settings", "Error", MB_OK);
        return;
    }

    dmSettings.dmPelsWidth    = SCREEN_WIDTH;
    dmSettings.dmPelsHeight    = SCREEN_HEIGHT;

    int result = ChangeDisplaySettings(&dmSettings,CDS_FULLSCREEN);

    if(result != DISP_CHANGE_SUCCESSFUL)
    {

        MessageBox(NULL, "Display Mode Not Compatible", "Error", MB_OK);
        PostQuitMessage(0);
    }
}

HWND CreateMyWindow(LPSTR strWindowName, int width, int height, DWORD dwStyle, bool bFullScreen, HINSTANCE hInstance)
{
    HWND hWnd;
    WNDCLASS wndclass;

    memset(&wndclass, 0, sizeof(WNDCLASS));
    wndclass.style = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc = WinProc;
    wndclass.hInstance = hInstance;
    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);
    wndclass.lpszClassName = "GameTutorials";

    RegisterClass(&wndclass);

    if(bFullScreen && !dwStyle)
    {
        dwStyle = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
        ChangeToFullScreen();
        ShowCursor(FALSE);
    }
    else if(!dwStyle)
        dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;

    g_hInstance = hInstance;

    RECT rWindow;
    rWindow.left    = 0;
    rWindow.right    = width;
    rWindow.top        = 0;
    rWindow.bottom    = height;
    AdjustWindowRect( &rWindow, dwStyle, false);


    hWnd = CreateWindow("GameTutorials", strWindowName, dwStyle, 0, 0,
                        rWindow.right  - rWindow.left, rWindow.bottom - rWindow.top,
                        NULL, NULL, hInstance, NULL);

    if(!hWnd) return NULL;

    ShowWindow(hWnd, SW_SHOWNORMAL);
    UpdateWindow(hWnd);

    SetFocus(hWnd);

    return hWnd;
}

bool bSetupPixelFormat(HDC hdc)
{
    PIXELFORMATDESCRIPTOR pfd;
    int pixelformat;

    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
    pfd.nVersion = 1;

    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.dwLayerMask = PFD_MAIN_PLANE;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = SCREEN_DEPTH;
    pfd.cDepthBits = SCREEN_DEPTH;
    pfd.cAccumBits = 0;
    pfd.cStencilBits = 0;

    if ( (pixelformat = ChoosePixelFormat(hdc, &pfd)) == FALSE )
    {
        MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
        return FALSE;
    }

    if (SetPixelFormat(hdc, pixelformat, &pfd) == FALSE)
    {
        MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
        return FALSE;
    }

    return TRUE;
}

void SizeOpenGLScreen(int width, int height)
{
    if (height==0)
    {
        height=1;
    }

    glViewport(0,0,width,height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f,(GLfloat)width/(GLfloat)height, .5f ,150.0f);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void InitializeOpenGL(int width, int height)
{
    g_hDC = GetDC(g_hWnd);

    if (!bSetupPixelFormat(g_hDC))
        PostQuitMessage (0);

    g_hRC = wglCreateContext(g_hDC);
    wglMakeCurrent(g_hDC, g_hRC);

    glEnable(GL_TEXTURE_2D);
    glEnable(GL_DEPTH_TEST);

    SizeOpenGLScreen(width, height);
}

void DeInit()
{
    if (g_hRC)
    {
        wglMakeCurrent(NULL, NULL);
        wglDeleteContext(g_hRC);
    }

    if (g_hDC)
        ReleaseDC(g_hWnd, g_hDC);

    if(g_bFullScreen)
    {
        ChangeDisplaySettings(NULL,0);
        ShowCursor(TRUE);
    }

    UnregisterClass("GameTutorials", g_hInstance);

    PostQuitMessage (0);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hprev, PSTR cmdline, int ishow)
{
    HWND hWnd;

    // 判断用户是否需要全屏显示
    if(MessageBox(NULL, "Click Yes to go to full screen (Recommended)", "Options", MB_YESNO | MB_ICONQUESTION) == IDNO)
        g_bFullScreen = false;

    hWnd = CreateMyWindow(" 3DS Loader", SCREEN_WIDTH, SCREEN_HEIGHT, 0, g_bFullScreen, hInstance);

    if(hWnd == NULL) return true;

    // 初始化OpenGL
    Init(hWnd);
    return MainLoop();
}

以下是main.cpp:

#include "main.h"
#include "3ds.h"

bool  g_bFullScreen = true;
HWND  g_hWnd;
RECT  g_rRect;
HDC   g_hDC;
HGLRC g_hRC;
HINSTANCE g_hInstance;

#define FILE_NAME  "trans.3ds"

UINT g_Texture[MAX_TEXTURES] = {0};

CLoad3DS g_Load3ds;
t3DModel g_3DModel;

int   g_ViewMode      = GL_TRIANGLES;
bool  g_bLighting     = true;
float g_RotateX          = 0.0f;
float g_RotationSpeed = 0.0f;

void Init(HWND hWnd)
{
    g_hWnd = hWnd;
    GetClientRect(g_hWnd, &g_rRect);
    InitializeOpenGL(g_rRect.right, g_rRect.bottom);

    g_Load3ds.Import3DS(&g_3DModel, FILE_NAME);            // 将3ds文件装入到模型结构体中

    // 遍历所有的材质
    for(int i = 0; i < g_3DModel.numOfMaterials; i++)
    {
        // 判断是否是一个文件名
        if(strlen(g_3DModel.pMaterials[i].strFile) > 0)
        {
            //  使用纹理文件名称来装入位图
            CreateTexture(g_Texture, g_3DModel.pMaterials[i].strFile, i);
        }

        // 设置材质的纹理ID
        g_3DModel.pMaterials[i].texureId = i;
    }

    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);

}

WPARAM MainLoop()
{
    MSG msg;

    while(1)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if(msg.message == WM_QUIT)
                break;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            RenderScene();
        }
    }

    // 遍历场景中所有的对象
    for(int i = 0; i < g_3DModel.numOfObjects; i++)
    {
        // 删除所有的变量
        delete [] g_3DModel.pObject[i].pFaces;
        delete [] g_3DModel.pObject[i].pNormals;
        delete [] g_3DModel.pObject[i].pVerts;
        delete [] g_3DModel.pObject[i].pTexVerts;
    }

    DeInit();
    return(msg.wParam);
}

void RenderScene()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    gluLookAt(        0, 0.5f, 100,        0, 5.0f, -20,            0, 1, 0);

    glRotatef(g_RotateX, 0, 1.0f, 0);
    g_RotateX += g_RotationSpeed;

    // 遍历模型中所有的对象
    for(int i = 0; i < g_3DModel.numOfObjects; i++)
    {
        // 如果对象的大小小于0，则退出
        if(g_3DModel.pObject.size() <= 0) break;

        // 获得当前显示的对象
        t3DObject *pObject = &g_3DModel.pObject[i];

        // 判断该对象是否有纹理映射
        if(pObject->bHasTexture) {

            // 打开纹理映射
            glEnable(GL_TEXTURE_2D);
            glColor3ub(255, 255, 255);
            glBindTexture(GL_TEXTURE_2D, g_Texture[pObject->materialID]);
        } else {

            // 关闭纹理映射
            glDisable(GL_TEXTURE_2D);
            glColor3ub(255, 255, 255);
        }
        // 开始以g_ViewMode模式绘制
        glBegin(g_ViewMode);
            // 遍历所有的面
            for(int j = 0; j < pObject->numOfFaces; j++)
            {
                // 遍历三角形的所有点
                for(int whichVertex = 0; whichVertex < 3; whichVertex++)
                {
                    // 获得面对每个点的索引
                    int index = pObject->pFaces[j].vertIndex[whichVertex];

                    // 给出法向量
                    glNormal3f(pObject->pNormals[ index ].x, pObject->pNormals[ index ].y, pObject->pNormals[ index ].z);

                    // 如果对象具有纹理
                    if(pObject->bHasTexture) {

                        // 确定是否有UVW纹理坐标
                        if(pObject->pTexVerts) {
                            glTexCoord2f(pObject->pTexVerts[ index ].x, pObject->pTexVerts[ index ].y);
                        }
                    } else {

                        if(g_3DModel.pMaterials.size() && pObject->materialID >= 0)
                        {
                            BYTE *pColor = g_3DModel.pMaterials[pObject->materialID].color;
                            glColor3ub(pColor[0], pColor[1], pColor[2]);
                        }
                    }
                    glVertex3f(pObject->pVerts[ index ].x, pObject->pVerts[ index ].y, pObject->pVerts[ index ].z);
                }
            }

        glEnd();                                // 绘制结束
    }

    SwapBuffers(g_hDC);                                    // 交换缓冲区
}

LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LONG    lRet = 0;
    PAINTSTRUCT    ps;

    switch (uMsg)
    {
    case WM_SIZE:
        if(!g_bFullScreen)
        {
            SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));
            GetClientRect(hWnd, &g_rRect);
        }
        break;

    case WM_PAINT:
        BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
        break;

    case WM_LBUTTONDOWN:                                // 按下鼠标左键，改变绘制模式

        if(g_ViewMode == GL_TRIANGLES) {
            g_ViewMode = GL_LINE_STRIP;
        } else {
            g_ViewMode = GL_TRIANGLES;
        }
        break;

    case WM_RBUTTONDOWN:                                // 按下鼠标右键，改变光照模式

        g_bLighting = !g_bLighting;

        if(g_bLighting) {
            glEnable(GL_LIGHTING);
        } else {
            glDisable(GL_LIGHTING);
        }
        break;

    case WM_KEYDOWN:                                    // 键盘响应

        switch(wParam) {
            case VK_ESCAPE:                                // 按下ESC键
                PostQuitMessage(0);
                break;

            case VK_LEFT:                                // 按下向左键
                g_RotationSpeed -= 0.05f;
                break;

            case VK_RIGHT:                                // 按下向右键
                g_RotationSpeed += 0.05f;
                break;
        }
        break;

    case WM_CLOSE:
        PostQuitMessage(0);
        break;

    default:
        lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
        break;
    }

    return lRet;
}

Motorola Backflip/Enzo 多图曝光

liuzaoxingseu@gmail.com(lzx) — Fri,18 Dec 2009 16:18:01 +0800

Motorola Backflip/Enzo 应该是首款翻盖带QWERTY全键盘手机吧，设计非常另类。首先，关闭翻盖后键盘依然是裸露在外面的，翻开屏幕，屏幕后侧有一个类似于笔记本触摸板的东西，不过对其是否实用表示怀疑。另外手机的摄像头和闪光灯都在键盘闪，这样是否意味着翻开键盘后，是否能用摄像头进行视频通话呢，拍照摄像视频聊天都用同一个摄像头，创意真不错，不过打字的时候会不会挡住呢。
配置:
高通 MSM7201A 528 MHz CPU
512 MB ROM
256 MB RAM
3.1 寸分辨率为 320 x 480 (HVGA)的电容触摸屏
5 百万像素带闪光灯摄像头
WiFi / Bluetooth 2.0 / GPS
搭载Android 1.5 Motoblur操作系统
频率为GSM 850/900/1800/1900；W-CDMA 850/900/1700/1900/2100
反向翻转键盘
定向触摸板(屏幕背面)

基于Android 2.1的Sense界面已被移植上G1

liuzaoxingseu@gmail.com(lzx) — Wed,02 Dec 2009 21:00:47 +0800

经过国外Hack Drizzy 和国人Xdan等人的努力，全中文界面基于Android 2.1的Sense UI界面已经成功装入最古老的Android手机-G1里，并且良好运行。这个么说来官方装有HTC Sense UI的手机，包括原版的HTC Hero、CDMA版的Spirit Hero、以及HTC Eris都将跳过Android 1.6和Android 2.0 直接升级至Android 2.1。

关于Android 2.1 Sense UI的内容有：
1.增加电源widget好看多了(这个在Android1.6里就有了，除了HTC Tattoo之外没有在其他使用Sense UI的手机上使用)
2.可以同时绑定多个Google账号
3.更快的运行和加载速度
4.设置里增加Personalize功能
5.无线控件里有了VPN设置，之前1.5的Sense UI里没有的
6.增加Mobile network sharing
7.声音和显示选择增加的重力感应校准
8.Location和Privacy
9.Connect to PC设置
10.文字到语音转换
11.新的拨号界面，按键更大，更易于操作
12.更多桌面插件
13.新的Google地图
14.新的浏览器
15.全局搜索
15.全新的Market
……
更多截图：

组织一次苹果、Thinkpad高档笔记本团购，详细见内，欢迎联系，一个月内有效

liuzaoxingseu@gmail.com(lzx) — Mon,12 Oct 2009 13:21:43 +0800

全部为港行和新加坡行货，质量均优于欧水和大陆行，有些高配的大陆行货没有。

质量尽可放心，所有配件均是原厂出厂配置，品质绝对保证。苹果系列可以享受全国联保，Thinkpad整机保修一年。正规发票没有问题，开正规含税发票加税钱400元，开不开发票不影响保修。提供基本的软件支持，免费安装Windows XP，OEM版Windows Vista旗舰版，OEM版Windows 7旗舰版。

十一后笔记本出货量骤减，很多型号都没有货，这批苹果和Thinkpad十一后刚入关，渠道商分销，团购价格如下所示，5台以上我就去拿货，有意咨询请联系QQ301086252，参与讨论请加入QQ群4596582。

PS：请不要拿所谓的XXX报价来说，在南京，这个价格品质保证，利润更是极低，非heyong、xuze之流的卖场价格。

详细配置EXECL文件：http://liuzaoxing.cn/price.xls
    机型    价格    CPU    内存    硬盘    LCD    显卡    通讯/端口    光软    系统
    X200 DU2(推荐）    6999    P8700 2.53G    2G    250G 5400    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/摄像头/4芯/新加坡    选购    DOS
X200 PN6    7099    P8700 2.53G    2G    250G 5400    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/摄像头/6芯/香港    选购    DOS
X200 CV3/CTO    7299    P8700 2.53G    2G    320G 5400    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/摄像头/讯盘/6芯/新加坡    选购    DOS
X200 CTO    7350    P8700 2.53G    2G    320G 7200    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/摄像头/6芯/新加坡    选购    DOS
X200 PE5(推荐）    7450    P8700 2.53G    4G    320G 7200    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/摄像头/6芯/香港    选购    DOS
X200 BJ3/CTO    8200    T9550 2.66G    2G    320G 7200    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/摄像头/讯盘/6芯/新加坡    选购    DOS
X200S RN3    8399    SL9400 1.86G    4G    320G 7200    12.1WXGA(1280X800)    intel X4500    802.11n/蓝牙/指纹/6芯/香港    选购    DOS
X200T CTO    10999    SL9600 2.13G    2G    320G 5400    12.1WXGA(1280X800)    intel X4500    802.11g/蓝牙/指纹/摄像头/笔触/8芯/香港    选购    DOS
X200T CTO    12400    SL9600 2.13G    2G    320G 5400    12.1LED(1280X800)    intel X4500    802.11g/蓝牙/指纹/摄像头/8芯/手触/香港    选购    DOS
X301  RS9    12200    SU9600 1.6G    2G    250G 5400    13.3LED(1440X900)    intel X4500    802.11n/蓝牙/指纹/摄像头/讯盘2G/3芯/香港    DVDRW    DOS
    T400 R29(推荐）    6950    P8700 2.53G    2G    250G 5400    14.1WXGA(1280X800)    256M ATI HD3470    802.11n/蓝牙/指纹/摄像头/6芯/香港    COMBO    DOS
    T400 R15（推荐）7600    7750    P8700 2.53G     2G    250G 5400    14.1LED(1440X900)    256M ATI HD3470    802.11n/蓝牙/指纹/摄像头/6芯/香港    DVDRW    DOS
    T400 AJ1(推荐）    8099    P8700 2.53G    2G    320G 7200    14.1LED(1440X900)    256M ATI HD3470    802.11n/蓝牙/指纹/摄像头/迅盘/6芯/新加坡    DVDRW    DOS
    T400 PV7    8399    P8800 2.66G    2G    320G 5400    14.1LED(1440X900)    256M ATI HD3470    802.11n/蓝牙/指纹/摄像头/6芯/香港    DVDRW    DOS
    T400 PV8    7700    P8800 2.66G    2G    320G 5400    14.1WXGA(1440X900)    256M ATI HD3470    802.11n/蓝牙/指纹/摄像头/6芯/香港    DVDRW    DOS
    T400 R38    9699    P9600 2.66G    2G    500G 5400    14.1LED(1440X900)    256M ATI HD3470    802.11ag/蓝牙/指纹/摄像头/迅盘/9芯/香港    DVDRW    DOS
T400 PU2    9750    P9700 2.8G    4G    320G 7200    14.1LED(1440X900)    256M ATI HD3470    802.11n/蓝牙/指纹/摄像头/6芯/香港    DVDRW    DOS
T400S RW1    10300    SP9400 2.4G    4G    250G 5400    14.1LED(1440X900)    intel X4500    802.11n/蓝牙/指纹/摄像头/6芯/香港    DVDRW    DOS
T400S RZ6    10400    SP9400 2.4G    2G    250G 5400    14.1LED(1440X900)    intel X4500    802.11ag/蓝牙/指纹/摄像头/迅盘/6芯/香港    DVDRW    DOS
T400S RY6    12200    SP9400 2.4G    2G    128G SSD    14.1LED(1440X900)    intel X4500    802.11ag/蓝牙/指纹/摄像头/迅盘/6芯/香港    DVDRW    DOS
T500 CTO    8750    P8700 2.53G    2G    320G 5400    15.4WSXGA+(1680X1050)    256M ATI HD3650    802.11n/蓝牙/指纹/摄像头/迅盘/6芯/香港    DVDRW    DOS
W500 CTO    9950    T9600 2.8G    4G    320G 5400    15.4WSXGA+(1680X1050)    512M ATI V5700    802.11n/蓝牙/指纹/摄像头/6芯/香港    DVDRW    DOS
W500 RN4    10600    T9600 2.8G    4G    320G 7200    15.4WSXGA+(1680X1050)    512M ATI V5700    802.11n/蓝牙/指纹/摄像头/9芯/香港    DVDRW    DOS
W700 RZ4    18000    T9600 2.8G    4G    320G*2 5400    17WUXGA(1920X1200)    1G Nvidia Fx3700m    802.11n/蓝牙/指纹/摄像头/迅盘/9芯/香港    Bluray    Vista
苹果
    MC240(纯白）    7398    P7450 2.13G    2G    160G 5400    13.3WXGA(1280X800)    NVIDIA GeForce    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    DVDRW    Mac
MC233（Air）    10950    SL9400 1.86G    2G    120G 4200    13.3LED(1280X800)    NVIDIA GeForce    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    光驱另选    Mac
MC234（Air）    13100    SL9600 2.13G    2G    128G SSD    13.3LED(1280X800)    NVIDIA GeForce    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    光驱另选    Mac
MB990    8700    P7550 2.26G    2G    160G 5400    13.3LED(1280X800)    NVIDIA GeForce    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    DVDRW    Mac
MC118    12200    P8700 2.53G    4G    250G 5400    15.4LED(1440X900)    256M NVS 9400M    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    DVDRW    Mac
MB991    10700    P8700 2.4G    4G    250G 5400    13.3LED(1280X800)    256M NVS 9400M    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    DVDRW    Mac
MB985    15800    T9600 2.8G    4G    500G 5400    15.4LED(1440X900)    512M NVS 9600MGT    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    DVDRW    Mac
MB985    13999    B8800 2.66G    4G    320G 5400    15.4LED(1440X900)    512M NVS 9600MGT    Magsafe电源端口，两个USB2.0端口，Mini DVI，isight摄像头    DVDRW    Mac

“Courier”系列超酷平板笔记本电脑原型

liuzaoxingseu@gmail.com(lzx) — Wed,23 Sep 2009 22:47:54 +0800

业内最近风传微软将要推出自己的平板产品和苹果做一次正面对抗,微软的平板和MID意义不同,它采用两个7英寸多功能触摸显示器拼合而成,这一款产品更像是一本电子书.显示面积很大,支持手写笔,背面也有300万像素摄像头,支持感应无线充电,微软表示目前这种设备仅仅是一种原型,并未投产,发布日期,技术细节也一概不知.

让人恐惧的聊天工具和邮件系统监控

liuzaoxingseu@gmail.com(lzx) — Thu,10 Sep 2009 10:44:35 +0800

       最近我看到了两篇老文章，里面写着关于QQ、MSN、SKYPE和QQ邮箱的监控过滤能力，看得我真是心惊肉跳啊，像我这种翻墙翻惯了，经常使用QQ、MSN传一些新闻的人，真是感到GFW和“绿坝”之类的东西简直无处不在。这两篇文章的地址是：http://www.kenengba.com/post/533.html   http://www.kenengba.com/post/781.html

      这样真的不是真正的好的做法，左一个限制，右一个河蟹，这样只会适得其反，借以掩饰什么？个人觉得真正的和谐可不是这样出来的，这种做法就好似掩耳盗铃，以为一个GFW就真正封锁互联网了吗？这样只会让网民对自己获取的信息产生极大的怀疑，对墙外的宣传更加好奇，拼命地要翻出墙去，对墙外的信息深信不疑，大受鼓动..........
      qq也是那种有图片过滤的功能，我用QQ截图随便接了一个有死人的图片，发送给别人显示的就是XX，但是换了一张正常图片又能显示。不知道哪一天，虽然Gmail很好，https很好，不过，如果到哪天所有XX分子都用Gmail，我相信，和Google相关的东西都得被“您的链接已重置”，ZF在这个方面上是绝对肯投钱的。。。

用MSF开发流程开发，微软解决方案

liuzaoxingseu@gmail.com(lzx) — Thu,03 Sep 2009 15:43:05 +0800

微软解决方案框架过程--构思阶段 Microsoft Solutions Framework Process - Envisioning Phase

构思过程Envisioning Process

    * 组建团队 Setting up the team
    * 定义项目结构 Defining the project structure
    * 定义商业目标 Defining the business goals
    * 评估时局 Assessing the current situation
    * 创建一个远景声明、定义项目的范围 Creating a vision statement and defining the scope of the project
    * 备注：共享的而且可以清晰描述的远景是项目的成功的基本要素。NOTE: A shared and clearly articulated vision is fundamental to the success of the project.
    * 定义需求和用户概况 Defining requirements and user profiles
    * 开发一个解决方案体系 Developing a solution concept
    * 评估风险 Assessing risk
    * 关闭构思阶段 Closing the envisioning phase

里程碑 Milestones

    * 核心团队组织 Core team organized
    * 远景与范围的创建 Vision/scope created

交付物 Deliverables

    * 远景与范围定义 Vision/scope
    * 问题陈述和商业目标 Problem statements and business objectives
    * 现有的过程的重审 A review of existing processes
    * 主要用户需求 A broad definition of user requirements
    * 用户概况标志项目受益人 User profiles identifying who will benefit from the solution
    * 一个远景声明和范围定义 A vision statement and scope definition
    * 解决方案内容描述项目的计划步骤 The solution concept outlining the approach the team will take to plan the project
    * 解决设计策略 Solution design strategies
    * 项目结构 Project structure
    * 所有MSF团队成员角色定义及相应团队成员列表 A description of all MSF team roles and a list of corresponding team members
    * 项目结构文档和团队遵循的过程标准 A project structure and process standards for the team to follow
    * 风险评估 Risk assessment
    * 一种初步的风险评估  A preliminary risk assessment
    * 主要风险列表 A list of the primary identified risks
    * 将减轻或者消除风险的对策做入项目计划 Plans for mitigating or eliminating the identified risks

微软解决方案框架过程--计划制订阶段 Microsoft Solutions Framework Process - Planning Phase

设计阶段 Design Stages

    * 概要设计 Conceptual design
    * 逻辑设计 Logical design
    * 物理设计 Physical design

设计过程 Design Process

    * 设计解决方案和架构 Developing the solution design and architecture
    * 创建功能规格说明书 Creating the functional specification
    * 制订项目计划 Developing project plans
    * 创建项目时间表 Creating project schedules
    * 创建开发，测试，和运行环境 Creating the development, testing, and staging environments
    * 关闭计划制订阶段 Closing the planning phase

里程碑 Milestones

    * 完成技术验证 Technology validation complete
    * 完成功能规格说明书 Functional specification complete
    * 完成主项目计划 Master plan complete
    * 完成主项目时间表 Master project schedule complete
    * 开发和测试环境配置成功 Development and test environments configured

交付物 Deliverables

    * 功能规格说明书 Functional specification
    * 风险管理计划 Risk management plan
    * 主项目计划和主项目时间表 Master project plan and master project schedule

微软解决方案框架过程--开发阶段 Microsoft Solutions Framework Process - Developing Phase

开发过程 Development Process

    * 开始开发周期 Starting the development cycle
    * 创建程序原型 Creating a prototype application
    * 开发解决方案组件 Developing the solution components
    * 构建解决方案 Building the solution
    * 关闭开发阶段 Closing the developing phase

里程碑 Milestones

    * 完成用于概念验证的程序 Proof-of-concept application complete
    * 内部构建成功 Internal builds complete

交付物 Deliverables

    * 源代码和可执行文件 Source code and executable files
    * 用于部署的安装脚本和配置 Installation scripts and configuration settings for deployment
    * 最终版功能规格说明书 Finalized functional specification
    * 性能支持 Performance support elements
    * 测试规格说明书和测试用例 Test specifications and test cases

微软解决方案框架过程--稳定阶段 Microsoft Solutions Framework Process - Stabilizing Phase

稳定性过程 Stabilization Process

    * 测试解决方案 Testing the solution
          o 组件测试 Component testing
          o 数据库测试 Database testing
          o 基础架构测试 Infrastructure testing
          o 安全测试 Security testing
          o 用户接受和可用性测试 User acceptance and usability testing
          o 压力，容量，和性能试验 Stress, capacity, and performance testing
          o 回归测试 Regression testing
          o 记录BUG的数量 Recording the number of bugs
    * 实施飞行员 Conducting the pilot

里程碑 Milestones

    * BUG收敛 Bug convergence
    * 零错误反弹 Zero-bug release
    * 发布候选版本 Release candidates
    * 黄金版发布 Golden release

交付物 Deliverables

    * 最终版本发布 Final release
    * 发布的说明 Release notes
    * 性能支持要素Performance support elements
    * 测试结果和测试工具 Test results and testing tools
    * 源代码和可执行文件 Source code and executable files
    * 项目文件 Project documents
    * 里程碑评审 Milestone review

微软解决方案框架过程--部署阶段 Microsoft Solutions Framework Process - Deploying Phase

部署过程 Deployment Process

    * 完成部署和运营过程 Completion of deployment and operations procedures
    * 部署和稳定 Deployment and stabilization
    * 项目评审 Project review

里程碑 Milestones

    * 核心组件的部署 Core components deployed
    * 站点部署完成 Site deployments complete
    * 稳定的部署 Deployment stable
    * 完全的部署 Deployment complete

交付物 Deliverables

    * 操作和支持信息 Operation and support information
          o 程序和过程 Procedures and processes
          o 知识库，报告，和日志 Knowledge base, reports, and logbooks
    * 包含项目期间部署的所有版本的文档和代码的文档库 Documentation repository for all versions of documents and code deployed during the project
    * 培训计划 A training plan
    * 项目总结报告 Project completion report
          o 所有项目文件的最终版本 Final versions of all project documents
          o 客户满意数据 Customer satisfaction data
          o 定义接下来的步骤 Definition of next steps

Mac OS X Leopard 高清安装视频教程

liuzaoxingseu@gmail.com(lzx) — Thu,03 Sep 2009 15:41:08 +0800

Flash动画

在线播放