~NativeCode() {
if (callbacks.onDestroy != NULL) {
callbacks.onDestroy(this);
}
if (env != NULL) {
if (clazz != NULL) {
env->DeleteGlobalRef(clazz);
}
if (javaAssetManager != NULL) {
env->DeleteGlobalRef(javaAssetManager);
}
}
if (messageQueue != NULL && mainWorkRead >= 0) {
messageQueue->getLooper()->removeFd(mainWorkRead);
}
setSurface(NULL);
if (mainWorkRead >= 0) close(mainWorkRead);
if (mainWorkWrite >= 0) close(mainWorkWrite);
if (dlhandle != NULL) {
// for now don't unload... we probably should clean this
// up and only keep one open dlhandle per proc, since there
// is really no benefit to unloading the code.
//dlclose(dlhandle);
}
}
Image::Image(std::string filename, int xPos, int yPos)
{
setSurface(filename); //Loads entire image into memory
setRect(xPos, yPos, STDTILE, STDTILE); //Loads part of image specified by x and y position. Standard tilesize
setTileSize(STDTILE, STDTILE); //Uses the default tilesize
setColorKey(0,0,STDCKEY); //Uses the default colorkey
}
static void Surface_writeToParcel(
JNIEnv* env, jobject clazz, jobject argParcel, jint flags)
{
Parcel* parcel = (Parcel*)env->GetIntField(
argParcel, no.native_parcel);
if (parcel == NULL) {
doThrowNPE(env);
return;
}
// The Java instance may have a SurfaceControl (in the case of the
// WindowManager or a system app). In that case, we defer to the
// SurfaceControl to send its ISurface. Otherwise, if the Surface is
// available we let it parcel itself. Finally, if the Surface is also
// NULL we fall back to using the SurfaceControl path which sends an
// empty surface; this matches legacy behavior.
const sp<SurfaceControl>& control(getSurfaceControl(env, clazz));
if (control != NULL) {
SurfaceControl::writeSurfaceToParcel(control, parcel);
} else {
sp<Surface> surface(Surface_getSurface(env, clazz));
if (surface != NULL) {
Surface::writeToParcel(surface, parcel);
} else {
SurfaceControl::writeSurfaceToParcel(NULL, parcel);
}
}
if (flags & PARCELABLE_WRITE_RETURN_VALUE) {
setSurfaceControl(env, clazz, NULL);
setSurface(env, clazz, NULL);
}
}
bool CanvasContext::initialize(ANativeWindow* window) {
setSurface(window);
if (mCanvas) return false;
mCanvas = new OpenGLRenderer(mRenderThread.renderState());
mCanvas->initProperties();
return true;
}
Image::Image(std::string filename, int xPos, int yPos, int width, int height, int rkey, int gkey, int bkey)
{
setSurface(filename);
setRect(xPos, yPos, width, height);
setTileSize(width, height);
setColorKey(rkey, gkey, bkey);
}
Image::Image(std::string filename)
{
setSurface(filename); //Loads entire image into memory
setRect(); //Load entire image into rectangle
setTileSize(surf->w, surf->h); //Sets tilesize using the entire image size
setColorKey(0,0,0); //No colorkey
}
void LayerSurfaceEdit::undo(const LayerRef &layer)
{
auto rasterLayer = dynamicSPCast<RasterLayer>(layer);
Q_ASSERT(rasterLayer);
Surface surface = rasterLayer->surface();
rasterLayer->setSurface(_surface);
_surface = surface;
}
static void Surface_transferFrom(
JNIEnv* env, jobject clazz, jobject other)
{
if (clazz == other)
return;
if (other == NULL) {
doThrowNPE(env);
return;
}
sp<SurfaceControl> control(getSurfaceControl(env, other));
sp<Surface> surface(Surface_getSurface(env, other));
setSurfaceControl(env, clazz, control);
setSurface(env, clazz, surface);
setSurfaceControl(env, other, 0);
setSurface(env, other, 0);
}
static void Surface_destroy(JNIEnv* env, jobject clazz, uintptr_t *ostack)
{
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (SurfaceControl::isValid(surface)) {
surface->clear();
}
setSurfaceControl(env, clazz, 0);
setSurface(env, clazz, 0);
}
void CanvasContext::makeCurrent() {
// TODO: Figure out why this workaround is needed, see b/13913604
// In the meantime this matches the behavior of GLRenderer, so it is not a regression
EGLint error = 0;
mHaveNewSurface |= mEglManager.makeCurrent(mEglSurface, &error);
if (error) {
setSurface(nullptr);
}
}
void LayerSurfaceEdit::redo(const LayerRef &layer)
{
auto rasterLayer = std::dynamic_pointer_cast<RasterLayer>(layer);
Q_ASSERT(rasterLayer);
Surface surface = rasterLayer->surface();
rasterLayer->setSurface(_surface);
_surface = surface;
}
void CPicture::scaleTo(Point size)
{
SDL_Surface * scaled = CSDL_Ext::scaleSurface(bg, size.x, size.y);
if(freeSurf)
SDL_FreeSurface(bg);
setSurface(scaled);
freeSurf = false;
}
void Session::createSurface()
{
if (m_surface) return;
setSurface(SurfaceManager::singleton()->createSurface(name(),
Mir::NormalType,
m_application && m_application->fullscreen() ? Mir::FullscreenState :
Mir::MaximizedState,
m_screenshot));
}
bool CanvasContext::initialize(ANativeWindow* window) {
setSurface(window);
if (mCanvas) return false;
mCanvas = new OpenGLRenderer(mRenderThread.renderState());
mCanvas->initProperties();
if (window) {
Surface *s = static_cast<Surface*>(window);
s->allocateBuffers();
}
return true;
}
void CanvasContext::destroy() {
stopDrawing();
setSurface(NULL);
freePrefetechedLayers();
destroyHardwareResources();
mAnimationContext->destroy();
if (mCanvas) {
delete mCanvas;
mCanvas = 0;
}
}
static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel)
{
Parcel* parcel = (Parcel*)env->GetIntField(argParcel, no.native_parcel);
if (parcel == NULL) {
doThrowNPE(env);
return;
}
sp<Surface> sur(Surface::readFromParcel(*parcel));
setSurface(env, clazz, sur);
}
static void Surface_initFromSurfaceTexture(
JNIEnv* env, jobject clazz, jobject jst)
{
sp<ISurfaceTexture> st(SurfaceTexture_getSurfaceTexture(env, jst));
sp<Surface> surface(new Surface(st));
if (surface == NULL) {
jniThrowException(env, OutOfResourcesException, NULL);
return;
}
setSurfaceControl(env, clazz, NULL);
setSurface(env, clazz, surface);
}
void LayerMoveEdit::undo(const LayerRef &layer)
{
auto rasterLayer = dynamicSPCast<RasterLayer>(layer);
Q_ASSERT(rasterLayer);
Surface surface;
{
Painter painter(&surface);
painter.drawPreTransformedSurface(-_offset, rasterLayer->surface());
}
surface.squeeze();
rasterLayer->setSurface(surface);
}
BiotSavart::BiotSavart(Mesh &ms, const Vect<complex_t> &J, Vect<complex_t> &B, int code)
{
_mu = 4*OFELI_PI*1.e-7;
_theMesh = &ms;
_code = code;
setSurface();
_BC = &B;
_C = true;
_bound = false;
_type = J.getDOFType();
_theEdgeList = NULL;
_theSideList = NULL;
_JC = &J;
if (_type==SIDE_FIELD)
_theSideList = new SideList(*_theMesh);
if (_type==EDGE_FIELD)
_theEdgeList = new EdgeList(*_theMesh);
}
Document *createTestDocument(QObject *parent)
{
LayerRef layer[3];
for (int i = 0; i < 3; ++i)
{
auto l = makeSP<RasterLayer>("layer" + QString::number(i));
l->setSurface(createTestSurface(i));
layer[i] = l;
}
auto group = makeSP<GroupLayer>("group");
group->append(layer[1]);
group->append(layer[2]);
QList<LayerRef> layers = { layer[0], group };
return new Document("document", QSize(400, 300), layers, parent);
}
SurfaceItem::SurfaceItem(QWaylandSurface *surface)
: m_depthOffset(0)
, m_opacity(0.55)
, m_textureId(0)
, m_height(maxHeight() * 0.99)
, m_focus(false)
, m_mipmap(true)
{
setSurface(surface);
m_time.start();
connect(surface, &QWaylandSurface::damaged, this, &SurfaceItem::surfaceDamaged);
connect(surface, &QWaylandSurface::sizeChanged, this, &SurfaceItem::sizeChanged);
//m_dirty = QRect(QPoint(), surface->size());
qDebug() << "surface size:" << surface->size();
m_opacityAnimation = new QPropertyAnimation(this, "opacity");
m_opacityAnimation->setDuration(400);
sizeChanged();
}
bool EglHwcomposerBackend::initRenderingContext()
{
if (!initBufferConfigs()) {
return false;
}
if (!createContext()) {
return false;
}
m_nativeSurface = m_backend->createSurface();
EGLSurface surface = eglCreateWindowSurface(eglDisplay(), config(), (EGLNativeWindowType)static_cast<ANativeWindow*>(m_nativeSurface), nullptr);
if (surface == EGL_NO_SURFACE) {
qCCritical(KWIN_HWCOMPOSER) << "Create surface failed";
return false;
}
setSurface(surface);
return makeContextCurrent();
}
void CComponent::init(Etype Type, int Subtype, int Val, ESize imageSize)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
compType = Type;
subtype = Subtype;
val = Val;
size = imageSize;
assert(compType < typeInvalid);
assert(size < sizeInvalid);
setSurface(getFileName()[size], getIndex());
pos.w = image->pos.w;
pos.h = image->pos.h;
EFonts font = FONT_SMALL;
if (imageSize < small)
font = FONT_TINY; //other sizes?
pos.h += 4; //distance between text and image
std::vector<std::string> textLines = CMessage::breakText(getSubtitle(), std::max<int>(80, pos.w), font);
for(auto & line : textLines)
{
int height = graphics->fonts[font]->getLineHeight();
auto label = new CLabel(pos.w/2, pos.h + height/2, font, CENTER, Colors::WHITE, line);
pos.h += height;
if (label->pos.w > pos.w)
{
pos.x -= (label->pos.w - pos.w)/2;
pos.w = label->pos.w;
}
}
}
void CanvasContext::swapBuffers(const SkRect& dirty, EGLint width, EGLint height) {
if (CC_UNLIKELY(!mEglManager.swapBuffers(mEglSurface, dirty, width, height))) {
setSurface(nullptr);
}
mHaveNewSurface = false;
}
void PGRAPH::Begin(Primitive primitive) {
// Set surface
setSurface();
// Set viewport
gfx::Viewport viewportRect = { viewport.x, viewport.y, viewport.width, viewport.height, 0.0f, 1.0f };
gfx::Rectangle scissorRect = { scissor.x, scissor.y, scissor.width, scissor.height };
cmdBuffer->cmdSetViewports(1, &viewportRect);
cmdBuffer->cmdSetScissors(1, &scissorRect);
// Hashing
auto vpData = &vpe.data[vpe.start];
auto vpHash = HashVertexProgram(vpData);
auto fpData = memory->ptr<rsx_fp_instruction_t>((fp_location ? rsx->get_ea(0x0) : 0xC0000000) + fp_offset);
auto fpHash = HashFragmentProgram(fpData);
auto pipelineHash = hashStruct(pipeline) ^ vpHash ^ fpHash;
if (cachePipeline.find(pipelineHash) == cachePipeline.end()) {
const auto& p = pipeline;
if (cacheVP.find(vpHash) == cacheVP.end()) {
auto vp = std::make_unique<RSXVertexProgram>();
vp->decompile(vpData);
vp->compile(graphics.get());
cacheVP[vpHash] = std::move(vp);
}
if (cacheFP.find(fpHash) == cacheFP.end()) {
auto fp = std::make_unique<RSXFragmentProgram>();
fp->decompile(fpData);
fp->compile(graphics.get());
cacheFP[fpHash] = std::move(fp);
}
gfx::PipelineDesc pipelineDesc = {};
pipelineDesc.formatDSV = convertFormat(surface.depthFormat);
pipelineDesc.numCBVs = 2;
pipelineDesc.numSRVs = RSX_MAX_TEXTURES;
pipelineDesc.vs = cacheVP[vpHash]->shader;
pipelineDesc.ps = cacheFP[fpHash]->shader;
pipelineDesc.rsState.fillMode = gfx::FILL_MODE_SOLID;
pipelineDesc.rsState.cullMode = p.cull_face_enable ? convertCullMode(p.cull_mode) : gfx::CULL_MODE_NONE;
pipelineDesc.rsState.frontCounterClockwise = convertFrontFace(p.front_face);
pipelineDesc.rsState.depthEnable = p.depth_test_enable;
pipelineDesc.rsState.depthWriteMask = p.depth_mask ? gfx::DEPTH_WRITE_MASK_ALL : gfx::DEPTH_WRITE_MASK_ZERO;
pipelineDesc.rsState.depthFunc = convertCompareFunc(p.depth_func);
pipelineDesc.rsState.stencilEnable = p.stencil_test_enable;
pipelineDesc.rsState.stencilReadMask = p.stencil_func_mask;
pipelineDesc.rsState.stencilWriteMask = p.stencil_mask;
pipelineDesc.rsState.frontFace.stencilOpFail = convertStencilOp(p.stencil_op_fail);
pipelineDesc.rsState.frontFace.stencilOpZFail = convertStencilOp(p.stencil_op_zfail);
pipelineDesc.rsState.frontFace.stencilOpPass = convertStencilOp(p.stencil_op_zpass);
pipelineDesc.rsState.frontFace.stencilFunc = convertCompareFunc(p.stencil_func);
if (p.two_sided_stencil_test_enable) {
pipelineDesc.rsState.backFace.stencilOpFail = convertStencilOp(p.stencil_op_fail);
pipelineDesc.rsState.backFace.stencilOpZFail = convertStencilOp(p.stencil_op_zfail);
pipelineDesc.rsState.backFace.stencilOpPass = convertStencilOp(p.stencil_op_zpass);
pipelineDesc.rsState.backFace.stencilFunc = convertCompareFunc(p.stencil_func);
} else {
pipelineDesc.rsState.backFace.stencilOpFail = convertStencilOp(p.back_stencil_op_fail);
pipelineDesc.rsState.backFace.stencilOpZFail = convertStencilOp(p.back_stencil_op_zfail);
pipelineDesc.rsState.backFace.stencilOpPass = convertStencilOp(p.back_stencil_op_zpass);
pipelineDesc.rsState.backFace.stencilFunc = convertCompareFunc(p.back_stencil_func);
}
pipelineDesc.cbState.colorTarget[0].enableBlend = p.blend_enable;
pipelineDesc.cbState.colorTarget[0].enableLogicOp = p.logic_op_enable;
pipelineDesc.cbState.colorTarget[0].blendOp = convertBlendOp(p.blend_equation_rgb);
pipelineDesc.cbState.colorTarget[0].blendOpAlpha = convertBlendOp(p.blend_equation_alpha);
pipelineDesc.cbState.colorTarget[0].srcBlend = convertBlend(p.blend_sfactor_rgb);
pipelineDesc.cbState.colorTarget[0].destBlend = convertBlend(p.blend_dfactor_rgb);
pipelineDesc.cbState.colorTarget[0].srcBlendAlpha = convertBlend(p.blend_sfactor_alpha);
pipelineDesc.cbState.colorTarget[0].destBlendAlpha = convertBlend(p.blend_dfactor_alpha);
pipelineDesc.cbState.colorTarget[0].colorWriteMask = convertColorMask(p.color_mask);
pipelineDesc.cbState.colorTarget[0].logicOp = convertLogicOp(p.logic_op);
pipelineDesc.iaState.topology = convertPrimitiveTopology(primitive);
for (U32 index = 0; index < RSX_MAX_VERTEX_INPUTS; index++) {
const auto& attr = vpe.attr[index];
if (!attr.size) {
continue;
}
gfx::Format format = convertVertexFormat(attr.type, attr.size);
U32 stride = attr.stride;
pipelineDesc.iaState.inputLayout.push_back({
index, format, index, 0, stride, 0, gfx::INPUT_CLASSIFICATION_PER_VERTEX, 0 }
);
}
for (U32 i = 0; i < RSX_MAX_TEXTURES; i++) {
gfx::Sampler sampler = {};
sampler.filter = gfx::FILTER_MIN_MAG_MIP_LINEAR;
sampler.addressU = gfx::TEXTURE_ADDRESS_MIRROR;
sampler.addressV = gfx::TEXTURE_ADDRESS_MIRROR;
sampler.addressW = gfx::TEXTURE_ADDRESS_MIRROR;
pipelineDesc.samplers.push_back(sampler);
}
cachePipeline[pipelineHash] = std::unique_ptr<gfx::Pipeline>(graphics->createPipeline(pipelineDesc));
}
heapResources->reset();
heapResources->pushVertexBuffer(vpeConstantMemory);
heapResources->pushVertexBuffer(vtxTransform);
// Upload VPE constants if necessary
void* constantsPtr = vpeConstantMemory->map();
memcpy(constantsPtr, &vpe.constant, sizeof(vpe.constant));
vpeConstantMemory->unmap();
// Upload vertex transform matrix if necessary
if (vertex_transform_dirty) {
V128* transformPtr = reinterpret_cast<V128*>(vtxTransform->map());
memset(transformPtr, 0, 4 * sizeof(V128));
F32 half_cliph = surface.width / 2.0f;
F32 half_clipv = surface.height / 2.0f;
transformPtr[0].f32[0] = (viewport_scale.f32[0] / half_cliph);
transformPtr[1].f32[1] = (viewport_scale.f32[1] / half_clipv);
transformPtr[2].f32[2] = (viewport_scale.f32[2]);
transformPtr[0].f32[3] = (viewport_offset.f32[0] - half_cliph) / half_cliph;
transformPtr[1].f32[3] = (viewport_offset.f32[1] - half_clipv) / half_clipv;
transformPtr[2].f32[3] = (viewport_offset.f32[2]);
transformPtr[3].f32[3] = 1.0f;
vtxTransform->unmap();
}
// Set textures
for (U32 i = 0; i < RSX_MAX_TEXTURES; i++) {
const auto& tex = texture[i];
// Dummy texture
if (!tex.enable) {
gfx::TextureDesc texDesc = {};
texDesc.width = 2;
texDesc.height = 2;
texDesc.format = gfx::FORMAT_R8G8B8A8_UNORM;
texDesc.mipmapLevels = 1;
texDesc.swizzle = TEXTURE_SWIZZLE_ENCODE(
gfx::TEXTURE_SWIZZLE_VALUE_0,
gfx::TEXTURE_SWIZZLE_VALUE_0,
gfx::TEXTURE_SWIZZLE_VALUE_0,
gfx::TEXTURE_SWIZZLE_VALUE_0
);
gfx::Texture* texDescriptor = graphics->createTexture(texDesc);
heapResources->pushTexture(texDescriptor);
}
// Upload real texture
else {
auto texFormat = static_cast<TextureFormat>(tex.format & ~RSX_TEXTURE_LN & ~RSX_TEXTURE_UN);
gfx::TextureDesc texDesc = {};
texDesc.data = memory->ptr<Byte>((tex.location ? rsx->get_ea(0x0) : 0xC0000000) + tex.offset);
texDesc.size = tex.width * tex.height;
texDesc.width = tex.width;
texDesc.height = tex.height;
texDesc.format = convertTextureFormat(texFormat);
texDesc.mipmapLevels = tex.mipmap;
texDesc.swizzle = convertTextureSwizzle(texFormat);
switch (texFormat) {
case RSX_TEXTURE_B8: texDesc.size *= 1; break;
case RSX_TEXTURE_A1R5G5B5: texDesc.size *= 2; break;
case RSX_TEXTURE_A4R4G4B4: texDesc.size *= 2; break;
case RSX_TEXTURE_R5G6B5: texDesc.size *= 2; break;
case RSX_TEXTURE_A8R8G8B8: texDesc.size *= 4; break;
default:
assert_always("Unimplemented");
}
gfx::Texture* texDescriptor = graphics->createTexture(texDesc);
heapResources->pushTexture(texDescriptor);
}
}
cmdBuffer->cmdBindPipeline(cachePipeline[pipelineHash].get());
cmdBuffer->cmdSetHeaps({ heapResources });
cmdBuffer->cmdSetDescriptor(0, heapResources, 0);
cmdBuffer->cmdSetDescriptor(1, heapResources, 2);
cmdBuffer->cmdSetPrimitiveTopology(convertPrimitiveTopology(primitive));
}
// Overloaded Constructor
Intersection::Intersection(Surface *surface, Point3 intersectionPoint, double t)
{
setSurface(surface);
setIntersectionPoint(intersectionPoint);
setT(t);
}
void CanvasContext::updateSurface(ANativeWindow* window) {
setSurface(window);
}
Surface::Surface(SDL_Surface *s) : _surface(0)
{
setSurface(s);
// _surface = s;
// s->refcount++;
}
void CanvasContext::swapBuffers() {
if (CC_UNLIKELY(!mEglManager.swapBuffers(mEglSurface))) {
setSurface(NULL);
}
mHaveNewSurface = false;
}
BulletWeapon:: BulletWeapon(UnitID &owner, unsigned short owner_type_id, unsigned short damage, iXY &start, iXY &end)
: Weapon(owner, owner_type_id, damage, start, end)
{
setSurface();
}
