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; } } }
void CzPlatformRender::DrawText(CzFontPreparedText prepared_text, CzFont* font, CzMatrix3* transform, const CzColour& colour, CzVec4& skew, bool filter, eCzAlphaMode alpha_mode) { CIwMaterial::AlphaMode am = (CIwMaterial::AlphaMode)alpha_mode; // TODO Add proper method map Marmalade Alpha mode to Marmalade // Cache the transform float m00 = transform->m[0][0]; float m01 = transform->m[0][1]; float m10 = transform->m[1][0]; float m11 = transform->m[1][1]; float tx = transform->getX(); float ty = transform->getY(); float sx1 = (float)skew.x; float sx2 = (float)skew.y; float sy1 = (float)skew.z; float sy2 = (float)skew.w; /* CzIRect clip = ScreenClipRect; clip.x <<= 3; clip.y <<= 3; clip.w = clip.x + (clip.w << 3); clip.h = clip.y + (clip.h << 3);*/ 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; } IwGxFlush(); IwGxSwapBuffers(); // Attempt frame rate while ((s3eTimerGetMs() - start) < MS_PER_FRAME){ int32 yield = (MS_PER_FRAME - (s3eTimerGetMs() - start)); if (yield < 0) { break; } s3eDeviceYield(yield); } frameCount++; IwGxClear(IW_GX_COLOUR_BUFFER_F | IW_GX_DEPTH_BUFFER_F); } delete game; delete mainMenu; delete localPlayer; delete opponentPlayer; delete background; delete unit_ui; palateGroup->Finalise(); for(int i = 0; i < MAX_TOUCHES; ++i) if(touches[i].unit) delete touches[i].unit; }
void GhostCollision::RenderEctoplasmaBar(float ectoPercent, double ghostRotation) { CIwFMat ectoMatrix = CIwFMat(); ectoMatrix.CopyRot(*modelMatrix); ectoMatrix.CopyTrans(*modelMatrix); ectoMatrix.PostRotateY(PI-ghostRotation); IwGxSetModelMatrix(&ectoMatrix); IwGxSetScreenSpaceSlot(1); if (ghostW < 0 || ghostX < 0 || ghostY < 0) ResolveLocation(); const int16 w = 180; const int16 border_x1 = ghostX+ghostW/2 - (float)w*ectobarScale; const int16 border_x2 = ghostX+ghostW/2 + (float)w*ectobarScale; const float border_y1 = ghostY+0x20; const float border_y2 = ghostY+0x20 + (float)0x10*ectobarScale; const int16 z = 0x6; { CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL(); pMat->SetModulateMode(CIwMaterial::MODULATE_RGB); pMat->SetAlphaMode(CIwMaterial::ALPHA_BLEND); pMat->SetTexture(borderTexture); int16 x1 = border_x1, x2 = border_x2; float y1 = border_y1, y2 = border_y2; border_Verts[0] = CIwFVec3(x1, y2, -z); border_Verts[1] = CIwFVec3(x2, y2, -z); border_Verts[2] = CIwFVec3(x2, y1, -z); border_Verts[3] = CIwFVec3(x1, y1, -z); border_Verts[4] = CIwFVec3(x1, y2, z); border_Verts[5] = CIwFVec3(x2, y2, z); border_Verts[6] = CIwFVec3(x2, y1, z); border_Verts[7] = CIwFVec3(x1, y1, z); IwGxSetMaterial(pMat); IwGxSetVertStream(border_Verts, 8); //IwGxSetColStream(s_Cols, 8); IwGxSetUVStream(s_UVs); IwGxDrawPrims(IW_GX_QUAD_STRIP, s_QuadStrip, 4); } float start_y1 = border_y1 + fabs((float)(border_y2 - border_y1)*0.200); float start_y2 = start_y1 + fabs((float)(border_y2 - border_y1)*0.720); float startWhScale = (float)((double)startTexture->GetWidth() / startTexture->GetHeight()); int16 startW = (start_y2 - start_y1) * startWhScale; int16 start_x1 = border_x1 + abs((float)(border_x2 - border_x1)*0.0097); int16 start_x2 = start_x1 + startW; { CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL(); pMat->SetModulateMode(CIwMaterial::MODULATE_RGB); pMat->SetAlphaMode(CIwMaterial::ALPHA_BLEND); pMat->SetTexture(startTexture); int16 x1 = start_x1, x2 = start_x2; float y1 = start_y1, y2 = start_y2; start_Verts[0] = CIwFVec3(x1, y2, -z); start_Verts[1] = CIwFVec3(x2, y2, -z); start_Verts[2] = CIwFVec3(x2, y1, -z); start_Verts[3] = CIwFVec3(x1, y1, -z); start_Verts[4] = CIwFVec3(x1, y2, z); start_Verts[5] = CIwFVec3(x2, y2, z); start_Verts[6] = CIwFVec3(x2, y1, z); start_Verts[7] = CIwFVec3(x1, y1, z); IwGxSetMaterial(pMat); IwGxSetVertStream(start_Verts, 8); //IwGxSetColStream(s_Cols, 8); IwGxSetUVStream(s_UVs); IwGxDrawPrims(IW_GX_QUAD_STRIP, s_QuadStrip, 4); } float end_y1 = start_y1; float end_y2 = start_y2; float endWhScale = (float)((double)endTexture->GetWidth() / endTexture->GetHeight()); int16 endW = (end_y2 - end_y1) * endWhScale; int endMaxX = border_x2 - abs((float)(border_x2 - border_x1)*0.0097) - endW; int endMinX = start_x2; int16 end_x1 = (double)(endMaxX - endMinX)*ectoPercent + endMinX; int16 end_x2 = end_x1 + endW; { CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL(); pMat->SetModulateMode(CIwMaterial::MODULATE_RGB); pMat->SetAlphaMode(CIwMaterial::ALPHA_BLEND); pMat->SetTexture(endTexture); int16 x1 = end_x1, x2 = end_x2; float y1 = end_y1, y2 = end_y2; end_Verts[0] = CIwFVec3(x1, y2, -z); end_Verts[1] = CIwFVec3(x2, y2, -z); end_Verts[2] = CIwFVec3(x2, y1, -z); end_Verts[3] = CIwFVec3(x1, y1, -z); end_Verts[4] = CIwFVec3(x1, y2, z); end_Verts[5] = CIwFVec3(x2, y2, z); end_Verts[6] = CIwFVec3(x2, y1, z); end_Verts[7] = CIwFVec3(x1, y1, z); IwGxSetMaterial(pMat); IwGxSetVertStream(end_Verts, 8); //IwGxSetColStream(s_Cols, 8); IwGxSetUVStream(s_UVs); IwGxDrawPrims(IW_GX_QUAD_STRIP, s_QuadStrip, 4); } float center_y1 = start_y1; float center_y2 = start_y2; int16 center_x1 = start_x2 - 1; int16 center_x2 = end_x1 + 1; { CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL(); pMat->SetModulateMode(CIwMaterial::MODULATE_RGB); pMat->SetAlphaMode(CIwMaterial::ALPHA_BLEND); pMat->SetTexture(centerTexture); int16 x1 = center_x1, x2 = center_x2; float y1 = center_y1, y2 = center_y2; center_Verts[0] = CIwFVec3(x1, y2, -z); center_Verts[1] = CIwFVec3(x2, y2, -z); center_Verts[2] = CIwFVec3(x2, y1, -z); center_Verts[3] = CIwFVec3(x1, y1, -z); center_Verts[4] = CIwFVec3(x1, y2, z); center_Verts[5] = CIwFVec3(x2, y2, z); center_Verts[6] = CIwFVec3(x2, y1, z); center_Verts[7] = CIwFVec3(x1, y1, z); IwGxSetMaterial(pMat); IwGxSetVertStream(center_Verts, 8); //IwGxSetColStream(s_Cols, 8); IwGxSetUVStream(s_UVs); IwGxDrawPrims(IW_GX_QUAD_STRIP, s_QuadStrip, 4); } }
void Transitions2D::Fade(uint8 transitionSpeed, bool skipFirstAndLastFrame) { IwGxSetColClear(0, 0, 0, 0); if (mStartTexture == NULL || mEndTexture == NULL) return; if (transitionSpeed == 0) transitionSpeed = 1; IwGxScreenOrient orient = IwGxGetScreenOrient(); if (isUsingPrivateTextures) IwGxSetScreenOrient(IW_GX_ORIENT_NONE); int alpha = 0; if (skipFirstAndLastFrame) alpha += transitionSpeed; CIwMaterial* startMat; CIwMaterial* endMat; while (alpha <= 255) { IwGxClear(); startMat = IW_GX_ALLOC_MATERIAL(); startMat->SetTexture(mStartTexture); IwGxSetMaterial(startMat); IwGxDrawRectScreenSpace(&CIwSVec2(0, 0), &CIwSVec2(mStartTexture->GetWidth(), mStartTexture->GetHeight())); endMat = IW_GX_ALLOC_MATERIAL(); endMat->SetTexture(mEndTexture); endMat->SetAlphaMode(CIwMaterial::ALPHA_BLEND); endMat->SetColAmbient(255, 255, 255, alpha); IwGxSetMaterial(endMat); IwGxDrawRectScreenSpace(&CIwSVec2(0, 0), &CIwSVec2(mEndTexture->GetWidth(), mEndTexture->GetHeight())); IwGxFlush(); IwGxSwapBuffers(); s3eDeviceYield(40); alpha += transitionSpeed; } if (!skipFirstAndLastFrame) { IwGxClear(); endMat = IW_GX_ALLOC_MATERIAL(); endMat->SetTexture(mEndTexture); IwGxSetMaterial(endMat); IwGxDrawRectScreenSpace(&CIwSVec2(0, 0), &CIwSVec2(mEndTexture->GetWidth(), mEndTexture->GetHeight())); IwGxFlush(); IwGxSwapBuffers(); } if (isUsingPrivateTextures) { delete mStartTexture; delete mEndTexture; mStartTexture = NULL; mEndTexture = NULL; } IwGxSetScreenOrient(orient); }