void CRenderer::DrawBatch() { if ( GetVBSize() > 0 ) { IwGxLightingOff(); IwGxSetMaterial( mCurrMtl ); IwGxSetUVStream( mUVB ); IwGxSetColStream(mCB, mCBSize); IwGxSetVertStreamScreenSpaceSubPixel( mVB, mVBSize ); if ( mIBSize == 0 ) { IwGxDrawPrims(mBuffType, NULL, mVBSize); } else { IwGxDrawPrims(mBuffType, mIB, mIBSize); } mCurrMtl = NULL; //DefaultMaterial(); IwGxFlush(); IwGxSetColStream(NULL); //IwGxSetUVStream( NULL ); ResetBuffers(); } }
void CRenderer::DrawDirect( IwGxPrimType type, CIwSVec2 * vertex, CIwSVec2 * uv, uint16* indexStream, CIwColour * colour, int32 vertexCount, CIwMaterial * mat ) { IwGxLightingOff(); IwGxSetMaterial( mat ); IwGxSetUVStream( uv ); IwGxSetColStream(colour, vertexCount); IwGxSetVertStreamScreenSpaceSubPixel( vertex, vertexCount ); IwGxDrawPrims(type, indexStream, vertexCount); IwGxFlush(); IwGxSetColStream(NULL); }
void Quads::refresh() { if (vertc > 0) { IwGxSetVertStreamScreenSpace(verts, vertc); IwGxSetColStream(cols, vertc); IwGxDrawPrims(IW_GX_TRI_LIST, NULL, vertc); } }
// 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++; } }
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::display(){ IwGxSetColStream(owner->getColors(), 4); renderImageWorldSpace(position, getAngle(), scale, spriteSize, game->getRotation(), curFrame, numFrames, 0.0f); //UNCOMMENT TO DRAW DEBUG PRIMITIVES. Yellow circle = Unit Sight. Blue circle = Unit bounding volume /* CIwMat pMat = CIwMat::g_Identity; pMat.SetTrans(CIwVec3(position.x, -position.y, 1)); CIwMat rot = CIwMat::g_Identity; rot.SetRotZ(IW_ANGLE_FROM_RADIANS(game->getRotation())); IwGxDebugPrimCircle(pMat*rot, sight, 2,IwGxGetColFixed(IW_GX_COLOUR_YELLOW), false); IwGxDebugPrimCircle(pMat*rot, getSize()/2.0, 2,IwGxGetColFixed(IW_GX_COLOUR_BLUE), false); */ }
void Icing::display() { CIwColour ownerCol = owner->getColor(); CIwColour* colors = (CIwColour*)malloc(sizeof(CIwColour)*4); colors[0] = ownerCol; colors[1] = ownerCol; colors[2] = ownerCol; colors[3] = ownerCol; IwGxSetColStream(colors, 4); renderImageWorldSpace(position, angle, scale, 256, game->getRotation(), 0, 1, .2f); delete colors; }
void Block::draw(int16 x, int16 y, int16 w, int16 h) { if (!enabled) return; xy4[0].x = x, xy4[0].y = y; xy4[1].x = x, xy4[1].y = y+h; xy4[2].x = x+w, xy4[2].y = y+h; xy4[3].x = x+w, xy4[3].y = y; IwGxSetVertStreamScreenSpace(xy4, 4); IwGxSetMaterial(IW_GX_ALLOC_MATERIAL()); IwGxSetColStream(color, 4); // Draw single triangle IwGxDrawPrims(IW_GX_QUAD_LIST, NULL, 4); }
void ExampleRender() { //IW_PROFILE_NEWFRAME(); CIwProfileIteratorDerived pProfileIterator(CIwProfileManager::Get().GetRoot()); pProfileIterator.First(); int iy = 30; while (!pProfileIterator.IsDone()) { PrintfProperty(10, iy, pProfileIterator.GetCurrentName(), pProfileIterator.GetCurrentLastTime()); pProfileIterator.Next(); iy += 10; } PrintfProperty(10, 90, "points: ", (float)m_pAnimator->GetCurrentSpline()->GetPointCount()); IW_PROFILE_START("render"); CIwMaterial* pMat; // Clear the screen IwGxClear(IW_GX_COLOUR_BUFFER_F | IW_GX_DEPTH_BUFFER_F); //// Allocate and initialise material from the IwGx global cache pMat = IW_GX_ALLOC_MATERIAL(); //// Set this as the active material IwGxSetMaterial(pMat); m_pSplinePoly2Tri->Render(); //IwGxSetColStream(s_Cols, 8); m_pBall->Render(); IwGxSetColStream(NULL); // End drawing IwGxFlush(); IW_PROFILE_STOP(); // Swap buffers IwGxSwapBuffers(); }
// 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; }
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; }
void Icing::display() { IwGxSetColStream(owner->getColors(), 4); renderImageWorldSpace(position, angle, scale, 256, game->getRotation(), 0, 1, .2f); }
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); }