Exemplo n.º 1
0
void VGContext::releasePaint(VGbitfield paintModes)
{
	if(paintModes & VG_FILL_PATH)
	{
		//release previous paint
		Paint* prev = (Paint*)m_fillPaint;
		if(prev)
		{
			if(!prev->removeReference())
				RI_DELETE(prev);
		}
		m_fillPaint = VG_INVALID_HANDLE;
	}
	if(paintModes & VG_STROKE_PATH)
	{
		//release previous paint
		Paint* prev = (Paint*)m_strokePaint;
		if(prev)
		{
			if(!prev->removeReference())
				RI_DELETE(prev);
		}
		m_strokePaint = VG_INVALID_HANDLE;
	}
}
Exemplo n.º 2
0
  virtual void OnDraw(const Context &context) override {
    using wiztk::graphic::Canvas;
    using wiztk::graphic::Paint;

    const RectF &rect = GetBounds();
    int scale = context.surface()->GetScale();

    Canvas *canvas = context.canvas();
    canvas->Save();
    canvas->Scale(scale, scale);

    Paint paint;
    paint.SetColor(ColorF(0.855f, 0.855f, 0.165f, .9f));
    canvas->DrawRect(rect, paint);

    canvas->Restore();

    SkCanvas *sk_canvas = canvas->GetSkCanvas();

    SkImageInfo info = SkImageInfo::MakeN32(400, 400, kPremul_SkAlphaType);
    sk_sp<SkSurface> surface = sk_canvas->makeSurface(info);

    SkCanvas *top_canvas = surface->getCanvas();
    SkRect top_rect = SkRect::MakeXYWH(50, 50, 100, 100);
    SkPaint top_paint;
    top_paint.setColor(0xFFFF0000);

    top_canvas->drawRect(top_rect, top_paint);
    top_canvas->flush();

    surface->draw(sk_canvas, 100, 100, nullptr);

    canvas->Flush();
  }
static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong bitmapHandle,
                       jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,
                       jint screenDensity, jint bitmapDensity) {
    Canvas* canvas = get_canvas(canvasHandle);
    const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
    const Paint* paint = reinterpret_cast<Paint*>(paintHandle);

    if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
        if (screenDensity != 0 && screenDensity != bitmapDensity) {
            Paint filteredPaint;
            if (paint) {
                filteredPaint = *paint;
            }
            filteredPaint.setFilterLevel(Paint::kLow_FilterLevel);
            canvas->drawBitmap(*bitmap, left, top, &filteredPaint);
        } else {
            canvas->drawBitmap(*bitmap, left, top, paint);
        }
    } else {
        canvas->save(SkCanvas::kMatrixClip_SaveFlag);
        SkScalar scale = canvasDensity / (float)bitmapDensity;
        canvas->translate(left, top);
        canvas->scale(scale, scale);

        Paint filteredPaint;
        if (paint) {
            filteredPaint = *paint;
        }
        filteredPaint.setFilterLevel(Paint::kLow_FilterLevel);

        canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint);
        canvas->restore();
    }
}
static void android_view_DisplayListCanvas_drawRegionAsRects(JNIEnv* env, jobject clazz,
        jlong rendererPtr, jlong regionPtr, jlong paintPtr) {
    DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);
    SkRegion* region = reinterpret_cast<SkRegion*>(regionPtr);
    Paint* paint = reinterpret_cast<Paint*>(paintPtr);
    if (paint->getStyle() != Paint::kFill_Style ||
            (paint->isAntiAlias() && !renderer->isCurrentTransformSimple())) {
        SkRegion::Iterator it(*region);
        while (!it.done()) {
            const SkIRect& r = it.rect();
            renderer->drawRect(r.fLeft, r.fTop, r.fRight, r.fBottom, *paint);
            it.next();
        }
    } else {
        int count = 0;
        Vector<float> rects;
        SkRegion::Iterator it(*region);
        while (!it.done()) {
            const SkIRect& r = it.rect();
            rects.push(r.fLeft);
            rects.push(r.fTop);
            rects.push(r.fRight);
            rects.push(r.fBottom);
            count += 4;
            it.next();
        }
        renderer->drawRects(rects.array(), count, paint);
    }
}
// Regular JNI
static void nAddStyleRun(JNIEnv* /* unused */, jclass /* unused */, jlong builderPtr,
                         jlong paintPtr, jint start, jint end, jboolean isRtl) {
    Paint* paint = toPaint(paintPtr);
    const Typeface* typeface = Typeface::resolveDefault(paint->getAndroidTypeface());
    minikin::MinikinPaint minikinPaint = MinikinUtils::prepareMinikinPaint(paint, typeface);
    toBuilder(builderPtr)->addStyleRun(start, end, std::move(minikinPaint), isRtl);
}
Exemplo n.º 6
0
int main(int argc, char* argv[])
{   
	string input;
	Scan scan;
	Paint print;

	

	if (argc == 2)//无-a -f
	{
		
		input = argv[1];
		scan.ToStringQueue(input);
		print.Printqueue();
	}

	else if (argc == 3 )//第二个参数-a
	{
		input = argv[2];
		cout << input << " ";
		scan.ToStringQueue(input);
		print.Printqueue();
	}
	
	else// -f的情况
	{
		
		fout.open(argv[3]);
		flag = 4;
		ifstream fin;
		fin.open(argv[2]);
		if (fin.is_open())
		{

			while (fin.good() && !fin.eof())//读取到文件尾停止读入
			{
				
				string message;//先将运算式存入message 再转存如input进行操作
				fin >> message;
				input = message;
				ssss = argv[3];
				scan.ToStringQueue(input);
				print.Printqueue();

			}
		}	
	}
	system("pause");
	return 0;
	
}
Exemplo n.º 7
0
void Canvas::drawAtlas(CanvasImage* atlas,
    const Vector<RSTransform>& transforms, const Vector<Rect>& rects,
    const Vector<SkColor>& colors, TransferMode mode,
    const Rect& cullRect, const Paint& paint)
{
  if (!m_canvas)
    return;

  RefPtr<SkImage> skImage = atlas->image();

  Vector<SkRSXform> skXForms;
  skXForms.reserveInitialCapacity(transforms.size());
  for (const RSTransform& transform : transforms)
    skXForms.append(transform.sk_xform);

  Vector<SkRect> skRects;
  skRects.reserveInitialCapacity(rects.size());
  for (const Rect& rect : rects)
    skRects.append(rect.sk_rect);

  m_canvas->drawAtlas(
      skImage.get(),
      skXForms.data(),
      skRects.data(),
      colors.isEmpty() ? nullptr : colors.data(),
      skXForms.size(),
      mode,
      cullRect.is_null ? nullptr : &cullRect.sk_rect,
      paint.paint()
  );
}
Exemplo n.º 8
0
void Canvas::saveLayer(const Rect& bounds, const Paint& paint)
{
    if (!m_canvas)
        return;
    m_canvas->saveLayer(!bounds.is_null ? &bounds.sk_rect : nullptr,
                        paint.paint());
}
Exemplo n.º 9
0
void Canvas::drawImageNine(const CanvasImage* image, Rect& center, Rect& dst, const Paint& paint) {
    if (!m_canvas)
        return;
    ASSERT(image);
    SkIRect icenter;
    center.sk_rect.round(&icenter);
    m_canvas->drawImageNine(image->image(), icenter, dst.sk_rect, paint.paint());
}
Exemplo n.º 10
0
void Spinner::Private::Draw(const Context &context) {
  angle += 5.f;
  if (angle > 360.f) angle = 0.f;

  Canvas *canvas = context.canvas();
  int scale = context.surface()->GetScale();
  canvas->Scale(scale, scale);

  const RectF &rect = proprietor()->GetBounds();
  float radius = base::Clamp(std::min(rect.width(), rect.height()) / 2.f - 50.f,
                             50.f, 200.f);

  Paint paint;
  paint.SetAntiAlias(true);

  paint.SetColor(background);
  paint.SetStyle(Paint::Style::kStyleFill);
  canvas->DrawRect(rect, paint);

  paint.SetColor(ColorF(foreground));
  paint.SetStyle(Paint::Style::kStyleStroke);
  paint.SetStrokeWidth(6.f);

  canvas->DrawArc(RectF(rect.center_x() - radius,
                        rect.center_y() - radius,
                        rect.center_x() + radius,
                        rect.center_y() + radius),
                  angle, 300.f, false, paint);

  frame_callback.Setup(context.surface());
}
    void doFrame(int frameNr) override {
        const char* text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

        std::unique_ptr<Canvas> canvas(
                Canvas::create_recording_canvas(container->stagingProperties().getWidth(),
                                                container->stagingProperties().getHeight(),
                                                container.get()));

        Paint paint;
        paint.setAntiAlias(true);
        paint.setColor(Color::Black);
        for (int i = 0; i < 5; i++) {
            paint.setTextSize(10 + (frameNr % 20) + i * 20);
            TestUtils::drawUtf8ToCanvas(canvas.get(), text, paint, 0, 100 * (i + 2));
        }

        container->setStagingDisplayList(canvas->finishRecording());
    }
Exemplo n.º 12
0
void Canvas::saveLayer(double left,
                       double top,
                       double right,
                       double bottom,
                       const Paint& paint)
{
    if (!m_canvas)
        return;
    SkRect bounds = SkRect::MakeLTRB(left, top, right, bottom);
    m_canvas->saveLayer(&bounds, paint.paint());
}
Exemplo n.º 13
0
void Canvas::drawVertices(SkCanvas::VertexMode vertexMode,
        const Vector<Point>& vertices,
        const Vector<Point>& textureCoordinates,
        const Vector<SkColor>& colors,
        SkXfermode::Mode transferMode,
        const Vector<int>& indices,
        const Paint& paint,
        ExceptionState& es)
{
    if (!m_canvas)
        return;
    size_t vertexCount = vertices.size();

    if (textureCoordinates.size() && textureCoordinates.size() != vertexCount)
        return es.ThrowRangeError("vertices and textureCoordinates lengths must match");
    if (colors.size() && colors.size() != vertexCount)
        return es.ThrowRangeError("vertices and colors lengths must match");

    Vector<SkPoint> skVertices;
    for (size_t x = 0; x < vertices.size(); x++) {
        const Point& point = vertices[x];
        if (point.is_null)
            return es.ThrowRangeError("vertices contained a null");
        skVertices.append(point.sk_point);
    }

    Vector<SkPoint> skTextureCoordinates;
    for (size_t x = 0; x < textureCoordinates.size(); x++) {
        const Point& point = textureCoordinates[x];
        if (point.is_null)
            return es.ThrowRangeError("textureCoordinates contained a null");
        skTextureCoordinates.append(point.sk_point);
    }

    Vector<uint16_t> skIndices;
    for (size_t x = 0; x < indices.size(); x++) {
        uint16_t i = indices[x];
        skIndices.append(i);
    }

    RefPtr<SkXfermode> transferModePtr = adoptRef(SkXfermode::Create(transferMode));

    m_canvas->drawVertices(
        vertexMode,
        skVertices.size(),
        skVertices.data(),
        skTextureCoordinates.isEmpty() ? nullptr : skTextureCoordinates.data(),
        colors.isEmpty() ? nullptr : colors.data(),
        transferModePtr.get(),
        skIndices.isEmpty() ? nullptr : skIndices.data(),
        skIndices.size(),
        *paint.paint()
    );
}
    void doFrame(int frameNr) override {
        std::unique_ptr<uint16_t[]> text = TestUtils::asciiToUtf16(
                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
        ssize_t textLength = 26 * 2;

        TestCanvas canvas(
                container->stagingProperties().getWidth(),
                container->stagingProperties().getHeight());
        Paint paint;
        paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
        paint.setAntiAlias(true);
        paint.setColor(Color::Black);
        for (int i = 0; i < 5; i++) {
            paint.setTextSize(10 + (frameNr % 20) + i * 20);
            canvas.drawText(text.get(), 0, textLength, textLength,
                    0, 100 * (i + 2), kBidi_Force_LTR, paint, nullptr);
        }

        container->setStagingDisplayList(canvas.finishRecording(), nullptr);
    }
Exemplo n.º 15
0
static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,
                           float srcLeft, float srcTop, float srcRight, float srcBottom,
                           float dstLeft, float dstTop, float dstRight, float dstBottom,
                           jlong paintHandle, jint screenDensity, jint bitmapDensity) {
    Canvas* canvas = get_canvas(canvasHandle);
    const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
    const Paint* paint = reinterpret_cast<Paint*>(paintHandle);

    if (screenDensity != 0 && screenDensity != bitmapDensity) {
        Paint filteredPaint;
        if (paint) {
            filteredPaint = *paint;
        }
        filteredPaint.setFilterLevel(Paint::kLow_FilterLevel);
        canvas->drawBitmap(*bitmap, srcLeft, srcTop, srcRight, srcBottom,
                           dstLeft, dstTop, dstRight, dstBottom, &filteredPaint);
    } else {
        canvas->drawBitmap(*bitmap, srcLeft, srcTop, srcRight, srcBottom,
                           dstLeft, dstTop, dstRight, dstBottom, paint);
    }
}
Exemplo n.º 16
0
void TitleBar::CloseButton::OnDraw(const Context &context) {
  Canvas *canvas = context.canvas();
  int scale = context.surface()->GetScale();
  const RectF &rect = GetBounds();

  canvas->Scale(scale, scale);

  Paint paint;
  paint.SetAntiAlias(true);
  base::ColorF background = 0xFFDD6666;

  if (IsHovered()) {
    if (IsPressed()) {
      background -= 45;
    } else {
      background += 35;
    }
  }

  paint.SetStyle(Paint::Style::kStyleFill);
  paint.SetColor(background);
  canvas->DrawCircle(rect.center_x(), rect.center_y(), 7.f, paint);

//  paint.SetColor(Theme::GetData().title_bar.active.foreground.color);
  paint.SetColor(0xFFDDDDDD);
  paint.SetStrokeWidth(1.5f);
  canvas->DrawLine(rect.center_x() - 3.f, rect.center_y() - 3.f,
                   rect.center_x() + 3.f, rect.center_y() + 3.f,
                   paint);
  canvas->DrawLine(rect.center_x() + 3.f, rect.center_y() - 3.f,
                   rect.center_x() - 3.f, rect.center_y() + 3.f,
                   paint);
}
Exemplo n.º 17
0
void SliderView::draw(ICanvas& c){
	Paint paint;

	paint.setStyle( Paint::eSTYLE_FILL_AND_STROKE );
	paint.setFillColor( mBaseColor );
	paint.setStrokeColor( mBorderColor );

	// Base rect
	c.drawRect(0, 0, getSize().x, getSize().y, &paint);
	
	// Slider
	paint.setStyle( Paint::eSTYLE_FILL );
	paint.setFillColor( mSliderColor );

	if(mMode == eMODE_HORIZONTAL){
		// Progress rect
		float pos = glm::mix(0.0f, getSize().x - mBarWidth, mValue/100.0f);

		c.drawRect(pos, 0, mBarWidth, getSize().y, &paint);
	}
	else{
		float pos = glm::mix(0.0f, getSize().y - mBarWidth, mValue/100.0f);

		c.drawRect(0, pos, mBarWidth, getSize().x, &paint);
	}
}
Exemplo n.º 18
0
void Canvas::drawVertices(SkCanvas::VertexMode vertexMode,
        const std::vector<Point>& vertices,
        const std::vector<Point>& textureCoordinates,
        const std::vector<CanvasColor>& colors,
        TransferMode transferMode,
        const std::vector<int>& indices,
        const Paint& paint)
{
  if (!m_canvas)
    return;

  std::vector<SkPoint> skVertices;
  skVertices.reserve(vertices.size());
  for (const Point& point : vertices)
    skVertices.push_back(point.sk_point);

  std::vector<SkPoint> skTextureCoordinates;
  skVertices.reserve(textureCoordinates.size());
  for (const Point& point : textureCoordinates)
    skTextureCoordinates.push_back(point.sk_point);

  std::vector<SkColor> skColors;
  skColors.reserve(colors.size());
  for (const CanvasColor& color : colors)
    skColors.push_back(color);

  std::vector<uint16_t> skIndices;
  skIndices.reserve(indices.size());
  for (uint16_t i : indices)
    skIndices.push_back(i);

  RefPtr<SkXfermode> transferModePtr = adoptRef(SkXfermode::Create(transferMode));

  m_canvas->drawVertices(
    vertexMode,
    skVertices.size(),
    skVertices.data(),
    skTextureCoordinates.empty() ? nullptr : skTextureCoordinates.data(),
    skColors.empty() ? nullptr : skColors.data(),
    transferModePtr.get(),
    skIndices.empty() ? nullptr : skIndices.data(),
    skIndices.size(),
    *paint.paint()
  );
}
Exemplo n.º 19
0
void Canvas::drawImageRect(const CanvasImage* image,
                           double srcLeft,
                           double srcTop,
                           double srcRight,
                           double srcBottom,
                           double dstLeft,
                           double dstTop,
                           double dstRight,
                           double dstBottom,
                           const Paint& paint) {
    if (!m_canvas)
        return;
    ASSERT(image);
    m_canvas->drawImageRect(image->image(),
                            SkRect::MakeLTRB(srcLeft, srcTop, srcRight, srcBottom),
                            SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom),
                            paint.paint(),
                            SkCanvas::kFast_SrcRectConstraint);
}
Exemplo n.º 20
0
void Canvas::drawImageNine(const CanvasImage* image,
                           double centerLeft,
                           double centerTop,
                           double centerRight,
                           double centerBottom,
                           double dstLeft,
                           double dstTop,
                           double dstRight,
                           double dstBottom,
                           const Paint& paint) {
    if (!m_canvas)
        return;
    ASSERT(image);
    SkRect center = SkRect::MakeLTRB(centerLeft, centerTop, centerRight, centerBottom);
    SkIRect icenter;
    center.round(&icenter);
    m_canvas->drawImageNine(image->image(),
                            icenter,
                            SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom),
                            paint.paint());
}
Exemplo n.º 21
0
void Canvas::drawAtlas(CanvasImage* atlas,
    const Vector<RSTransform>& transforms, const Vector<Rect>& rects,
    const Vector<SkColor>& colors, SkXfermode::Mode mode,
    const Rect& cullRect, const Paint& paint, ExceptionState& es)
{
    if (!m_canvas)
        return;
    RefPtr<SkImage> skImage = atlas->image();
    if (transforms.size() != rects.size())
        return es.ThrowRangeError("transforms and rects lengths must match");
    if (colors.size() && colors.size() != rects.size())
        return es.ThrowRangeError("if supplied, colors length must match that of transforms and rects");

    Vector<SkRSXform> skXForms;
    for (size_t x = 0; x < transforms.size(); x++) {
        const RSTransform& transform = transforms[x];
        if (transform.is_null)
            return es.ThrowRangeError("transforms contained a null");
        skXForms.append(transform.sk_xform);
    }

    Vector<SkRect> skRects;
    for (size_t x = 0; x < rects.size(); x++) {
        const Rect& rect = rects[x];
        if (rect.is_null)
            return es.ThrowRangeError("rects contained a null");
        skRects.append(rect.sk_rect);
    }

    m_canvas->drawAtlas(
        skImage.get(),
        skXForms.data(),
        skRects.data(),
        colors.isEmpty() ? nullptr : colors.data(),
        skXForms.size(),
        mode,
        cullRect.is_null ? nullptr : &cullRect.sk_rect,
        paint.paint()
    );
}
Exemplo n.º 22
0
void Canvas::drawVertices(SkCanvas::VertexMode vertexMode,
        const Vector<Point>& vertices,
        const Vector<Point>& textureCoordinates,
        const Vector<SkColor>& colors,
        TransferMode transferMode,
        const Vector<int>& indices,
        const Paint& paint)
{
  if (!m_canvas)
    return;

  Vector<SkPoint> skVertices;
  skVertices.reserveInitialCapacity(vertices.size());
  for (const Point& point : vertices)
    skVertices.append(point.sk_point);

  Vector<SkPoint> skTextureCoordinates;
  skVertices.reserveInitialCapacity(textureCoordinates.size());
  for (const Point& point : textureCoordinates)
    skTextureCoordinates.append(point.sk_point);

  Vector<uint16_t> skIndices;
  skIndices.reserveInitialCapacity(indices.size());
  for (uint16_t i : indices)
    skIndices.append(i);

  RefPtr<SkXfermode> transferModePtr = adoptRef(SkXfermode::Create(transferMode));

  m_canvas->drawVertices(
    vertexMode,
    skVertices.size(),
    skVertices.data(),
    skTextureCoordinates.isEmpty() ? nullptr : skTextureCoordinates.data(),
    colors.isEmpty() ? nullptr : colors.data(),
    transferModePtr.get(),
    skIndices.isEmpty() ? nullptr : skIndices.data(),
    skIndices.size(),
    *paint.paint()
  );
}
Exemplo n.º 23
0
void Canvas::drawAtlas(CanvasImage* atlas,
    const std::vector<RSTransform>& transforms, const std::vector<Rect>& rects,
    const std::vector<CanvasColor>& colors, TransferMode mode,
    const Rect& cullRect, const Paint& paint)
{
  if (!m_canvas)
    return;

  RefPtr<SkImage> skImage = atlas->image();

  std::vector<SkRSXform> skXForms;
  skXForms.reserve(transforms.size());
  for (const RSTransform& transform : transforms)
    skXForms.push_back(transform.sk_xform);

  std::vector<SkRect> skRects;
  skRects.reserve(rects.size());
  for (const Rect& rect : rects)
    skRects.push_back(rect.sk_rect);

  std::vector<SkColor> skColors;
  skColors.reserve(colors.size());
  for (const CanvasColor& color : colors)
    skColors.push_back(color);

  m_canvas->drawAtlas(
      skImage.get(),
      skXForms.data(),
      skRects.data(),
      skColors.empty() ? nullptr : skColors.data(),
      skXForms.size(),
      mode,
      cullRect.is_null ? nullptr : &cullRect.sk_rect,
      paint.paint()
  );
}
Exemplo n.º 24
0
void TitleBar::MinimizeButton::OnDraw(const Context &context) {
  Canvas *canvas = context.canvas();
  int scale = context.surface()->GetScale();
  const RectF &rect = GetBounds();

  canvas->Scale(scale, scale);

  Paint paint;
  paint.SetAntiAlias(true);

  if (IsHovered()) {
    if (IsPressed()) {
      paint.SetColor(Theme::GetData().title_bar.highlight.foreground.colors[0]);
      paint.SetStyle(Paint::Style::kStyleFill);
      canvas->DrawCircle(rect.center_x(), rect.center_y(), 7.f, paint);
      paint.Reset();
      paint.SetAntiAlias(true);
    }

    paint.SetStyle(Paint::Style::kStyleStroke);
    paint.SetColor(Theme::GetData().title_bar.active.foreground.colors[0]);
    paint.SetStrokeWidth(1.f);
    canvas->DrawCircle(rect.center_x(), rect.center_y(), 6.5f, paint);
  }

  paint.SetColor(Theme::GetData().title_bar.active.foreground.colors[0]);
  paint.SetStrokeWidth(1.5f);
  canvas->DrawLine(rect.center_x() - 4.f, rect.center_y(),
                   rect.center_x() + 4.f, rect.center_y(),
                   paint);
}
Exemplo n.º 25
0
void Canvas::saveLayerWithoutBounds(const Paint& paint) {
    if (!m_canvas)
        return;
    m_canvas->saveLayer(nullptr, paint.paint());
}
Exemplo n.º 26
0
void StructuralReports::
saveMaterialBoundariesBeta_2(const GridDescription & grid,
    const VoxelizedPartition & vp)
{
	ObjFile objFile;
	int ii,jj,kk;
    
	ostringstream foutname;
	foutname << grid.name() << "_faces.obj";
	ofstream fout(foutname.str().c_str());
	
    const Map<Paint*, SetupUpdateEquationPtr> materials(vp.setupMaterials());
    map<Paint*, SetupUpdateEquationPtr>::const_iterator itr;
    
    const VoxelGrid & vg(vp.voxels());
	//const StructureGrid& grid = *mStructureGrid;
	
	// We'll write the materials one at a time.
	for (itr = materials.begin(); itr != materials.end(); itr++)
    if ( (*itr).first == (*itr).first->withoutModifications())
	{
		Paint* paint = (*itr).first;
		SetupUpdateEquationPtr mat = (*itr).second;
        string name = paint->fullName();
        Rect3i roi = grid.nonPMLHalfCells();
		Paint* lastMat;
        Paint* curMat;
		
		LOGF << "Considering material " << name << endl;
		
		//fout << name << endl;
		
		vector<OrientedRect3i> xFaces;
		vector<OrientedRect3i> yFaces;
		vector<OrientedRect3i> zFaces;
		
		// Do all the face determination stuff
		{
		// X-normal faces
		//	a.  Bottom layer
		ii = roi.p1[0];
		for (kk = roi.p1[2]; kk <= roi.p2[2]; kk++)
		for (jj = roi.p1[1]; jj <= roi.p2[1]; jj++)
		{
			curMat = vg(ii, jj, kk);
			if (curMat == paint)
			{
				xFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii,jj+1,kk+1),
					Vector3i(-1, 0, 0)) );
			}
		} 
		//	b.  Top layer
		ii = roi.p2[0];
		for (kk = roi.p1[2]; kk <= roi.p2[2]; kk++)
		for (jj = roi.p1[1]; jj <= roi.p2[1]; jj++)
		{
			curMat = vg(ii, jj, kk);
			if (curMat == paint)
			{
				xFaces.push_back( OrientedRect3i(
					Rect3i(ii+1,jj,kk,ii+1,jj+1,kk+1),
					Vector3i(1,0,0) ));
			}
		}
		//	c.  Middle (careful about X direction for-loop limits)
		for (ii = roi.p1[0]+1; ii <= roi.p2[0]; ii++)
		for (kk = roi.p1[2]; kk <= roi.p2[2]; kk++)
		for (jj = roi.p1[1]; jj <= roi.p2[1]; jj++)
		{
			lastMat = vg(ii-1, jj, kk);
			curMat = vg(ii, jj, kk);
			
			if (lastMat == paint && curMat != paint)
			{
				xFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii,jj+1,kk+1),
					Vector3i(1, 0, 0)) );
			}
			else if (lastMat != paint && curMat == paint)
			{
				xFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii,jj+1,kk+1),
					Vector3i(-1,0,0) ));
			}
		}
		
		// Y-normal faces
		//	a.  Top layer
		jj = roi.p1[1];
		for (ii = roi.p1[0]; ii <= roi.p2[0]; ii++)
		for (kk = roi.p1[2]; kk <= roi.p2[2]; kk++)
		{
			curMat = vg(ii, jj, kk);
			if (curMat == paint)
			{
				yFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii+1,jj,kk+1),
					Vector3i(0, -1, 0) ));
			}
		} 
		//	b.  Bottom layer
		jj = roi.p2[1];
		for (ii = roi.p1[0]; ii <= roi.p2[0]; ii++)
		for (kk = roi.p1[2]; kk <= roi.p2[2]; kk++)
		{
			curMat = vg(ii, jj, kk);
			if (curMat == paint)
			{
				yFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj+1,kk,ii+1,jj+1,kk+1),
					Vector3i(0, 1, 0) ));
			}
		}
		//	c.  Middle (careful about X direction for-loop limits)
		for (jj = roi.p1[1]+1; jj <= roi.p2[1]; jj++)
		for (ii = roi.p1[0]; ii <= roi.p2[0]; ii++)
		for (kk = roi.p1[2]; kk <= roi.p2[2]; kk++)
		{
			lastMat = vg(ii, jj-1, kk);
			curMat = vg(ii, jj, kk);
			
			if (lastMat == paint && curMat != paint)
			{
				yFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii+1,jj,kk+1),
					Vector3i(0, 1, 0) ));
			}
			else if (lastMat != paint && curMat == paint)
			{
				yFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii+1,jj,kk+1),
					Vector3i(0, -1, 0) ));
			}
		}
		
		// Z-normal faces
		//	a.  Top layer
		kk = roi.p1[2];
		for (jj = roi.p1[1]; jj <= roi.p2[1]; jj++)
		for (ii = roi.p1[0]; ii <= roi.p2[0]; ii++)
		{
			curMat = vg(ii, jj, kk);
			if (curMat == paint)
			{
				zFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii+1,jj+1,kk),
					Vector3i(0, 0, -1) ));
			}
		} 
		//	b.  Bottom layer
		kk = roi.p2[2];
		for (jj = roi.p1[1]; jj <= roi.p2[1]; jj++)
		for (ii = roi.p1[0]; ii <= roi.p2[0]; ii++)
		{
			curMat = vg(ii, jj, kk);
			if (curMat == paint)
			{
				zFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk+1,ii+1,jj+1,kk+1),
					Vector3i(0, 0, 1) ));
			}
		}
		//	c.  Middle (careful about X direction for-loop limits)
		for (kk = roi.p1[2]+1; kk <= roi.p2[2]; kk++)
		for (jj = roi.p1[1]; jj <= roi.p2[1]; jj++)
		for (ii = roi.p1[0]; ii <= roi.p2[0]; ii++)
		{
			lastMat = vg(ii, jj, kk-1);
			curMat = vg(ii, jj, kk);
			
			if (lastMat == paint && curMat != paint)
			{
				zFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii+1,jj+1,kk),
					Vector3i(0, 0, 1) ));
			}
			else if (lastMat != paint && curMat == paint)
			{
				zFaces.push_back( OrientedRect3i(
					Rect3i(ii,jj,kk,ii+1,jj+1,kk),
					Vector3i(0, 0, -1) ));
			}
		}
		}
        
		// Now try to consolidate a little bit.		
		list<OrientedRect3i> xCompressed;
		list<OrientedRect3i> yCompressed;
		list<OrientedRect3i> zCompressed;
		
		consolidateRects(xFaces, xCompressed, 0);
		consolidateRects(yFaces, yCompressed, 1);
		consolidateRects(zFaces, zCompressed, 2);
		
		/*
		ostream_iterator<OrientedRect3i> fout_itr(fout, "\n");
		copy(xCompressed.begin(), xCompressed.end(), fout_itr);
		copy(yCompressed.begin(), yCompressed.end(), fout_itr);
		copy(zCompressed.begin(), zCompressed.end(), fout_itr);
		*/
        
		objFile.appendGroup(name, xCompressed);
		objFile.appendGroup(name, yCompressed);
		objFile.appendGroup(name, zCompressed);
	}
	
    objFile.write(fout, -grid.origin(), 0.5*grid.dxyz());
	//objFile.write(fout, 0.5);  // The scale factor 0.5 undoes half-cells.
	fout.close();
}
Exemplo n.º 27
0
void Canvas::drawImageRect(const CanvasImage* image, Rect& src, Rect& dst, const Paint& paint) {
    if (!m_canvas)
        return;
    ASSERT(image);
    m_canvas->drawImageRect(image->image(), src.sk_rect, dst.sk_rect, paint.paint(), SkCanvas::kFast_SrcRectConstraint);
}
Exemplo n.º 28
0
void Canvas::drawImage(const CanvasImage* image, const Point& p, const Paint& paint) {
    if (!m_canvas)
        return;
    ASSERT(image);
    m_canvas->drawImage(image->image(), p.sk_point.x(), p.sk_point.y(), paint.paint());
}
Exemplo n.º 29
0
void TitleBar::FullscreenButton::OnDraw(const Context &context) {
  Canvas *canvas = context.canvas();
  int scale = context.surface()->GetScale();
  const RectF &rect = GetBounds();

  canvas->Scale(scale, scale);

  Paint paint;
  paint.SetAntiAlias(true);

  if (IsHovered()) {
    if (IsPressed()) {
      paint.SetColor(Theme::GetData().title_bar.active.foreground.colors[0]);
      paint.SetStyle(Paint::Style::kStyleFill);
      canvas->DrawCircle(rect.center_x(), rect.center_y(), 7.f, paint);
      paint.Reset();
      paint.SetAntiAlias(true);
    }

    paint.SetStyle(Paint::Style::kStyleStroke);
    paint.SetColor(Theme::GetData().title_bar.active.foreground.colors[0]);
    paint.SetStrokeWidth(1.f);
    canvas->DrawCircle(rect.center_x(), rect.center_y(), 6.5f, paint);
  }

  paint.SetColor(Theme::GetData().title_bar.active.foreground.colors[0]);
  paint.SetStyle(Paint::Style::kStyleFill);

  Path path;
  path.MoveTo(-5.f, 0.f);
  path.RelativeLineTo(3.5f, -3.5f);
  path.RelativeLineTo(0.f, 7.f);
  path.Close();

  canvas->Translate(rect.center_x(), rect.center_y());
  canvas->Rotate(-45.f);
  canvas->DrawPath(path, paint);
  canvas->Rotate(180.f);
  canvas->DrawPath(path, paint);
}
Exemplo n.º 30
0
void TitleBar::OnDraw(const Context &context) {
  using namespace base;
  using namespace graphic;

  int scale = context.surface()->GetScale();

  const RectF bounds = GetBounds() * scale;
  float factor = 0.5f * scale;

  Paint paint;
  paint.SetAntiAlias(true);
  paint.SetStyle(Paint::kStyleFill);

  Point2F points[2] = {{factor, bounds.top + factor}, {factor, bounds.bottom}};
  uint32_t colors[2] = {0xFFE7E7E7, 0xFFD7D7D7};
  float pos[2] = {0.f, 1.f};

  Shader shader = GradientShader::MakeLinear(points, colors, pos, 2, Shader::kTileModeClamp);
  paint.SetShader(shader);

  context.canvas()->DrawRect(RectF::FromLTRB(bounds.left + factor,
                                             bounds.top + factor,
                                             bounds.right - factor,
                                             bounds.bottom), paint);

  paint.Reset();
  paint.SetAntiAlias(true);
  paint.SetStyle(Paint::kStyleFill);
  paint.SetFont(font_);
  paint.SetTextSize(font_.GetSize() * scale);

  paint.SetColor(Theme::GetData().title_bar.active.foreground.colors[0]);

  float text_width = paint.MeasureText(title_.c_str(), title_.length());

  SkTextBox text_box;
  // Put the foreground at the center
  text_box.setBox(bounds.l + (bounds.width() - text_width) / 2.f,
                  bounds.t + 1.f, // move down a little for better look
                  bounds.r - (bounds.width() - text_width) / 2.f,
                  bounds.b);
  text_box.setSpacingAlign(SkTextBox::kCenter_SpacingAlign);
  text_box.setText(title_.c_str(), title_.length(), paint.GetSkPaint());
  text_box.draw(context.canvas()->GetSkCanvas());

}