C++ CIwMaterial::SetAlphaMode方法代码示例

void DrawRect(int x, int y, int width, int height, uint8 r, uint8 g, uint8 b)
{
    int right = x + width;
    int bottom = y + height;
    if (x < 0)
        x = 0;
    if (y < 0)
        y = 0;
    if (right > (int32)s3eSurfaceGetInt(S3E_SURFACE_WIDTH))
        right = s3eSurfaceGetInt(S3E_SURFACE_WIDTH);
    if (bottom > (int32)s3eSurfaceGetInt(S3E_SURFACE_HEIGHT))
        bottom = s3eSurfaceGetInt(S3E_SURFACE_HEIGHT);

    // Draw the text
    IwGxSetScreenSpaceSlot(0);

    CIwMaterial *fadeMat = IW_GX_ALLOC_MATERIAL();
    fadeMat->SetAlphaMode(CIwMaterial::NONE);
    fadeMat->SetShadeMode(CIwMaterial::SHADE_FLAT);
    IwGxSetMaterial(fadeMat);

    CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
    for (int i = 0; i < 4; i++)
        cols[i].Set(r, g, b);

    CIwSVec2 xy(x, y);
    CIwSVec2 wh(width, height);
    IwGxDrawRectScreenSpace(&xy, &wh, cols);
}

void SimpleMenu::smDrawSimpleMenuScrollbar(const CIwSVec2 & pos,const CIwSVec2 & size,const CIwSVec2 & spos,const CIwSVec2 & ssize)
{
	CIwMaterial* m = IW_GX_ALLOC_MATERIAL();
	CIwColour c;
	c.Set(0xFFFFFFFF);
	m->SetColAmbient(c);
	m->SetAlphaMode(CIwMaterial::ALPHA_BLEND);
	IwGxSetMaterial(m);
	CIwSVec2* points = IW_GX_ALLOC(CIwSVec2,8);
	CIwColour* cols = IW_GX_ALLOC(CIwColour,8);
	points[0] = pos+CIwSVec2(0,0);
	points[1] = pos+CIwSVec2(0,size.y);
	points[2] = pos+CIwSVec2(size.x,size.y);
	points[3] = pos+CIwSVec2(size.x,0);
	c.Set(0x20,0x20,0x20,0x20);
	cols[0] = cols[1] = cols[2] = cols[3] = c;
	points[4] = spos+CIwSVec2(0,0);
	points[5] = spos+CIwSVec2(0,ssize.y);
	points[6] = spos+CIwSVec2(ssize.x,ssize.y);
	points[7] = spos+CIwSVec2(ssize.x,0);
	c.Set(0xFF,0xFF,0xFF,0x80);
	cols[4] = cols[5] = cols[6] = cols[7] = c;
	IwGxSetVertStreamScreenSpace(points,8);
	IwGxSetColStream(cols);
	IwGxDrawPrims(IW_GX_QUAD_LIST,0,8);
}

// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
void ImGui_Marmalade_RenderDrawLists(ImDrawData* draw_data)
{
    // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
    ImGuiIO& io = ImGui::GetIO();
    draw_data->ScaleClipRects(io.DisplayFramebufferScale);

    // Render command lists
    for(int n = 0; n < draw_data->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list = draw_data->CmdLists[n];
        const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front();
        const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front();
        int nVert = cmd_list->VtxBuffer.size();
        CIwFVec2* pVertStream = IW_GX_ALLOC(CIwFVec2, nVert);
        CIwFVec2* pUVStream = IW_GX_ALLOC(CIwFVec2, nVert);
        CIwColour* pColStream = IW_GX_ALLOC(CIwColour, nVert);

        for( int i=0; i < nVert; i++ )
        {
            // TODO: optimize multiplication on gpu using vertex shader
            pVertStream[i].x = cmd_list->VtxBuffer[i].pos.x * g_scale.x;
            pVertStream[i].y = cmd_list->VtxBuffer[i].pos.y * g_scale.y;
            pUVStream[i].x = cmd_list->VtxBuffer[i].uv.x;
            pUVStream[i].y = cmd_list->VtxBuffer[i].uv.y;
            pColStream[i] = cmd_list->VtxBuffer[i].col;
        }

        IwGxSetVertStreamScreenSpace(pVertStream, nVert);
        IwGxSetUVStream(pUVStream);
        IwGxSetColStream(pColStream, nVert);
        IwGxSetNormStream(0);

        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
        {
            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
            if (pcmd->UserCallback)
            {
                pcmd->UserCallback(cmd_list,pcmd);
            }
            else
            {
                CIwMaterial* pCurrentMaterial = IW_GX_ALLOC_MATERIAL();
                pCurrentMaterial->SetShadeMode(CIwMaterial::SHADE_FLAT);
                pCurrentMaterial->SetCullMode(CIwMaterial::CULL_NONE);
                pCurrentMaterial->SetFiltering(false);
                pCurrentMaterial->SetAlphaMode(CIwMaterial::ALPHA_BLEND);
                pCurrentMaterial->SetDepthWriteMode(CIwMaterial::DEPTH_WRITE_NORMAL);
                pCurrentMaterial->SetAlphaTestMode(CIwMaterial::ALPHATEST_DISABLED);
                pCurrentMaterial->SetTexture((CIwTexture*)pcmd->TextureId);
                IwGxSetMaterial(pCurrentMaterial);
                IwGxDrawPrims(IW_GX_TRI_LIST, (uint16*)idx_buffer, pcmd->ElemCount);
            }
            idx_buffer += pcmd->ElemCount;
        }
        IwGxFlush();
    }

    // TODO: restore modified state (i.e. mvp matrix)
}

void CzPlatformRender::DrawPrimitives(CzRenderPrim3* prims, CzRenderMaterial* materials, int num_prims, bool single_material)
{
	while (num_prims-- > 0)
	{
		CIwMaterial::AlphaMode am = (CIwMaterial::AlphaMode)materials->AlphaMode;	// TODO Add proper method to map Marmalade Alpha mode to Marmalade
		int vc = prims->VertCount;

		// Set up vertex streams
		if (prims->UVs != NULL)
			IwGxSetUVStream((CIwFVec2*)prims->UVs, 0);
		else
			IwGxSetUVStream(NULL);
		if (prims->ModelSpace)
			IwGxSetVertStreamModelSpace((CIwFVec3*)prims->Verts, vc);
		else
			IwGxSetVertStreamViewSpace((CIwFVec3*)prims->Verts, vc);
		IwGxSetColStream((CIwColour*)prims->Colours);
		IwGxSetNormStream((CIwFVec3*)prims->Normals);

		CzTexture texture = materials->Image->getTexture();
		CIwTexture* mt = static_cast<CIwTexture*>(texture);
		bool filter;
		if (materials->Image->isFilterSet())
			filter = mt->GetFiltering();
		else
			filter = materials->Filter;

		// Only create new render material if something important has changed
		if (texture != CurrentTexture || CurrentAlphaMode != materials->AlphaMode || CurrentFilter != filter || CurrentTexture == NULL || CurrentTiled != materials->Tiled)
		{
			CIwMaterial* mat = IW_GX_ALLOC_MATERIAL();
			mat->SetTexture(mt);
			mat->SetDepthWriteMode(CIwMaterial::DEPTH_WRITE_DISABLED);
			mat->SetClamping(!materials->Tiled);
			mat->SetFiltering(filter);
			mat->SetAlphaMode(am);
			mat->SetCullMode(CIwMaterial::CULL_BACK);
//			mat->SetCullMode(CIwMaterial::CULL_NONE);
			IwGxSetMaterial(mat);
			CurrentTexture = texture;
			CurrentAlphaMode = materials->AlphaMode;
			CurrentTiled = materials->Tiled;
			CurrentFilter = filter;
		}
		else
		{
			RedundantTextureCalls++;
		}
	
		// Render the primitive
		IwGxDrawPrims(CzToIwGxPrimType[prims->Type], prims->Indices, prims->IndicesCount);

		// Move to next primitive
		prims++;
		if (!single_material)
			materials++;
	}
}

static void SoftkeyRender(const char* text, s3eDeviceSoftKeyPosition pos, void(*handler)())
{
    // TODO: Hardocoded font width and height (boo!)
    int width = 7;
    int height = 30;

    width *= strlen(text) * 2;
    int x = 0;
    int y = 0;
    switch (pos)
    {
        case S3E_DEVICE_SOFTKEY_BOTTOM_LEFT:
            y = IwGxGetScreenHeight() - height;
            x = 0;
            break;
        case S3E_DEVICE_SOFTKEY_BOTTOM_RIGHT:
            y = IwGxGetScreenHeight() - height;
            x = IwGxGetScreenWidth() - width;
            break;
        case S3E_DEVICE_SOFTKEY_TOP_RIGHT:
            y = 0;
            x = IwGxGetScreenWidth() - width;
            break;
        case S3E_DEVICE_SOFTKEY_TOP_LEFT:
            x = 0;
            y = 0;
            break;
    }

    CIwMaterial *fadeMat = IW_GX_ALLOC_MATERIAL();
    fadeMat->SetAlphaMode(CIwMaterial::SUB);
    IwGxSetMaterial(fadeMat);

    IwGxPrintString(x + 10, y+10, text, false);

    CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
    memset(cols, 50, sizeof(CIwColour)*4);

    if (s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_PRESSED)
    {
        int pointerx = s3ePointerGetX();
        int pointery = s3ePointerGetY();
        if (pointerx >= x && pointerx <= x+width && pointery >=y && pointery <= y+height)
        {
            memset(cols, 15, sizeof(CIwColour)*4);
            handler();
        }
    }

    // Draw button area
    CIwSVec2 XY(x, y-2), dXY(width, height);
    IwGxDrawRectScreenSpace(&XY, &dXY, cols);
}

void myIwGxDoneStars()
{
    IwGxSetScreenSpaceSlot(3);
    IwGxSetVertStreamScreenSpace( svertices, ssend_vertices );
    CIwMaterial *pMat = IW_GX_ALLOC_MATERIAL();
    pMat->SetAlphaMode( CIwMaterial::ALPHA_ADD );
    pMat->SetTexture( star_texture );
    pMat->SetColAmbient( 0xFF, 0xFF, 0xFF, 0xFF );
    IwGxSetMaterial( pMat );
    IwGxSetUVStream( suvdata );
    IwGxSetColStream( scolors, ssend_vertices );
    IwGxDrawPrims( IW_GX_QUAD_LIST, NULL, ssend_vertices );
    IwGxFlush();
}

void Unit::displayOnScreen(int x, int y){    
    
    CIwMaterial *mat = new CIwMaterial();
	mat->SetTexture((CIwTexture*)game->getSprites()->GetResHashed(getTextureName(), IW_GX_RESTYPE_TEXTURE));
    mat->SetModulateMode(CIwMaterial::MODULATE_NONE);
    mat->SetAlphaMode(CIwMaterial::ALPHA_DEFAULT);
    IwGxSetMaterial(mat);
    
	CIwSVec2 xy(x-45, y-45);
    CIwSVec2 duv(IW_FIXED(1.0/numFrames), IW_GEOM_ONE);
    
	static CIwSVec2 wh(90, 90);
	static CIwSVec2 uv(IW_FIXED(0), IW_FIXED(0));	
    
    IwGxSetScreenSpaceSlot(1);
    IwGxDrawRectScreenSpace(&xy, &wh, &uv, &duv);
    
    delete mat;
}

void Graphics::DrawTexture(const Rect& screenCoords, int textureId, const Rect& textureCoord, float xOffset, float yOffset)
{
    static CIwSVec2 textureUVs[4];
    static CIwSVec2 screenXY[4];
    static CIwMaterial material;

    CIwTexture* texture = (CIwTexture*)ResourceManager::GetInstance().GetTexture(textureId)->GetData();
    if (!texture)
        return;

    material.Reset();
    material.SetAlphaMode(CIwMaterial::ALPHA_BLEND);
    material.SetTexture(texture);

    int16 width = texture->GetWidth();
    int16 height = texture->GetHeight();

    static const int16 uvSize = 4096;

    // screen coordinates
    screenXY[0] = CIwSVec2((int16)(screenCoords.left + xOffset), (int16)(screenCoords.top + yOffset));
    screenXY[1] = CIwSVec2((int16)(screenCoords.left + xOffset), (int16)(screenCoords.bottom + yOffset));
    screenXY[2] = CIwSVec2((int16)(screenCoords.right + xOffset), (int16)(screenCoords.top + yOffset));
    screenXY[3] = CIwSVec2((int16)(screenCoords.right + xOffset), (int16)(screenCoords.bottom + yOffset));

    // texture's UV coordinates
    textureUVs[0] = CIwSVec2(((int16)textureCoord.left * uvSize) / width, ((int16)textureCoord.top * uvSize) / height);
    textureUVs[1] = CIwSVec2(((int16)textureCoord.left * uvSize) / width, ((int16)textureCoord.bottom * uvSize) / height);
    textureUVs[2] = CIwSVec2(((int16)textureCoord.right * uvSize) / width, ((int16)textureCoord.top * uvSize) / height);
    textureUVs[3] = CIwSVec2(((int16)textureCoord.right * uvSize) / width, ((int16)textureCoord.bottom * uvSize) / height);

    IwGxSetMaterial(&material);
    IwGxSetUVStream(textureUVs);

    IwGxSetColStream(NULL);
    IwGxSetVertStreamScreenSpace(screenXY, 4);
    IwGxDrawPrims(IW_GX_QUAD_STRIP, NULL, 4);

    IwGxFlush();
}

CIwMaterial * CRenderer::GetMtlCached( CIwTexture * tex, CIwMaterial::AlphaMode blend )
{
	MaterialContainer::iterator it = mMtlCache.begin(), ite = mMtlCache.end();
	for (; it != ite; it++ )
	{
		if ( (*it)->GetTexture() == tex && (*it)->GetAlphaMode() == blend )
		{
			return *it;
		}
	}

	CIwMaterial * pMat = new CIwMaterial();
	pMat->SetTexture( tex ); 
	pMat->SetAlphaMode( blend ); 
	//pMat->SetBlendMode( CIwMaterial::BLEND_MODULATE_4X );
	pMat->SetFiltering( true );
	pMat->SetClamping(true);

	mMtlCache.push_back( pMat );

	return pMat;
}

void MapBackground::RenderBackgroundOnSurface(CIw2DSurface* pSurface)
{
	std::list<MapTile*>::iterator iter = gVectorImageUrls.begin();

	// Set up a view matrix to rotate what we are viewing about the z-axis
	// This normalizes the center of the screen to (0,0), so we need to offset
	// our coordinates.
	// We also need to scale in our X and Y directions.

	CIwColour colClear;
	colClear = IwGxGetColClear();

	if (g_dAlpha < 0xFF)
	{
		IwGxSetColClear(0, 0, 0, 0);
	}

	CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
	for (int i = 0; i < 4; ++i)
	{
		cols[i].r = cols[i].g = cols[i].b = 0xff;
		cols[i].a = (uint8)g_dAlpha;
	}
	//static CIwSVec2 uvs[4] =
	//{
	//	CIwSVec2(0 << 12, 0 << 12),
	//	CIwSVec2(0 << 12, 1 << 12),
	//	CIwSVec2(1 << 12, 1 << 12),
	//	CIwSVec2(1 << 12, 0 << 12),
	//};
	static CIwSVec2 uvs[4] =
	{
		CIwSVec2((0 << 12) + 1, (0 << 12) + 1),
		CIwSVec2((0 << 12) + 1, (1 << 12) - 1),
		CIwSVec2((1 << 12) - 1, (1 << 12) - 1),
		CIwSVec2((1 << 12) - 1, (0 << 12) + 1),
	};

	static CIwSVec2 uvsRot[4] =
	{
		CIwSVec2((0 << 12) + 20, (0 << 12) + 20),
		CIwSVec2((0 << 12) + 20, (1 << 12) - 20),
		CIwSVec2((1 << 12) - 20, (1 << 12) - 20),
		CIwSVec2((1 << 12) - 20, (0 << 12) + 20),
	};

	while (iter != gVectorImageUrls.end())
	{
		MapTile* pTile = *iter;
		
		CIwTexture* pTexture = pTile->pTexture;

		if (pTexture)
		{
			//Calculate the top left of the map image
			CIwSVec2 topLeft = pTile->location;

			CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL();
			pMat->SetAlphaMode(CIwMaterial::ALPHA_BLEND);
			pMat->SetModulateMode(CIwMaterial::MODULATE_RGB);

			// Use Texture on Material
			pMat->SetTexture(pTexture);
			IwGxSetMaterial(pMat);

			int xOffset = IwGxGetScreenWidth() / 2;
			int yOffset = IwGxGetScreenHeight() / 2;

			CIwSVec3* pWSCoords= IW_GX_ALLOC(CIwSVec3, 4);
 			pWSCoords[0].x = topLeft.x; pWSCoords[0].y = topLeft.y;
			pWSCoords[1].x = topLeft.x; pWSCoords[1].y = topLeft.y + 256;
			pWSCoords[2].x = topLeft.x + 256; pWSCoords[2].y = topLeft.y + 256;
			pWSCoords[3].x = topLeft.x + 256; pWSCoords[3].y = topLeft.y;
			pWSCoords[0].z = pWSCoords[1].z = pWSCoords[2].z = pWSCoords[3].z = 0;

			// Scale the coordinates by offsetting, scaling and rendering
			for (int i = 0; i < 4; ++i)
			{
				pWSCoords[i].x -= xOffset;
				pWSCoords[i].y -= yOffset;
			}

			IwGxSetVertStreamWorldSpace(pWSCoords, 4);

			if (g_bScaledMode)
			{
				IwGxSetUVStream(uvsRot);
			}
			else
			{
				IwGxSetUVStream(uvs);
			}
			IwGxSetColStream(cols);
			IwGxDrawPrims(IW_GX_QUAD_LIST, NULL, 4);
		}
		iter++;
	}
	IwGxSetColStream(NULL);
	//IwGxSetColClear(colClear.r, colClear.g, colClear.b, colClear.a);
}

// BatchDrawPrims - Currently only supports batching of Quad lists
void CzPlatformRender::BatchDrawPrims(bool filter)
{
	if (NextMaterial == 0)
		return;

	// Allocate memory from data cache for verts, UV's and colours
	for (int t = 0; t < NextMaterial; t++)
	{
		int prim_count = MaterialUsedCounts[t] * 4;
		BatchVerts[t] = IW_GX_ALLOC(CzVec2, prim_count);
		BatchUVs[t] = IW_GX_ALLOC(CzVec2, prim_count);
		BatchColours[t] = IW_GX_ALLOC(CzColour, prim_count);
		BatchIndices[t] = IW_GX_ALLOC(uint16, prim_count);
	}

	// Populate the data cache
	CzRenderPrim** prims = Primitives;
	for (int t = 0; t < NextPrimitive; t++)
	{
		CzRenderPrim *prim = *prims;
		int mat_id = prim->MaterialID;
		int idx = MaterialIndices[mat_id];
		CzVec2* v = BatchVerts[mat_id] + idx;
		CzVec2* uv = BatchUVs[mat_id] + idx;
		CzColour* c = BatchColours[mat_id] + idx;
		uint16* i = BatchIndices[mat_id] + idx;
		for (int t2 = 0; t2 < 4; t2++)
		{
			v->x = (prim->Verts + t2)->x;
			v->y = (prim->Verts + t2)->y;
			uv->x = (prim->UVs + t2)->x;
			uv->y = (prim->UVs + t2)->y;
			c->set(*(prim->Colours + t2));
			v++; uv++; c++;
		}
// TODO: ERROR - Does not work with batched ngon
		*i++ = idx;
		*i++ = idx + 3;
		*i++ = idx + 2;
		*i++ = idx + 1;
		MaterialIndices[mat_id] += 4;
		prims++;
	}

	// Render batched streams
	CzRenderMaterial** mats = Materials;
	for (int t = 0; t < NextMaterial; t++)
	{
		int count = MaterialUsedCounts[t] * 4;
		IwGxSetUVStream((CIwFVec2*)BatchUVs[t], 0);
		IwGxSetVertStreamScreenSpace((CIwFVec2*)BatchVerts[t], count);
		IwGxSetColStream((CIwColour*)(BatchColours[t]), count);
		IwGxSetNormStream(NULL);
		CIwMaterial* mat = IW_GX_ALLOC_MATERIAL();
		CIwTexture* texture = static_cast<CIwTexture*>((*mats)->Image->getTexture());
		mat->SetTexture(texture);
		mat->SetDepthWriteMode(CIwMaterial::DEPTH_WRITE_DISABLED);
		mat->SetClamping(false);
		mat->SetFiltering(filter);
		mat->SetAlphaMode(CIwMaterial::ALPHA_BLEND);
		mat->SetCullMode(CIwMaterial::CULL_BACK);
//		mat->SetCullMode(CIwMaterial::CULL_NONE);
		IwGxSetMaterial(mat);
		IwGxDrawPrims(IW_GX_QUAD_LIST, BatchIndices[t], count);
		mats++;
	}

	// Reset batch pointers
	for (int t = 0; t < NextMaterial; t++)
		MaterialUsedCounts[t] = 0;
	for (int t = 0; t < NextMaterial; t++)
		MaterialIndices[t] = 0;
	NextPrimitive = 0;
	NextMaterial = 0;
}

extern "C" void RenderButtons()
{
    ExButtons* pbutton = g_ButtonsHead;

    if(g_ButtonsHead)
    {
        pbutton = g_ButtonsHead;
        while(pbutton != NULL)
        {
            // Check the key and pointer states.
            pbutton->key_state = s3eKeyboardGetState(pbutton->key);
            if( s3eKeyboardGetState(pbutton->key) & S3E_KEY_STATE_DOWN )
            {
                if(pbutton->handler)
                    pbutton->handler();
            }

            if (!(s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_UP))
            {
                int pointerx = s3ePointerGetX();
                int pointery = s3ePointerGetY();
                if (pointerx >= pbutton->x && pointerx <= pbutton->x+pbutton->w && pointery >=pbutton->y && pointery <= pbutton->y+pbutton->h)
                {
                    if (s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_DOWN)
                    {
                        pbutton->key_state = S3E_KEY_STATE_DOWN;
                    }
                    if (s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_PRESSED)
                    {
                        pbutton->key_state = S3E_KEY_STATE_PRESSED;
                    }

                    if(pbutton->handler)
                        pbutton->handler();
                }

            }

            // Draw the text
            IwGxSetScreenSpaceSlot(0);

            if(s3ePointerGetInt(S3E_POINTER_AVAILABLE))
            {
                CIwMaterial *fadeMat = IW_GX_ALLOC_MATERIAL();
                fadeMat->SetAlphaMode(CIwMaterial::SUB);
                IwGxSetMaterial(fadeMat);

                CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
                if(pbutton->key_state == S3E_KEY_STATE_DOWN)
                    memset(cols, 15, sizeof(CIwColour)*4);
                else
                    memset(cols, 50, sizeof(CIwColour)*4);

                // Draw button area
                CIwSVec2 XY(pbutton->x, pbutton->y-2), dXY(pbutton->w, pbutton->h);
                IwGxDrawRectScreenSpace(&XY, &dXY, cols);
            }

            IwGxPrintString(pbutton->x + 2, pbutton->y + ((pbutton->h - 10)/2), pbutton->name, false);
            pbutton = pbutton->next;
        }
    }
}

//.........这里部分代码省略.........
	IwGxLightingOn();
	IwGxSetColStream(NULL);
	IwGxSetNormStream(NULL);

	CIwGxFont* mfont = static_cast<CIwGxFont*>(font->getFontHandle());
	CIwGxFontPreparedData* prep_text = static_cast<CIwGxFontPreparedData*>(prepared_text);

	// A font can consist of multiple materials so we need to process all of them
	for (int t = 0; t < mfont->GetNumberMaterials(); t++)
	{
		// Set UV stream
		uint32* char_ids;
		int num_chars = IwGxFontSetUVs(*prep_text, -1, t, &char_ids);

		// Generate transformed vertices from glyphs
		int nv = num_chars << 2;
		CzVec2* pVerts = IW_GX_ALLOC(CzVec2, nv);
		CzVec2* pVert = pVerts;
		if (m01 == 0 && m10 == 0)
		{
			// No rotation optimisation
			for (int t2 = 0; t2 < num_chars; t2++)
			{
				CIwRect rc = prep_text->GetCharacterArea(char_ids[t2]);
				float x1 = (float)rc.x;
				float y1 = (float)rc.y;
				float x2 = x1 + (float)rc.w;
				float y2 = y1 + (float)rc.h;
				float ax = (m00 * x1) + tx;
				float ay = (m11 * y1) + ty;
				float bx = (m00 * x2) + tx;
				float by = (m11 * y2) + ty;

//				if ((ax < clip.w && bx >= clip.x) && (ay < clip.h && by >= clip.y))
//				{
					pVert->x = ax + sx1;
					pVert->y = ay + sy1;
					pVert++;
					pVert->x = ax - sx1;
					pVert->y = by + sy2;
					pVert++;
					pVert->x = bx - sx2;
					pVert->y = by - sy2;
					pVert++;
					pVert->x = bx + sx2;
					pVert->y = ay - sy1;
					pVert++;
//				}
			}
		}
		else
		{
			for (int t2 = 0; t2 < num_chars; t2++)
			{
				CIwRect rc = prep_text->GetCharacterArea(char_ids[t2]);
				float x1 = (float)rc.x;
				float y1 = (float)rc.y;
				float x2 = x1 + (float)rc.w;
				float y2 = y1 + (float)rc.h;
				pVert->x = (m00 * x1 + m10 * y1 + tx + sx1);
				pVert->y = (m01 * x1 + m11 * y1 + ty + sy1);
				pVert++;
				pVert->x = (m00 * x1 + m10 * y2 + tx - sx1);
				pVert->y = (m01 * x1 + m11 * y2 + ty + sy2);
				pVert++;
				pVert->x = (m00 * x2 + m10 * y2 + tx - sx2);
				pVert->y = (m01 * x2 + m11 * y2 + ty - sy2);
				pVert++;
				pVert->x = (m00 * x2 + m10 * y1 + tx + sx2);
				pVert->y = (m01 * x2 + m11 * y1 + ty - sy1);
				pVert++;
			}
		}

		if (nv > 0)
		{
			// Set vertex stream
			IwGxSetVertStreamScreenSpace((CIwFVec2*)pVerts, nv);

			// Create a material
			CIwMaterial* mat = IW_GX_ALLOC_MATERIAL();
			mat->Copy(*IwGxFontGetFont()->GetMaterial(t));
			mat->SetDepthWriteMode(CIwMaterial::DEPTH_WRITE_DISABLED);
			mat->SetColEmissive(colour.get());
			mat->SetClamping(true);
			mat->SetFiltering(filter);
			mat->SetAlphaMode(am);
			mat->SetCullMode(CIwMaterial::CULL_BACK);
//			mat->SetCullMode(CIwMaterial::CULL_NONE);
			IwGxSetMaterial(mat);

			// Finally draw the glyphs
			IwGxDrawPrims(IW_GX_QUAD_LIST, NULL, nv);

			CurrentAlphaMode = alpha_mode;
		}
	}
	IwGxLightingOff();
	CurrentTexture = NULL;
}

extern "C" void RenderCursorskeys()
{
    int height = 20;
    int width = 45;

    int lefty = IwGxGetScreenHeight() - (height * 2);
    int leftx = (IwGxGetScreenWidth() - 220) / 2;
    int upy = IwGxGetScreenHeight() - (height * 3);
    int upx = leftx+width + (width/2);
    int downy = IwGxGetScreenHeight() - height;
    int downx = upx;
    int righty = IwGxGetScreenHeight() - (height * 2);
    int rightx = downx + width + (width/2);

    CIwMaterial *fadeMat = IW_GX_ALLOC_MATERIAL();
    fadeMat->SetAlphaMode(CIwMaterial::SUB);
    IwGxSetMaterial(fadeMat);

    g_Cursorkey = EXCURSOR_NONE;

    if ( (s3eKeyboardGetState(s3eKeyLeft) & S3E_KEY_STATE_DOWN) )
        g_Cursorkey = EXCURSOR_LEFT;
    if ( (s3eKeyboardGetState(s3eKeyRight) & S3E_KEY_STATE_DOWN) )
        g_Cursorkey = EXCURSOR_RIGHT;
    if ( (s3eKeyboardGetState(s3eKeyUp) & S3E_KEY_STATE_DOWN) )
        g_Cursorkey = EXCURSOR_UP;
    if ( (s3eKeyboardGetState(s3eKeyDown) & S3E_KEY_STATE_DOWN) )
        g_Cursorkey = EXCURSOR_DOWN;

    if(s3ePointerGetInt(S3E_POINTER_AVAILABLE))
    {
        if (s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_DOWN)
        {
            int pointerx = s3ePointerGetX();
            int pointery = s3ePointerGetY();
            // Check left
            if (pointerx >= leftx && pointerx <= leftx+width && pointery >=lefty && pointery <= lefty+height)
                g_Cursorkey = EXCURSOR_LEFT;
            // Check right
            if (pointerx >= rightx && pointerx <= rightx+width && pointery >=righty && pointery <= righty+height)
                g_Cursorkey = EXCURSOR_RIGHT;
            // Check up
            if (pointerx >= upx && pointerx <= upx+width && pointery >=upy && pointery <= upy+height)
                g_Cursorkey = EXCURSOR_UP;
            // Check down
            if (pointerx >= downx && pointerx <= downx+width && pointery >=downy && pointery <= downy+height)
                g_Cursorkey = EXCURSOR_DOWN;
        }

        CIwColour* cols = IW_GX_ALLOC(CIwColour, 4);
        if((s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_DOWN) && (g_Cursorkey != EXCURSOR_NONE))
            memset(cols, 10, sizeof(CIwColour)*4);
        else
            memset(cols, 50, sizeof(CIwColour)*4);

        // draw black rect covering screen
        CIwSVec2 rectdim(width, height);

        CIwSVec2 uXY(upx, upy-2);
        IwGxDrawRectScreenSpace(&uXY, &rectdim, cols);
        IwGxPrintString(upx + 10, upy + 5, "Up", false);

        CIwSVec2 dXY(downx, downy-2);
        IwGxDrawRectScreenSpace(&dXY, &rectdim, cols);
        IwGxPrintString(downx + 10, downy + 5, "Down", false);

        CIwSVec2 lXY(leftx, lefty-2);
        IwGxDrawRectScreenSpace(&lXY, &rectdim, cols);
        IwGxPrintString(leftx + 10, lefty + 5, "Left", false);

        CIwSVec2 rXY(rightx, righty-2);
        IwGxDrawRectScreenSpace(&rXY, &rectdim, cols);
        IwGxPrintString(rightx + 10, righty + 5, "Right", false);
    }
}

void doMain() {
    if(s3ePointerGetInt(S3E_POINTER_MULTI_TOUCH_AVAILABLE)){
        s3ePointerRegister(S3E_POINTER_TOUCH_EVENT, (s3eCallback)MultiTouchButtonCB, NULL);
        s3ePointerRegister(S3E_POINTER_TOUCH_MOTION_EVENT, (s3eCallback)MultiTouchMotionCB, NULL);
    } else {
        s3ePointerRegister(S3E_POINTER_BUTTON_EVENT, (s3eCallback)SingleTouchButtonCB, NULL);
        s3ePointerRegister(S3E_POINTER_MOTION_EVENT, (s3eCallback)SingleTouchMotionCB, NULL);
    }


    IwGetResManager()->LoadGroup("resource_groups/palate.group");
    
    palateGroup = IwGetResManager()->GetGroupNamed("Palate");

    std::vector<int> ui_texture_hashes;
	uint background_hash = IwHashString("background_clean");
	CIwResList* resources = palateGroup->GetListHashed(IwHashString("CIwTexture"));
	for(CIwManaged** itr = resources->m_Resources.GetBegin(); itr != resources->m_Resources.GetEnd(); ++itr) {
		if(background_hash != (*itr)->m_Hash) {
			ui_texture_hashes.push_back((*itr)->m_Hash);
		}
	}
    
    CIwMaterial* background = new CIwMaterial();
    background->SetTexture((CIwTexture*)palateGroup->GetResNamed("background_clean", IW_GX_RESTYPE_TEXTURE));
    background->SetModulateMode(CIwMaterial::MODULATE_NONE);
    background->SetAlphaMode(CIwMaterial::ALPHA_DEFAULT);

	unit_ui = new CIwMaterial();
    unit_ui->SetModulateMode(CIwMaterial::MODULATE_NONE);
    unit_ui->SetAlphaMode(CIwMaterial::ALPHA_DEFAULT);
    unit_ui->SetTexture((CIwTexture*)palateGroup->GetResNamed("TAKE2", IW_GX_RESTYPE_TEXTURE));
    
    CIwSVec2 bg_wh(320, 480);
	CIwSVec2 ui_wh(80, 480);
	CIwSVec2 ui_offset(240, 0);
	CIwSVec2 uv(0, 0);
	CIwSVec2 duv(IW_GEOM_ONE, IW_GEOM_ONE);

    init();
    
	IwGxLightingOff();
    IwGxSetColClear(255, 255, 255, 255);
    
    float worldScrollMultiplier = 0.75;
    
    if(s3eDeviceGetInt(S3E_DEVICE_OS) == S3E_OS_ID_IPHONE) {
        worldScrollMultiplier = 0.925;
    }

	while (1) {
        
        int64 start = s3eTimerGetMs();
	
		s3eDeviceYield(0);
		s3eKeyboardUpdate();
		s3ePointerUpdate();
		
		if ((s3eKeyboardGetState(s3eKeyEsc) & S3E_KEY_STATE_DOWN)
				|| (s3eKeyboardGetState(s3eKeyAbsBSK) & S3E_KEY_STATE_DOWN)       
				|| (s3eDeviceCheckQuitRequest())) {
			
		    break;
		}
	
        switch(currentState) {

        case MAIN_MENU:
            if(s3ePointerGetState(S3E_POINTER_BUTTON_SELECT) & S3E_POINTER_STATE_PRESSED) {
                currentState = IN_GAME;
            }
            if(frameCount % FRAMES_PER_UPDATE == 0) {
			    mainMenu->tick();
		    }
            mainMenu->render();
            break;
        case IN_GAME:
            IwGxSetMaterial(background);
            IwGxSetScreenSpaceSlot(-1);
            IwGxDrawRectScreenSpace(&CIwSVec2::g_Zero, &bg_wh, &uv, &duv);

		    IwGxSetMaterial(unit_ui);
            IwGxSetScreenSpaceSlot(1); 
            IwGxDrawRectScreenSpace(&ui_offset, &ui_wh, &uv, &duv);
        
		    if (worldScrollSpeed > .0005 || worldScrollSpeed < -.0005) {
			    game->rotate(worldScrollSpeed);
			    worldScrollSpeed *= worldScrollMultiplier;
		    }
            if(frameCount % FRAMES_PER_UPDATE == 0) {
			    game->tick();
		    }
		
		    game->render();
		    if(!renderTouches()) {
                break;
            }

            break;
        }
//.........这里部分代码省略.........