void VisionApp::SetColor(int32 which, const rgb_color color) { BAutolock colorLock(const_cast<BLocker*>(&fSettingsLock)); if (!colorLock.IsLocked()) return; if (which < MAX_COLORS && which >= 0 && (fColors[which].red != color.red || fColors[which].green != color.green || fColors[which].blue != color.blue || fColors[which].alpha != color.alpha)) { fColors[which] = color; fVisionSettings->ReplaceData("color", B_RGB_COLOR_TYPE, which, reinterpret_cast<void* const*>(&color), sizeof(rgb_color)); fActiveTheme->WriteLock(); if (which == C_BACKGROUND) { // update regular background color on all other text for (int32 i = 0; i < C_TIMESTAMP; i++) fActiveTheme->SetBackground(i, color); fActiveTheme->SetBackground(MAX_COLORS, color); } // update timestamp bg color else if (which == C_TIMESTAMP_BACKGROUND) fActiveTheme->SetBackground(C_TIMESTAMP, color); else if (which == C_SELECTION) fActiveTheme->SetBackground(C_SELECTION, color); // mirc fColors need to be updated on both fore and back else if (which >= C_MIRC_WHITE) { fActiveTheme->SetForeground(which, color); fActiveTheme->SetBackground(which, color); } else fActiveTheme->SetForeground(which, color); fActiveTheme->WriteUnlock(); } }
rgb_color VisionApp::GetColor(int32 which) const { rgb_color color = {0, 0, 0, 255}; BAutolock colorLock(const_cast<BLocker*>(&fSettingsLock)); if (!colorLock.IsLocked()) return color; if (which < MAX_COLORS && which >= 0) color = fColors[which]; return color; }
SkColorFilterImageFilter* SkColorFilterImageFilter::Create(SkColorFilter* cf, SkImageFilter* input, const CropRect* cropRect, uint32_t uniqueID) { if (NULL == cf) { return NULL; } SkColorFilter* inputColorFilter; if (input && input->asColorFilter(&inputColorFilter) && inputColorFilter) { SkAutoUnref autoUnref(inputColorFilter); // Try to collapse two consecutive matrix filters SkScalar colorMatrix[20], inputMatrix[20]; if (cf->asColorMatrix(colorMatrix) && inputColorFilter->asColorMatrix(inputMatrix) && !matrix_needs_clamping(inputMatrix)) { SkScalar combinedMatrix[20]; mult_color_matrix(colorMatrix, inputMatrix, combinedMatrix); SkAutoTUnref<SkColorFilter> newCF(SkColorMatrixFilter::Create(combinedMatrix)); return SkNEW_ARGS(SkColorFilterImageFilter, (newCF, input->getInput(0), cropRect, 0)); } // Try to collapse two consecutive table filters SkBitmap colorTable, inputTable; if (cf->asComponentTable(&colorTable) && inputColorFilter->asComponentTable(&inputTable)) { uint8_t combinedTable[4 * 256]; SkAutoLockPixels colorLock(colorTable); SkAutoLockPixels inputLock(inputTable); combine_color_tables(colorTable.getAddr8(0, 0), inputTable.getAddr8(0, 0), combinedTable); SkAutoTUnref<SkColorFilter> newCF(SkTableColorFilter::CreateARGB( &combinedTable[256 * 0], &combinedTable[256 * 1], &combinedTable[256 * 2], &combinedTable[256 * 3]) ); return SkNEW_ARGS(SkColorFilterImageFilter, (newCF, input->getInput(0), cropRect, 0)); } } return SkNEW_ARGS(SkColorFilterImageFilter, (cf, input, cropRect, uniqueID)); }
sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* source, const Context& ctx, SkIPoint* offset) const { SkIPoint colorOffset = SkIPoint::Make(0, 0); sk_sp<SkSpecialImage> color(this->filterInput(1, source, ctx, &colorOffset)); if (!color) { return nullptr; } SkIPoint displOffset = SkIPoint::Make(0, 0); sk_sp<SkSpecialImage> displ(this->filterInput(0, source, ctx, &displOffset)); if (!displ) { return nullptr; } const SkIRect srcBounds = SkIRect::MakeXYWH(colorOffset.x(), colorOffset.y(), color->width(), color->height()); // Both paths do bounds checking on color pixel access, we don't need to // pad the color bitmap to bounds here. SkIRect bounds; if (!this->applyCropRect(ctx, srcBounds, &bounds)) { return nullptr; } SkIRect displBounds; displ = this->applyCropRect(ctx, displ.get(), &displOffset, &displBounds); if (!displ) { return nullptr; } if (!bounds.intersect(displBounds)) { return nullptr; } const SkIRect colorBounds = bounds.makeOffset(-colorOffset.x(), -colorOffset.y()); SkVector scale = SkVector::Make(fScale, fScale); ctx.ctm().mapVectors(&scale, 1); #if SK_SUPPORT_GPU if (source->isTextureBacked()) { GrContext* context = source->getContext(); sk_sp<GrTexture> colorTexture(color->asTextureRef(context)); sk_sp<GrTexture> displTexture(displ->asTextureRef(context)); if (!colorTexture || !displTexture) { return nullptr; } GrSurfaceDesc desc; desc.fFlags = kRenderTarget_GrSurfaceFlag; desc.fWidth = bounds.width(); desc.fHeight = bounds.height(); desc.fConfig = kSkia8888_GrPixelConfig; SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc)); if (!dst) { return nullptr; } GrPaint paint; SkMatrix offsetMatrix = GrCoordTransform::MakeDivByTextureWHMatrix(displTexture.get()); offsetMatrix.preTranslate(SkIntToScalar(colorOffset.fX - displOffset.fX), SkIntToScalar(colorOffset.fY - displOffset.fY)); paint.addColorFragmentProcessor( GrDisplacementMapEffect::Create(fXChannelSelector, fYChannelSelector, scale, displTexture.get(), offsetMatrix, colorTexture.get(), SkISize::Make(color->width(), color->height())))->unref(); paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode); SkMatrix matrix; matrix.setTranslate(-SkIntToScalar(colorBounds.x()), -SkIntToScalar(colorBounds.y())); SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget())); if (!drawContext) { return nullptr; } drawContext->drawRect(GrClip::WideOpen(), paint, matrix, SkRect::Make(colorBounds)); offset->fX = bounds.left(); offset->fY = bounds.top(); return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()), kNeedNewImageUniqueID_SpecialImage, dst); } #endif SkBitmap colorBM, displBM; if (!color->getROPixels(&colorBM) || !displ->getROPixels(&displBM)) { return nullptr; } if ((colorBM.colorType() != kN32_SkColorType) || (displBM.colorType() != kN32_SkColorType)) { return nullptr; } SkAutoLockPixels colorLock(colorBM), displLock(displBM); if (!colorBM.getPixels() || !displBM.getPixels()) { return nullptr; } SkImageInfo info = SkImageInfo::MakeN32(bounds.width(), bounds.height(), colorBM.alphaType()); SkBitmap dst; if (!dst.tryAllocPixels(info)) { return nullptr; } SkAutoLockPixels dstLock(dst); computeDisplacement(fXChannelSelector, fYChannelSelector, scale, &dst, displBM, colorOffset - displOffset, colorBM, colorBounds); offset->fX = bounds.left(); offset->fY = bounds.top(); return SkSpecialImage::MakeFromRaster(SkIRect::MakeWH(bounds.width(), bounds.height()), dst); }
void csSprite2DMeshObject::PreGetBuffer (csRenderBufferHolder* holder, csRenderBufferName buffer) { if (!holder) return; csColoredVertices* vertices = GetCsVertices (); if (buffer == CS_BUFFER_INDEX) { size_t indexSize = vertices->GetSize (); if (!index_buffer.IsValid() || (indicesSize != indexSize)) { index_buffer = csRenderBuffer::CreateIndexRenderBuffer ( indexSize, CS_BUF_DYNAMIC, CS_BUFCOMP_UNSIGNED_INT, 0, vertices->GetSize () - 1); holder->SetRenderBuffer (CS_BUFFER_INDEX, index_buffer); csRenderBufferLock<uint> indexLock (index_buffer); uint* ptr = indexLock; for (size_t i = 0; i < vertices->GetSize (); i++) { *ptr++ = (uint)i; } indicesSize = indexSize; } } else if (buffer == CS_BUFFER_TEXCOORD0) { if (texels_dirty) { int texels_count; const csVector2 *uvani_uv = 0; if (!uvani) texels_count = (int)vertices->GetSize (); else uvani_uv = uvani->GetVertices (texels_count); size_t texelSize = texels_count; if (!texel_buffer.IsValid() || (texel_buffer->GetSize() != texelSize * sizeof(float) * 2)) { texel_buffer = csRenderBuffer::CreateRenderBuffer ( texelSize, CS_BUF_STATIC, CS_BUFCOMP_FLOAT, 2); holder->SetRenderBuffer (CS_BUFFER_TEXCOORD0, texel_buffer); } csRenderBufferLock<csVector2> texelLock (texel_buffer); for (size_t i = 0; i < (size_t)texels_count; i++) { csVector2& v = texelLock[i]; if (!uvani) { v.x = (*vertices)[i].u; v.y = (*vertices)[i].v; } else { v.x = uvani_uv[i].x; v.y = uvani_uv[i].y; } } texels_dirty = false; } } else if (buffer == CS_BUFFER_COLOR) { if (colors_dirty) { size_t color_size = vertices->GetSize (); if (!color_buffer.IsValid() || (color_buffer->GetSize() != color_size * sizeof(float) * 2)) { color_buffer = csRenderBuffer::CreateRenderBuffer ( color_size, CS_BUF_STATIC, CS_BUFCOMP_FLOAT, 3); holder->SetRenderBuffer (CS_BUFFER_COLOR, color_buffer); } csRenderBufferLock<csColor> colorLock (color_buffer); for (size_t i = 0; i < vertices->GetSize (); i++) { colorLock[i] = (*vertices)[i].color; } colors_dirty = false; } } else if (buffer == CS_BUFFER_POSITION) { if (vertices_dirty) { size_t vertices_size = vertices->GetSize (); if (!vertex_buffer.IsValid() || (vertex_buffer->GetSize() != vertices_size * sizeof(float) * 3)) { vertex_buffer = csRenderBuffer::CreateRenderBuffer ( vertices_size, CS_BUF_STATIC, CS_BUFCOMP_FLOAT, 3); holder->SetRenderBuffer (CS_BUFFER_POSITION, vertex_buffer); } csRenderBufferLock<csVector3> vertexLock (vertex_buffer); for (size_t i = 0; i < vertices->GetSize (); i++) { vertexLock[i].Set ((*vertices)[i].pos.x, (*vertices)[i].pos.y, 0.0f); } vertices_dirty = false; } } }