Download do PixelKit - Download do código fonte PixelKit

Confira assíncrofics.
Inspirado por Pixelkit & Renderkit.

Pixelkit

Gráficos ao vivo para iOS, macOS e tvOS
Corre no renderkit, alimentado por metal

O Pixelkit combina shaders personalizados, shaders de desempenho de metal, filtros de imagem centrais e visão para criar ferramentas para renderização em tempo real.

Exemplos: efeitos da câmera - tela verde
Info: Coordenar Space - Operadores de mistura - Funcs de conveniência de efeito - Modo de bit alto


Camerapix	Depthcamerapix	ImagePix	Videopix	ScreencapturePix	Streaminpix	Slopepix


Colorpix	Circlepix	Rectanglepix	Polygonpix	Arcpix	Linepix	Gradientepix	Stackpix


Noisepix	Textpix	MetalPix	Twirlpix	Feedbackpix	Atrasopix	SharpEnpix	Streamoutpix


Nível de nível	Blurpix	Edgepix	Limite do	Quantizepix	Transformpix	Kaleidoscopepix


ChannelMixpix	Chomakeypix	Cornerpinpix	ColorShiftpix	Flipfloppix	Rangepix	Starpix


Sepiapix	Convertpix	Reducepix	CLAMPPIX	Freezepix	Flarepix	AirPlayPix	Recordpix


Blendpix	Crosspix	Lookuppix	DiplacePix	Remappix	Reordenarpix	Resoluçãopix	Croppix


Blendspix	LumalevelSpix	Lumablurpix	Lumatransformpix	TimemachinePix	Arraypix

Instalar

Pacote Swift

 . package ( url : " https://github.com/heestand-xyz/PixelKit " , from : " 3.0.0 " )

Configurar

Swiftui

import SwiftUI
import PixelKit

struct ContentView : View {
    
    @ StateObject var circlePix = CirclePIX ( )
    @ StateObject var blurPix = BlurPIX ( )
    
    var body : some View {
        PixelView ( pix : blurPix )
            . onAppear {
                blurPix . input = circlePix
                blurPix . radius = 0.25
            }
    }
}

Uikit

import UIKit
import PixelKit

class ViewController : UIViewController {

    override func viewDidLoad ( ) {
        super . viewDidLoad ( )

        let circlePix = CirclePIX ( )

        let blurPix = BlurPIX ( )
        blurPix . input = circlePix
        blurPix . radius = 0.25

        let finalPix : PIX = blurPix
        finalPix . view . frame = view . bounds
        view . addSubview ( finalPix . view )
    }
}

Resolução

No Pixelkit, todos os pixs têm uma resolução. Alguns pixs definiram resoluções (padrão para .auto ) e alguns pixs derivaram resoluções.

A resolução .auto preencherá a visualização e obterá a resolução correta com base no tamanho da visualização. Se uma visualização for de 100x100 pontos, a resolução será de 200x200 pixels no macOS e 300x300 pixels no iPhone.

Importe o pacote de resolução para trabalhar com resoluções:

import Resolution

Você pode multiplicar e dividir resoluções com um CGFloat ou Int .

Existem resoluções predefinidas como ._1080p & ._4K .

Imagem renderizada

 . renderedImage // UIImage or NSImage
. renderedTexture // MTLTexture

Exemplo: efeitos da câmera

import SwiftUI
import PixelKit

class ViewModel : ObservableObject {
    
    let camera : CameraPIX
    let levels : LevelsPIX
    let colorShift : ColorShiftPIX
    let blur : BlurPIX
    let circle : CirclePIX
    
    let finalPix : PIX
    
    init ( ) {
        
        camera = CameraPIX ( )
        camera . cameraResolution = . _1080p

        levels = LevelsPIX ( )
        levels . input = camera
        levels . brightness = 1.5
        levels . gamma = 0.5

        colorShift = ColorShiftPIX ( )
        colorShift . input = levels
        colorShift . saturation = 0.5

        blur = BlurPIX ( )
        blur . input = colorShift
        blur . radius = 0.25

        circle = CirclePIX ( at : . square ( 1080 ) )
        circle . radius = 0.45
        circle . backgroundColor = . clear

        finalPix = blur & ( camera * circle )
    }
}

struct ContentView : View {
    
    @ StateObject var viewModel = ViewModel ( )
    
    var body : some View {
        PixelView ( pix : viewModel . finalPix )
    }
}

Isso também pode ser feito com efeitos de funções de conveniência:

 let pix = CameraPIX ( ) . pixBrightness ( 1.5 ) . pixGamma ( 0.5 ) . pixSaturation ( 0.5 ) . pixBlur ( 0.25 )

Lembre -se de adicionar NSCameraUsageDescription à sua info.plist

Exemplo: tela verde

import RenderKit import PixelKit

 let cityImage = ImagePIX ( )
cityImage . image = UIImage ( named : " city " )

let supermanVideo = VideoPIX ( )
supermanVideo . load ( fileNamed : " superman " , withExtension : " mov " )

let supermanKeyed = ChromaKeyPIX ( )
supermanKeyed . input = supermanVideo
supermanKeyed . keyColor = . green

let blendPix = BlendPIX ( )
blendPix . blendingMode = . over
blendPix . inputA = cityImage
blendPix . inputB = supermanKeyed

let finalPix : PIX = blendPix
finalPix . view . frame = view . bounds
view . addSubview ( finalPix . view )

Isso também pode ser feito com operadores de mistura e funções de conveniência de efeito:

 let pix = cityImage & supermanVideo . pixChromaKey ( . green )

Exemplo: câmera de profundidade

import RenderKit import PixelKit

 let cameraPix = CameraPIX ( )
cameraPix . camera = . front

let depthCameraPix = DepthCameraPIX . setup ( with : cameraPix )

let levelsPix = LevelsPIX ( )
levelsPix . input = depthCameraPix
levelsPix . inverted = true

let lumaBlurPix = cameraPix . pixLumaBlur ( pix : levelsPix , radius : 0.1 )

let finalPix : PIX = lumaBlurPix
finalPix . view . frame = view . bounds
view . addSubview ( finalPix . view )

O DepthCameraPIX foi adicionado no Pixelkit v0.8.4 e requer um iPhone X ou mais recente.

Nota para usar a setup(with:filter:) Método de DepthCameraPIX .
Ele cuidará da orientação, cor e permitirá profundidade na CameraPIX .

Para obter acesso a valores de profundidade, ouside dos limites 0,0 e 1,0,
Habilite o modo 16 bit como este: PixelKit.main.render.bits = ._16

Exemplo: câmera multi

 let cameraPix = CameraPIX ( )
cameraPix . camera = . back

let multiCameraPix = MultiCameraPIX . setup ( with : cameraPix , camera : . front )

let movedMultiCameraPix = multiCameraPix . pixScale ( by : 0.25 ) . pixTranslate ( x : 0.375 * ( 9 / 16 ) , y : 0.375 )

let finalPix : PIX = camearPix & movedMultiCameraPix
finalPix . view . frame = view . bounds
view . addSubview ( finalPix . view )

NOTA MultiCameraPIX Requer iOS 13.

Coordenar o espaço

O espaço de coordenadas do pixelkit é normailzado no eixo vertical (1,0 de altura) com a origem (0,0, 0,0) no centro.
Observe que, em comparação com as visualizações nativas do UIKIT e do SwiftUi, o eixo vertical é invertido e a origem é movida, isso é mais condenado ao trabalhar com gráficos no Pixelkit. Uma rotação completa é definida por 1.0

Centro: CGPoint (x: 0, y: 0)
Inferior esquerdo: cgpoint (x: -0,5 * aspetratio, y: -0.5)
Superior direito: CGPoint (x: 0,5 * Aspetratio, y: 0,5)

Dica: Resolution possui uma propriedade .aspect :
let aspectRatio: CGFloat = Resolution._1080p.aspect

Operadores de mistura

Uma maneira rápida e conveniente de misturar pixs
Estes são os operadores suportados BlendingMode :

`&`	`!&`	`+`	`-`	`*`	`**`	`!**`	`%`	`~`	`°`
.sobre	.sob	.adicionar	.subtrair	.multiplicar	.poder	.gama	.diferença	.média	cosseno

`<>`	`><`	`++`	`--`	`<->`	`>-<`	`+-+`
.mínimo	.máximo	.Addwithalpha	.Subtractwithalpha	dentro	fora	exclusivo

 let blendPix = ( CameraPIX ( ) !** NoisePIX ( at : . fullHD ( . portrait ) ) ) * CirclePIX ( at : . fullHD ( . portrait ) )

O modo de preenchimento do operador de mistura global padrão é .fit , mude assim:
PIX.blendOperators.globalPlacement = .fill

Funcs de conveniência de efeito

.PIXSCaleResolution (para: ._1080p * 0.5) -> Resoluçãopix
.PIXSCALeResolution (por: 0,5) -> Resoluçãopix
.pixbrightness (0,5) -> Levelspix
.PixDarkness (0,5) -> LevelSpix
.pixContrast (0,5) -> LevelSpix
.pixgamma (0,5) -> LevelSpix
.pixInvert () -> LevelSpix
.PixOpacity (0,5) -> LevelSpix
.pixblur (0,5) -> Blurpix
.pixedge () -> EdgePix
.pixthreshold (em: 0,5) -> limite
.pixquantize (por: 0.5) -> quantizepix
.pixPosition (at: cgpoint (x: 0,5, y: 0,5)) -> transformpix
.pixrotatate (por: 0.5) -> transformpix
.pixrotatate (byradianos: .pi) -> transformpix
.pixrotatate (Bydegrees: 180) -> TransformPix
.PixSCale (por: 0.5) -> Transformpix
.pixkaleidoscope () -> kaleidoscopepix
.pixtwirl (0,5) -> Twirlpix
.pixswap (.red, .blue) -> ChannelMixpix
.pixchromakey (.green) -> Chomakeypix
.pixhue (0,5) -> colorShiftpix
.pixsaturation (0,5) -> colorShiftpix
.pixcrop (CGrect (x: 0,25, y 0,25, largura: 0,5, altura: 0,5)) -> CropPix
.pixflipx () -> flipfloppix
.pixflipy () -> flipfloppix
.pixflopleft () -> flipfloppix
.pixfLOPRIRT () -> FLIPFLOPPIX
.pixRange (Inlow: 0.0, inight: 0.5, Outlow: 0.5, Ethigh: 1.0) -> RangePix
.pixRange (inlow: .clear, inight: .gray, Outlow: .gray, Ethigh: .white) -> rangepix
.pixSharpen () -> SharpEnpix
.pixslope () -> slopepix
.pixvignetting (raio: 0,5, inserção: 0,25, gama: 0,5) -> LumalevelSpix
.pixlookup (pix: pixb, eixo: .x) -> lookuppix
.pixlumablur (pix: pixb, raio: 0.5) -> lumablurpix
.pixlumalevels (pix: pixb, brilho: 2.0) -> lumalevelspix
.pixdisplace (pix: pixb, distância: 0,5) -> deslocespix
.pixRemap (PIX: PIXB) -> Remappix

Lembre -se de que essas funções criarão novos pixs.
Tenha cuidado ao sobrecarregar a memória da GPU, algumas funcas criam vários pixs.

Modo de bit alto

Alguns efeitos como o DipplacePix e o Slopepix podem se beneficiar de uma profundidade de bits mais alta.
O padrão é de 8 bits. Mude assim: PixelKit.main.render.bits = ._16

Habilite o modo de bit alto antes de criar pixs.

Nota Os recursos ainda não suportam bits mais altos.
Atualmente, existe algum deslocamento gama com recursos.

MetalPixs

 let metalPix = MetalPIX ( at : . _1080p , code :
    """
    pix = float4(u, v, 0.0, 1.0);
    """
)

 let metalEffectPix = MetalEffectPIX ( code :
    """
    float gamma = 0.25;
    pix = pow(input, 1.0 / gamma);
    """
)
metalEffectPix . input = CameraPIX ( )

 let metalMergerEffectPix = MetalMergerEffectPIX ( code :
    """
    pix = pow(inputA, 1.0 / inputB);
    """
)
metalMergerEffectPix . inputA = CameraPIX ( )
metalMergerEffectPix . inputB = ImagePIX ( " img_name " )

 let metalMultiEffectPix = MetalMultiEffectPIX ( code :
    """
    float4 inPixA = inTexs.sample(s, uv, 0);
    float4 inPixB = inTexs.sample(s, uv, 1);
    float4 inPixC = inTexs.sample(s, uv, 2);
    pix = inPixA + inPixB + inPixC;
    """
)
metalMultiEffectPix . inputs = [ ImagePIX ( " img_a " ) , ImagePIX ( " img_b " ) , ImagePIX ( " img_c " ) ]

Uniformes:

 var lumUniform = MetalUniform ( name : " lum " )
let metalPix = MetalPIX ( at : . _1080p , code :
    """
    pix = float4(in.lum, in.lum, in.lum, 1.0);
    """ ,
    uniforms : [ lumUniform ]
)
lumUniform . value = 0.5

Notas:

Para obter acesso à câmera, no macOS, verifique a câmera no aplicativo Sandbox nas configurações do projeto Xcode em recursos.

Inspirado por TouchDesigner criado por Anton Heestand XYZ

Expandir

PixelKit

Pixelkit

Instalar

Pacote Swift

Configurar

Swiftui

Uikit

Resolução

Imagem renderizada

Exemplo: efeitos da câmera

Exemplo: tela verde

Exemplo: câmera de profundidade

Exemplo: câmera multi

Coordenar o espaço

Operadores de mistura

Funcs de conveniência de efeito

Modo de bit alto

MetalPixs

Uniformes:

Notas:

Google Dorks

shepherd

mongo express

hidusbf

Free Algorithms Books

markdownpedia

chat.petals.dev

GPT Prompt Templates

GPTyped

Google Dorks

shepherd

mongo express

Google Dorks

shepherd

mongo express