void pawsStdTreeDecorator::GetCollapseSignFrame(pawsTreeNode* node, csRect &rect) { csRect nodeFrame = node->GetScreenFrame(); rect.SetPos(nodeFrame.xmin - collSpacing - 2, nodeFrame.ymin + nodeFrame.Height()/2 - 4); rect.SetSize(10, 10); }
void csGLRender2TextureFramebuf::SetClipRect (const csRect& clipRect) { GLRENDER3D_OUTPUT_LOCATION_MARKER; GLint vp[4]; glGetIntegerv (GL_VIEWPORT, vp); glScissor (vp[0] + clipRect.xmin, vp[1] + txt_h - clipRect.ymax, clipRect.Width(), clipRect.Height()); }
void csRectRegion::nkSplit (csRect &r1, csRect &r2) { r2.Intersect (r1); if (r1.ymin < r2.ymin) // upper stripe { region.Push (csRect(r1.xmin,r1.ymin, r1.xmax, r2.ymin)); } if (r1.xmin < r2.xmin) // left stripe { region.Push (csRect(r1.xmin,r2.ymin, r2.xmin, r2.ymax)); } if (r1.xmax > r2.xmax) // right stripe { //region.Push (csRect(r2.xmin, r2.ymin, r1.xmax, r2.ymax)); region.Push( csRect(r2.xmax, r2.ymin, r1.xmax, r2.ymax) ); } if (r1.ymax > r2.ymax) // lower stripe { region.Push (csRect(r1.xmin, r2.ymax, r1.xmax, r1.ymax)); } }
// The purpose of this function is to take r1 and fragment it around r2, // removing the area that overlaps. This function can be used by either // Include() or Exclude(), since it simply fragments r1 (but always checks // for swapping!) For Exclusion, r2 is ALWAYS the excluding rect! void csRectRegion::fragmentRect (csRect &r1, csRect &r2, int mode) { // We may have to fragment r1 into three pieces if an entire edge of r2 is // inside r1. if (r1.Intersects (r2)) { // Since fragment rect already test for all cases, the ideal method here // is to call fragment rect on the intersection of r1 and r2 with r1 // as the fragmentee. This creates a properly fragmented system. // // We know that rect1 is already good, so we simply fragment rect2 and // gather it's fragments into the fragment buffer for further consideration. // // In exclude mode, we don't want to remove parts of r2 from r1, whereas // in include mode we want to perform an optimal merge of the two, or // remove parts of r1 from r2. csRect ri (r1); ri.Intersect (r2); if (mode == MODE_INCLUDE) { if (r1.Area () < r2.Area ()) { csRect temp (r1); r1.Set (r2); r2.Set (temp); } // Push r1 back into the regions list region.Push (r1); // Perform fragment and gather. markForGather (); fragmentContainedRect (r2, ri); gatherFragments (); } else { // Fragment inclusion rect around intersection (keep) fragmentContainedRect (r1, ri); } return; } }
void csRectRegionDebug::ClipTo(const csRect &clip) { for(int i = 0; i < CS_RECT_REG_SIZE; i++) { for(int j = 0; j < CS_RECT_REG_SIZE; j++) { if(!clip.Contains(i,j)) area[i][j] = false; } } }
void pawsProgressBar::DrawProgressBar( const csRect &rect, iGraphics3D* graphics3D, float percent, int start_r, int start_g, int start_b, int diff_r, int diff_g, int diff_b, int alpha) { csSimpleRenderMesh mesh; static uint indices[4] = {0, 1, 2, 3}; csVector3 verts[4]; csVector4 colors[4]; float fr1 = start_r / 255.0f; float fg1 = start_g / 255.0f; float fb1 = start_b / 255.0f; float fr2 = fr1 + percent * (diff_r / 255.0f); float fg2 = fg1 + percent * (diff_g / 255.0f); float fb2 = fb1 + percent * (diff_b / 255.0f); float fa = alpha / 255.0f; mesh.meshtype = CS_MESHTYPE_QUADS; mesh.indexCount = 4; mesh.indices = indices; mesh.vertexCount = 4; mesh.vertices = verts; mesh.colors = colors; mesh.mixmode = CS_FX_COPY; mesh.alphaType.autoAlphaMode = false; mesh.alphaType.alphaType = csAlphaMode::alphaSmooth; verts[0].Set(rect.xmin, rect.ymin, 0); colors[0].Set(fr1, fg1, fb1, fa); verts[1].Set(rect.xmin + (rect.Width() * percent), rect.ymin, 0); colors[1].Set(fr2, fg2, fb2, fa); verts[2].Set(rect.xmin + (rect.Width() * percent), rect.ymax, 0); colors[2].Set(fr2, fg2, fb2, fa); verts[3].Set(rect.xmin, rect.ymax, 0); colors[3].Set(fr1, fg1, fb1, fa); graphics3D->DrawSimpleMesh(mesh, csSimpleMeshScreenspace); }
csLockedMaterialMap csTerrainCell::LockMaterialMap (const csRect& rectangle) { csLockedMaterialMap data; if (!materialMapPersistent) { materialmap.SetSize (rectangle.Width () * rectangle.Height ()); data.data = materialmap.GetArray (); data.pitch = rectangle.Width (); } else { data.data = materialmap.GetArray () + materialMapWidth * rectangle.ymin + rectangle.xmin; data.pitch = materialMapWidth; } lockedMaterialMapRect = rectangle; return data; }
void pawsTitle::SetWindowRect(const csRect & windowRect) { size_t a; int winWidth = windowRect.Width(); int w = (int)width; if (scaleWidth) w = (int)(winWidth * width); int deltaX = screenFrame.xmin; int deltaY = screenFrame.ymin; screenFrame.xmin = windowRect.xmin + (winWidth - w) / 2; screenFrame.ymin = windowRect.ymin - height / 2; screenFrame.SetSize(w, height); deltaX = screenFrame.xmin - deltaX; deltaY = screenFrame.ymin - deltaY; for (a=0; a<children.GetSize(); ++a) children[a]->Resize(); for (a=0; a<titleButtons.GetSize(); ++a) { switch (titleButtons[a].align) { case PTA_LEFT: titleButtons[a].buttonWidget->MoveTo(screenFrame.xmin + titleButtons[a].offsetx, screenFrame.ymin + titleButtons[a].offsety); break; case PTA_CENTER: titleButtons[a].buttonWidget->MoveTo(screenFrame.xmin + (screenFrame.Width() - titleButtons[a].buttonWidget->ScreenFrame().Width())/2 + titleButtons[a].offsetx, screenFrame.ymin + titleButtons[a].offsety); break; case PTA_RIGHT: titleButtons[a].buttonWidget->MoveTo(screenFrame.xmax - titleButtons[a].buttonWidget->ScreenFrame().Width() + titleButtons[a].offsetx, screenFrame.ymin + titleButtons[a].offsety); break; case PTA_COUNT: break; } } }
void ProctexPDLight::PDMap::ComputeValueBounds (const csRect& area, csRGBcolor& maxValue, csRect& nonNullArea) { const int width = imageW; maxValue.Set (0, 0, 0); nonNullArea.Set (INT_MAX, INT_MAX, INT_MIN, INT_MIN); int mapPitch = width - area.Width (); if (imageData->IsGray()) { const uint8* map = static_cast<LumelBufferGray*> ((LumelBufferBase*)imageData)->GetData() + area.ymin * width + area.xmin; for (int y = area.ymin; y < area.ymax; y++) { for (int x = area.xmin; x < area.xmax; x++) { uint8 v = *map++; if (v > maxValue.red) maxValue.Set (v, v, v); if (v > 0) { nonNullArea.Extend (x, y); } } map += mapPitch; } } else { const Lumel* map = static_cast<LumelBufferRGB*> ((LumelBufferBase*)imageData)->GetData() + area.ymin * width + area.xmin; for (int y = area.ymin; y < area.ymax; y++) { for (int x = area.xmin; x < area.xmax; x++) { const Lumel& p = *map++; if (p.c.red > maxValue.red) maxValue.red = p.c.red; if (p.c.green > maxValue.green) maxValue.green = p.c.green; if (p.c.blue > maxValue.blue) maxValue.blue = p.c.blue; if (p.c.red + p.c.green + p.c.blue > 0) { nonNullArea.Extend (x, y); } } map += mapPitch; } } // Align line start+end on 2-pixel-boundary (for MMX) nonNullArea.xmin &= ~1; nonNullArea.xmax = (nonNullArea.xmax+1) & ~1; }
void pawsImageDrawable::Draw(csRect rect, int alpha) { Draw(rect.xmin, rect.ymin, rect.Width(), rect.Height(), alpha); }
void csRectRegion::Exclude (const csRect &nrect) { // Ignore an empty rect if (nrect.IsEmpty ()) return; // If there are no rects in the region, just leave. if (region.IsEmpty()) return; size_t i; csRect rect (nrect); /// Clear the fragment buffer for (i = 0; i < FRAGMENT_BUFFER_SIZE; ++i) fragment[i].MakeEmpty (); // Otherwise, we have to see if this rect overlaps or touches any other. for (i = 0; i < region.GetSize(); i++) { csRect r1 (region[i]); csRect r2 (rect); // Check to see if these even touch if (r2.Intersects (r1) == false) continue; // Check to see if the inclusion rect is totally dominated by the // exclusion rect. r1.Exclude (r2); if (r1.IsEmpty ()) { region.DeleteIndex (i); i--; continue; } // Check to see if the exclusion rect is totally dominated by the // exclusion rect r1.Set (region[i]); r2.Exclude (r1); if (r2.IsEmpty ()) { r2.Set (rect); region.DeleteIndex (i); fragmentContainedRect (r1, r2); i = 0; continue; } r2.Set (rect); // This part is similiar to Include, except that we are trying to remove // a portion. Instead of calling chopEdgeIntersection, we actually have // to fragment rect1 and chop off an edge of the excluding rect. This // code should be handled inside fragment rect. // Kill rect from list region.DeleteIndex (i); i--; // Fragment it fragmentRect (r1, r2, MODE_EXCLUDE); } }
void csRectRegion::Include (const csRect &nrect) { // Ignore an empty rect if (nrect.IsEmpty ()) return; // If there are no rects in the region, add this and leave. if (region.IsEmpty()) { region.Push (nrect); return; } size_t i; bool no_fragments; csRect rect (nrect); /// Clear the fragment buffer for (i = 0; i < FRAGMENT_BUFFER_SIZE; ++i) fragment[i].MakeEmpty (); do { bool untouched = true; no_fragments = true; // Otherwise, we have to see if this rect creates a union with any other // rectangles. size_t last_to_consider = region.GetSize(); for (i = 0; i < last_to_consider; i++) { csRect &r1 = region[i]; csRect r2 (rect); // Check to see if these even touch, if not, next. if (r2.Intersects (r1) == false) continue; // If r1 totally contains rect, then we leave. r2.Exclude (r1); if (r2.IsEmpty ()) { // Mark it so we don't add it in untouched = false; break; } // If rect totally contains r1, then we kill r1 from the list. r2.Set (r1); r2.Exclude (rect); if (r2.IsEmpty ()) { // Kill from list region.DeleteIndex (i); i--; last_to_consider--; // Iterate continue; } /* // Otherwise we have to do the most irritating part: A full split // operation that may create other rects that need to be tested against // the database recursively. For this algorithm, we fragment the // one that is already in the database, that way we don't cause more // tests: we already know that that rect is good. r2.Set (rect); // Kill rect from list region.DeleteIndex (i); // Fragment it fragmentRect (r1, r2, MODE_INCLUDE); */ r2.Set (rect); nkSplit (r1, r2); region.DeleteIndex (i); i--; last_to_consider--; // Mark it // untouched = true; } // end for // In the end, we need to put the rect on the stack if (!rect.IsEmpty () && untouched) region.Push (rect); // Check and see if we have fragments to consider for (i = 0; i < FRAGMENT_BUFFER_SIZE; ++i) { if (!(fragment[i].IsEmpty ())) { rect.Set (fragment[i]); fragment[i].MakeEmpty (); no_fragments = false; break; } } } while (!no_fragments); }