void Chunk::put(const math::ivec3 &p, CubeType type)
{
CubeType &t = cubes[((p.x * CHUNK_SIZE) + p.y) * CHUNK_SIZE + p.z];
if (slpl)
{
if (isSunFullyTransparent(t) && !isSunFullyTransparent(type))
{
++slpl->valueAt(p.x, p.y);
}
else if (!isSunFullyTransparent(t) && isSunFullyTransparent(type))
{
--slpl->valueAt(p.x, p.y);
}
}
if (isOpaque(t))
--opaqueBlockCount;
else
++opaqueBlockCount;
if (isOpaque(type))
++opaqueBlockCount;
else if (type > 0)
++nonOpaqueBlockCount;
t = type;
needToPersist = true;
if (slpl)
slpl->needToPersist = true;
}
static void test_bitmap(skiatest::Reporter* reporter) {
SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
SkBitmap bmp;
bmp.setInfo(info);
// test 1: bitmap without pixel data
auto shader = bmp.makeShader(SkTileMode::kClamp, SkTileMode::kClamp);
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, !shader->isOpaque());
// From this point on, we have pixels
bmp.allocPixels(info);
// test 2: not opaque by default
shader = bmp.makeShader();
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, !shader->isOpaque());
// test 3: explicitly opaque
bmp.setAlphaType(kOpaque_SkAlphaType);
shader = bmp.makeShader();
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, shader->isOpaque());
// test 4: explicitly not opaque
bmp.setAlphaType(kPremul_SkAlphaType);
shader = bmp.makeShader();
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, !shader->isOpaque());
}
//___________________________________________________________
bool BlurHelper::eventFilter( QObject* object, QEvent* event )
{
// do nothing if not enabled
if( !enabled() ) return false;
switch( event->type() )
{
case QEvent::Hide:
{
QWidget* widget( qobject_cast<QWidget*>( object ) );
if( widget && isOpaque( widget ) )
{
QWidget* window( widget->window() );
if (window && isTransparent(window) && !_pendingWidgets.contains(window) )
{
_pendingWidgets.insert( window, window );
delayedUpdate();
}
}
break;
}
case QEvent::Show:
case QEvent::Resize:
{
// cast to widget and check
QWidget* widget( qobject_cast<QWidget*>( object ) );
if( !widget ) break;
if( isTransparent( widget ) )
{
_pendingWidgets.insert( widget, widget );
delayedUpdate();
} else if( isOpaque( widget ) ) {
QWidget* window( widget->window() );
if( isTransparent( window ) )
{
_pendingWidgets.insert( window, window );
delayedUpdate();
}
}
break;
}
default: break;
}
// never eat events
return false;
}
void TopLevelWindow::setDropShadowEnabled (const bool useShadow)
{
useDropShadow = useShadow;
if (isOnDesktop())
{
shadower = nullptr;
Component::addToDesktop (getDesktopWindowStyleFlags());
}
else
{
if (useShadow && isOpaque())
{
if (shadower == nullptr)
{
shadower = getLookAndFeel().createDropShadowerForComponent (this);
if (shadower != nullptr)
shadower->setOwner (this);
}
}
else
{
shadower = nullptr;
}
}
}
void DecoratedContainer::draw(gcn::Graphics* graphics)
{
if (isOpaque())
{
graphics->setColor(getBackgroundColor());
graphics->fillRectangle(gcn::Rectangle(2, 2, getWidth() - 4, getHeight() - 4));
}
int i;
for (i = 5; i < getHeight()-10; i+=5)
{
graphics->drawImage(mVertical, 0, i);
graphics->drawImage(mVertical, getWidth()-4, i);
}
graphics->drawImage(mVertical, 0, 0, 0, i, 4, getHeight()-5-i);
graphics->drawImage(mVertical, 0, 0, getWidth()-4, i, 4, getHeight()-5-i);
for (i = 5; i < getWidth()-10; i+=5)
{
graphics->drawImage(mHorizontal, i, 0);
graphics->drawImage(mHorizontal, i, getHeight()-4);
}
graphics->drawImage(mHorizontal, 0, 0, i, 0, getWidth()-5-i, 4);
graphics->drawImage(mHorizontal, 0, 0, i, getHeight()-4, getWidth()-5-i, 4);
graphics->drawImage(mCornerUL, 0, 0);
graphics->drawImage(mCornerUR, getWidth()-5, 0);
graphics->drawImage(mCornerDL, 0, getHeight()-5);
graphics->drawImage(mCornerDR, getWidth()-5, getHeight()-5);
drawChildren(graphics);
}
void LayerBase::setGeometry(
const sp<const DisplayDevice>& hw,
HWComposer::HWCLayerInterface& layer)
{
layer.setDefaultState();
// this gives us only the "orientation" component of the transform
const State& s(drawingState());
const uint32_t finalTransform = s.transform.getOrientation();
// we can only handle simple transformation
if (finalTransform & Transform::ROT_INVALID) {
layer.setTransform(0);
} else {
layer.setTransform(finalTransform);
}
if (!isOpaque()) {
layer.setBlending(mPremultipliedAlpha ?
HWC_BLENDING_PREMULT :
HWC_BLENDING_COVERAGE);
}
const Transform& tr = hw->getTransform();
Rect transformedBounds(computeBounds());
transformedBounds = tr.transform(transformedBounds);
// scaling is already applied in transformedBounds
layer.setFrame(transformedBounds);
layer.setCrop(transformedBounds.getBounds());
}
void AlertWindow::lookAndFeelChanged()
{
const int newFlags = getLookAndFeel().getAlertBoxWindowFlags();
setUsingNativeTitleBar ((newFlags & ComponentPeer::windowHasTitleBar) != 0);
setDropShadowEnabled (isOpaque() && (newFlags & ComponentPeer::windowHasDropShadow) != 0);
}
void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const
{
const Layer::State& s(drawingState());
snprintf(buffer, SIZE,
"+ %s %p (%s)\n",
getTypeId(), this, getName().string());
result.append(buffer);
s.transparentRegion.dump(result, "transparentRegion");
visibleRegion.dump(result, "visibleRegion");
snprintf(buffer, SIZE,
" "
"layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), "
"isOpaque=%1d, needsDithering=%1d, invalidate=%1d, "
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h,
s.active.crop.left, s.active.crop.top,
s.active.crop.right, s.active.crop.bottom,
isOpaque(), needsDithering(), contentDirty,
s.alpha, s.flags,
s.transform[0][0], s.transform[0][1],
s.transform[1][0], s.transform[1][1]);
result.append(buffer);
}
void paint (Graphics& g)
{
if (isOpaque())
g.fillAll (Colours::white);
g.setOpacity (1.0f);
g.drawImageAt (image, 0, 0);
}
void ScrollArea::drawBackground(Graphics *graphics)
{
if (isOpaque())
{
graphics->setColor(getBackgroundColor());
graphics->fillRectangle(getChildrenArea());
}
}
void draw(SkCanvas* canvas) {
auto check_isopaque = [](const SkImageInfo& imageInfo) -> void {
auto surface(SkSurface::MakeRaster(imageInfo));
auto image(surface->makeImageSnapshot());
SkDebugf("isOpaque = %s\n", image->isOpaque() ? "true" : "false");
};
check_isopaque(SkImageInfo::MakeN32Premul(5, 5));
check_isopaque(SkImageInfo::MakeN32(5, 5, kOpaque_SkAlphaType));
}
void Container::draw(Graphics* graphics)
{
if (isOpaque())
{
graphics->setColor(getBaseColor());
graphics->fillRectangle(Rectangle(0, 0, getWidth(), getHeight()));
}
drawChildren(graphics);
}
void TabbedArea::draw(Graphics *graphics)
{
const Color &faceColor = getBaseColor();
const int alpha = getBaseColor().a;
Color highlightColor = faceColor + 0x303030;
highlightColor.a = alpha;
Color shadowColor = faceColor - 0x303030;
shadowColor.a = alpha;
// Draw a border.
graphics->setColor(highlightColor);
graphics->drawLine(0,
mTabContainer->getHeight(),
0,
getHeight() - 2);
graphics->setColor(shadowColor);
graphics->drawLine(getWidth() - 1,
mTabContainer->getHeight() + 1,
getWidth() - 1,
getHeight() - 1);
graphics->drawLine(1,
getHeight() - 1,
getWidth() - 1,
getHeight() - 1);
if (isOpaque())
{
graphics->setColor(getBaseColor());
graphics->fillRectangle(Rectangle(1, 1,
getWidth() - 2,
getHeight() - 2));
}
// Draw a line underneath the tabs.
graphics->setColor(highlightColor);
graphics->drawLine(1,
mTabContainer->getHeight(),
getWidth() - 1,
mTabContainer->getHeight());
// If a tab is selected, remove the line right underneath
// the selected tab.
if (mSelectedTab != NULL)
{
graphics->setColor(getBaseColor());
graphics->drawLine(mSelectedTab->getX() + 1,
mTabContainer->getHeight(),
mSelectedTab->getX() + mSelectedTab->getWidth() - 2,
mTabContainer->getHeight());
}
drawChildren(graphics);
}
void ResizableWindow::setBackgroundColour (Colour newColour)
{
auto backgroundColour = newColour;
if (! Desktop::canUseSemiTransparentWindows())
backgroundColour = newColour.withAlpha (1.0f);
setColour (backgroundColourId, backgroundColour);
setOpaque (backgroundColour.isOpaque());
repaint();
}
void MLMultiSlider::paint (Graphics& g)
{
MLLookAndFeel* myLookAndFeel = (&(getRootViewResources(this).mLookAndFeel));
if (isOpaque()) myLookAndFeel->drawBackground(g, this);
float outlineThickness = myLookAndFeel->getGridUnitSize() / 64.f;
MLRect r = mPos.getLocalOutline();
const Colour outlineColor (findColour(MLLookAndFeel::outlineColor).withAlpha (isEnabled() ? 1.f : 0.5f));
// draw fills
// vertical only
Path full, empty;
Colour fullColor, emptyColor;
MLRect fullRect, emptyRect;
float dialY;
MLRange drawRange(mRange);
drawRange.convertTo(MLRange(r.height(), 0.));
for (int i=0; i<mNumSliders; ++i)
{
MLRect sr = (mPos.getElementBounds(i));
dialY = drawRange(getFloatProperty(ml::textUtils::addFinalNumber(ml::Symbol("value"), i)));
fullRect = sr;
emptyRect = sr;
fullRect.setTop(dialY);
fullColor = findColour(trackFullDarkColor);
emptyColor = findColour(trackEmptyDarkColor);
// groups of 4
if (!(i&4))
{
emptyColor = emptyColor.brighter(0.10f);
fullColor = fullColor.brighter(0.20f);
}
empty.clear();
empty.addRectangle(MLToJuceRect(emptyRect));
g.setColour(emptyColor);
g.fillPath(empty);
full.clear();
full.addRectangle(MLToJuceRect(fullRect));
g.setColour(fullColor);
g.fillPath(full);
g.setColour(outlineColor);
g.strokePath(empty, PathStrokeType (outlineThickness));
}
}
bool QWSMemorySurface::isValid() const
{
if (img.isNull())
return true;
const QWidget *win = window();
if (preferredImageFormat(win) != img.format())
return false;
if (isOpaque() != isWidgetOpaque(win)) // XXX: use QWidgetPrivate::isOpaque()
return false;
return true;
}
void QWSWindowSurface::flush(QWidget *widget, const QRegion ®ion,
const QPoint &offset)
{
const QWidget *win = window();
if (!win)
return;
#ifndef QT_NO_GRAPHICSVIEW
QWExtra *extra = win->d_func()->extra;
if (extra && extra->proxyWidget)
return;
#endif //QT_NO_GRAPHICSVIEW
Q_UNUSED(offset);
const bool opaque = isOpaque();
#ifdef QT_QWS_DISABLE_FLUSHCLIPPING
QRegion toFlush = region;
#else
QRegion toFlush = region & d_ptr->clip;
#endif
if (!toFlush.isEmpty()) {
flushUpdate(widget, toFlush, QPoint(0, 0));
QPoint globalZero = win->mapToGlobal(QPoint(0, 0));
toFlush.translate(globalZero);
#ifdef QT_QWS_CLIENTBLIT
bool needRepaint = true;
if (opaque) {
QScreen* widgetScreen = getScreen(widget);
if (widgetScreen->supportsBlitInClients()) {
QWSDisplay::grab();
if(directRegion().intersected(toFlush) == toFlush) {
QPoint translate = -globalZero + painterOffset() + geometry().topLeft();
QRegion flushRegion = toFlush.translated(translate);
widgetScreen->blit(image(), geometry().topLeft(), flushRegion);
widgetScreen->setDirty(toFlush.boundingRect());
needRepaint = false;
}
QWSDisplay::ungrab();
}
}
if(needRepaint)
#endif
win->qwsDisplay()->repaintRegion(winId(), win->windowFlags(), opaque, toFlush);
}
}
static void test_gradient(skiatest::Reporter* reporter) {
SkPoint pts[2];
pts[0].iset(0, 0);
pts[1].iset(1, 0);
SkColor colors[2];
SkScalar pos[2] = {SkIntToScalar(0), SkIntToScalar(1)};
int count = 2;
SkTileMode mode = SkTileMode::kClamp;
// test 1: all opaque
colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
colors[1] = SkColorSetARGB(0xFF, 0, 0, 0);
auto grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, grad->isOpaque());
// test 2: all 0 alpha
colors[0] = SkColorSetARGB(0, 0, 0, 0);
colors[1] = SkColorSetARGB(0, 0, 0, 0);
grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, !grad->isOpaque());
// test 3: one opaque, one transparent
colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
colors[1] = SkColorSetARGB(0x40, 0, 0, 0);
grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, !grad->isOpaque());
// test 4: test 3, swapped
colors[0] = SkColorSetARGB(0x40, 0, 0, 0);
colors[1] = SkColorSetARGB(0xFF, 0, 0, 0);
grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, !grad->isOpaque());
}
bool Chunk::hasEdge(const math::ivec3 &p, Dir dir, bool ignore_neib_chunks) const
{
CubeType t = rawCubeAt(p);
if (!isSolid(t))
return false;
math::ivec3 p2 = p;
if (dir == Dir::XN)
{
--p2.x;
if (ignore_neib_chunks && p2.x == -1)
return true;
}
else if (dir == Dir::XP)
{
++p2.x;
if (ignore_neib_chunks && p2.x == CHUNK_SIZE)
return true;
}
else if (dir == Dir::YN)
{
--p2.y;
if (ignore_neib_chunks && p2.y == -1)
return true;
}
else if (dir == Dir::YP)
{
++p2.y;
if (ignore_neib_chunks && p2.y == CHUNK_SIZE)
return true;
}
else if (dir == Dir::ZN)
{
--p2.z;
if (ignore_neib_chunks && p2.z == -1)
return true;
}
else if (dir == Dir::ZP)
{
++p2.z;
if (ignore_neib_chunks && p2.z == CHUNK_SIZE)
return true;
}
CubeType t2 = cubeAt(p2);
return t2 != t && !isOpaque(t2);
}
void Layer::dump(String8& result, Colorizer& colorizer) const
{
const Layer::State& s(getDrawingState());
colorizer.colorize(result, Colorizer::GREEN);
result.appendFormat(
"+ %s %p (%s)\n",
getTypeId(), this, getName().string());
colorizer.reset(result);
s.activeTransparentRegion.dump(result, "transparentRegion");
visibleRegion.dump(result, "visibleRegion");
sp<Client> client(mClientRef.promote());
result.appendFormat( " "
"layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), "
"isOpaque=%1d, invalidate=%1d, "
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
" client=%p\n",
s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h,
s.active.crop.left, s.active.crop.top,
s.active.crop.right, s.active.crop.bottom,
isOpaque(), contentDirty,
s.alpha, s.flags,
s.transform[0][0], s.transform[0][1],
s.transform[1][0], s.transform[1][1],
client.get());
sp<const GraphicBuffer> buf0(mActiveBuffer);
uint32_t w0=0, h0=0, s0=0, f0=0;
if (buf0 != 0) {
w0 = buf0->getWidth();
h0 = buf0->getHeight();
s0 = buf0->getStride();
f0 = buf0->format;
}
result.appendFormat(
" "
"format=%2d, activeBuffer=[%4ux%4u:%4u,%3X],"
" queued-frames=%d, mRefreshPending=%d\n",
mFormat, w0, h0, s0,f0,
mQueuedFrames, mRefreshPending);
if (mSurfaceFlingerConsumer != 0) {
mSurfaceFlingerConsumer->dump(result, " ");
}
}
void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const
{
const Layer::State& s(drawingState());
snprintf(buffer, SIZE,
"+ %s %p (%s)\n"
" "
"z=%9d, pos=(%g,%g), size=(%4d,%4d), "
"isOpaque=%1d, needsDithering=%1d, invalidate=%1d, "
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
getTypeId(), this, getName().string(),
s.z, s.transform.tx(), s.transform.ty(), s.w, s.h,
isOpaque(), needsDithering(), contentDirty,
s.alpha, s.flags,
s.transform[0][0], s.transform[0][1],
s.transform[1][0], s.transform[1][1]);
result.append(buffer);
}
SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
const SkPaint& paint,
const SkMatrix& ctm,
SkArenaAlloc* alloc) {
SkColorSpace* dstCS = dst.colorSpace();
SkPM4f paintColor = SkPM4f_from_SkColor(paint.getColor(), dstCS);
auto shader = as_SB(paint.getShader());
SkRasterPipeline_<256> shaderPipeline;
if (!shader) {
// Having no shader makes things nice and easy... just use the paint color.
shaderPipeline.append_uniform_color(alloc, paintColor);
bool is_opaque = paintColor.a() == 1.0f,
is_constant = true;
return SkRasterPipelineBlitter::Create(dst, paint, alloc,
shaderPipeline, nullptr,
is_opaque, is_constant);
}
bool is_opaque = shader->isOpaque() && paintColor.a() == 1.0f;
bool is_constant = shader->isConstant();
// Check whether the shader prefers to run in burst mode.
if (auto* burstCtx = shader->makeBurstPipelineContext(
SkShaderBase::ContextRec(paint, ctm, nullptr, SkShaderBase::ContextRec::kPM4f_DstType,
dstCS), alloc)) {
return SkRasterPipelineBlitter::Create(dst, paint, alloc,
shaderPipeline, burstCtx,
is_opaque, is_constant);
}
if (shader->appendStages(&shaderPipeline, dstCS, alloc, ctm, paint)) {
if (paintColor.a() != 1.0f) {
shaderPipeline.append(SkRasterPipeline::scale_1_float,
alloc->make<float>(paintColor.a()));
}
return SkRasterPipelineBlitter::Create(dst, paint, alloc, shaderPipeline, nullptr,
is_opaque, is_constant);
}
// The shader has opted out of drawing anything.
return alloc->make<SkNullBlitter>();
}
void Layer::drawWithOpenGL(
const sp<const DisplayDevice>& hw, const Region& clip) const {
const uint32_t fbHeight = hw->getHeight();
const State& s(getDrawingState());
computeGeometry(hw, mMesh);
/*
* NOTE: the way we compute the texture coordinates here produces
* different results than when we take the HWC path -- in the later case
* the "source crop" is rounded to texel boundaries.
* This can produce significantly different results when the texture
* is scaled by a large amount.
*
* The GL code below is more logical (imho), and the difference with
* HWC is due to a limitation of the HWC API to integers -- a question
* is suspend is whether we should ignore this problem or revert to
* GL composition when a buffer scaling is applied (maybe with some
* minimal value)? Or, we could make GL behave like HWC -- but this feel
* like more of a hack.
*/
const Rect win(computeBounds());
float left = float(win.left) / float(s.active.w);
float top = float(win.top) / float(s.active.h);
float right = float(win.right) / float(s.active.w);
float bottom = float(win.bottom) / float(s.active.h);
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
texCoords[0] = vec2(left, 1.0f - top);
texCoords[1] = vec2(left, 1.0f - bottom);
texCoords[2] = vec2(right, 1.0f - bottom);
texCoords[3] = vec2(right, 1.0f - top);
RenderEngine& engine(mFlinger->getRenderEngine());
engine.setDither(needsDithering());
engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha);
engine.drawMesh(mMesh);
engine.disableBlending();
}
void FFContainer::draw(gcn::Graphics* graphics)
{
int i;
if (isOpaque())
{
double height = (mRealHeight - 8) / 16.0;
gcn::Color c(0x7070FF);
for (i = 0; i<16; ++i)
{
graphics->setColor(c * (1.0 - i / 18.0));
graphics->fillRectangle(gcn::Rectangle(4, (i * height + 4),
getWidth()-8, (i * height ) + height));
}
}
graphics->pushClipArea(gcn::Rectangle(0, mCurrentSlide, getWidth(), getHeight()));
drawChildren(graphics);
graphics->popClipArea();
for (i = 5; i < getHeight()-10; i+=5)
{
graphics->drawImage(mVertical, 0, i);
graphics->drawImage(mVertical, getWidth()-4, i);
}
graphics->drawImage(mVertical, 0, 0, 0, i, 4, getHeight()-5-i);
graphics->drawImage(mVertical, 0, 0, getWidth()-4, i, 4, getHeight()-5-i);
for (i = 5; i < getWidth()-10; i+=5)
{
graphics->drawImage(mHorizontal, i, 0);
graphics->drawImage(mHorizontal, i, getHeight()-4);
}
graphics->drawImage(mHorizontal, 0, 0, i, 0, getWidth()-5-i, 4);
graphics->drawImage(mHorizontal, 0, 0, i, getHeight()-4, getWidth()-5-i, 4);
graphics->drawImage(mCornerUL, 0, 0);
graphics->drawImage(mCornerUR, getWidth()-5, 0);
graphics->drawImage(mCornerDL, 0, getHeight()-5);
graphics->drawImage(mCornerDR, getWidth()-5, getHeight()-5);
}
void Chunk::recalcBlockCount()
{
unsigned opaqueCount = 0;
unsigned nonOpaqueCount = 0;
for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE; ++i)
{
CubeType t = cubes[i];
if (t > 0)
{
if (isOpaque(t))
++opaqueCount;
else
++nonOpaqueCount;
}
}
opaqueBlockCount = opaqueCount;
nonOpaqueBlockCount = nonOpaqueCount;
}
llvm::Value * StructGen::emit(VflModule & module, StructAST & node)
{
std::vector<llvm::Type*> memberTypes;
std::vector<std::string> members;
auto structType = llvm::StructType::create(llvm::getGlobalContext(), node.getName());
module.getTypeSystem().addStructType(node.getName(), structType);
for (auto member : node.getMembers()) {
members.push_back(member->getName());
memberTypes.push_back(member->getType()->toLLVM(module.getTypeSystem()));
}
if (structType->isOpaque()) {
structType->setBody(memberTypes, false);
}
module.getTypeSystem().setStructMembers(node.getName(), members);
return nullptr;
}
llvm::Value * Generator::visit(Struct & node)
{
std::vector<llvm::Type*> memberTypes;
std::vector<std::string> members;
auto structType = llvm::StructType::create(*context, node.name);
typeSys.addStructType(node.name, structType);
for (auto m : node.members) {
members.push_back(m->name);
memberTypes.push_back(m->type->getType(typeSys));
}
if (structType->isOpaque()) {
structType->setBody(memberTypes, false);
}
typeSys.setStructMembers(node.name, members);
return nullptr;
}
void LayerBase::setGeometry(hwc_layer_t* hwcl)
{
hwcl->compositionType = HWC_FRAMEBUFFER;
hwcl->hints = 0;
hwcl->flags = HWC_SKIP_LAYER;
hwcl->transform = 0;
hwcl->blending = HWC_BLENDING_NONE;
// this gives us only the "orientation" component of the transform
const State& s(drawingState());
const uint32_t finalTransform = s.transform.getOrientation();
// we can only handle simple transformation
if (finalTransform & Transform::ROT_INVALID) {
hwcl->flags = HWC_SKIP_LAYER;
} else {
hwcl->transform = finalTransform;
}
if (!isOpaque()) {
hwcl->blending = mPremultipliedAlpha ?
HWC_BLENDING_PREMULT : HWC_BLENDING_COVERAGE;
}
// scaling is already applied in mTransformedBounds
hwcl->displayFrame.left = mTransformedBounds.left;
hwcl->displayFrame.top = mTransformedBounds.top;
hwcl->displayFrame.right = mTransformedBounds.right;
hwcl->displayFrame.bottom = mTransformedBounds.bottom;
hwcl->visibleRegionScreen.rects =
reinterpret_cast<hwc_rect_t const *>(
visibleRegionScreen.getArray(
&hwcl->visibleRegionScreen.numRects));
hwcl->sourceCrop.left = 0;
hwcl->sourceCrop.top = 0;
hwcl->sourceCrop.right = mTransformedBounds.width();
hwcl->sourceCrop.bottom = mTransformedBounds.height();
}
void LayerBase::drawWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip) const
{
const uint32_t fbHeight = hw->getHeight();
const State& s(drawingState());
GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
if (CC_UNLIKELY(s.alpha < 0xFF)) {
const GLfloat alpha = s.alpha * (1.0f/255.0f);
if (mPremultipliedAlpha) {
glColor4f(alpha, alpha, alpha, alpha);
} else {
glColor4f(1, 1, 1, alpha);
}
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
} else {
glColor4f(1, 1, 1, 1);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (!isOpaque()) {
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
} else {
glDisable(GL_BLEND);
}
}
LayerMesh mesh;
computeGeometry(hw, &mesh);
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
struct TexCoords {
GLfloat u;
GLfloat v;
};
Rect win(s.active.w, s.active.h);
if (!s.active.crop.isEmpty()) {
win.intersect(s.active.crop, &win);
}
GLfloat left = GLfloat(win.left) / GLfloat(s.active.w);
GLfloat top = GLfloat(win.top) / GLfloat(s.active.h);
GLfloat right = GLfloat(win.right) / GLfloat(s.active.w);
GLfloat bottom = GLfloat(win.bottom) / GLfloat(s.active.h);
TexCoords texCoords[4];
texCoords[0].u = left;
texCoords[0].v = top;
texCoords[1].u = left;
texCoords[1].v = bottom;
texCoords[2].u = right;
texCoords[2].v = bottom;
texCoords[3].u = right;
texCoords[3].v = top;
for (int i = 0; i < 4; i++) {
texCoords[i].v = 1.0f - texCoords[i].v;
}
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glVertexPointer(2, GL_FLOAT, 0, mesh.getVertices());
glDrawArrays(GL_TRIANGLE_FAN, 0, mesh.getVertexCount());
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_BLEND);
}
void ListBox::colourChanged()
{
setOpaque (findColour (backgroundColourId).isOpaque());
viewport->setOpaque (isOpaque());
repaint();
}
