PixelKit

Echa un vistazo a AsyncGraphics.
Inspirado en Pixelkit & Renderkit.

Píxel

Gráficos en vivo para iOS, MacOS y TVOS
Corre en renderkit, alimentado por metal

Pixelkit combina sombreadores personalizados, sombreadores de rendimiento de metal, filtros de imagen central y visión para crear herramientas para la representación en tiempo real.

Ejemplos: Efectos de la cámara - pantalla verde
Información: Espacio de coordenadas - Operadores de mezcla - Funcs de conveniencia de efecto - Modo de bits alto

Camerapix	Profundidadcamerapix	ImagePix	Videopix	ScreencapturePix	Streaminpix	Slopepix

Colorpix	Circlepix	Rectángulo	Poligonpix	Arcpix	Linepix	Gradiente	Stackpix

Noisepix	Textpix	Metalpix	Twirlpix	TELETRYPIX	Retraso	Afilado	StreamOutpix

Espíritu de nivel	Blurpix	Costilla	Umbral	Cuantizepix	Transformpix	Kaleidoscopepix

ChannelMixpix	Cromakeypix	Cornerpinpix	ColorShiftpix	Flipfloppix	Rangepix	Starpix

Sepiapix	Convertpix	ReducePIX	Clamppix	Freezepix	Flarepix	Airplaypix	RecordPix

Blendpix	Espíritu	Lookuppix	Desplazamiento	Rehacer	Reordenarpix	Resoluciónpix	Cosecha

Blendspix	Lumalevelspix	Lumablurpix	Lumatransformpix	TimemachinePix	Arraypix

---

Instalar

Paquete rápido

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

Configuración

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 )
    }
} 

Resolución

En Pixelkit, todas las pixs tienen una resolución. Algunas PIX han definido resoluciones (predeterminados a .auto ) y algunas PIX han obtenido resoluciones.

La resolución .auto llenará la vista y obtendrá la resolución correcta en función del tamaño de la vista. Si una vista es de 100x100 puntos, la resolución será de 200x200 píxeles en macOS y 300x300 píxeles en iPhone.

Importar el paquete de resolución para trabajar con resoluciones:

import Resolution

Puede multiplicar y dividir las resoluciones con un CGFloat o Int .

Hay resoluciones predefinidas como ._1080p & ._4K .

Imagen renderizada

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

Ejemplo: efectos de la cámara

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 )
    }
}

Esto también se puede hacer con funciones de conveniencia de efecto:

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

Recuerdo para agregar NSCameraUsageDescription a su información.

Ejemplo: pantalla 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 )

Esto también se puede hacer con operadores de mezcla y efectuar funciones de conveniencia:

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

Ejemplo: cámara de profundidad

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 )

La DepthCameraPIX se agregó en Pixelkit v0.8.4 y requiere un iPhone X o más nuevo.

Nota Para usar el setup(with:filter:) Método de DepthCameraPIX .
Se encargará de la orientación, el color y habilitará la profundidad en el CameraPIX .

Para obtener acceso a los valores de profundidad de los límites 0.0 y 1.0,
Habilite el modo 16 bit como este: PixelKit.main.render.bits = ._16

Ejemplo: cámaras múltiples

 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 requiere iOS 13.

Espacio de coordenadas

El espacio de coordenadas de Pixelkit se norleza al eje vertical (1.0 de altura) con el origen (0.0, 0.0) en el centro.
Tenga en cuenta que en comparación con las vistas nativas de Uikit y Swiftui, el eje vertical se voltea y el origen se mueve, esto es más convinente cuando se trabaja con gráficos en Pixelkit. Una rotación completa se define por 1.0

Centro: CGPoint (X: 0, Y: 0)
Abajo a la izquierda: CGPoint (X: -0.5 * Aspectratio, Y: -0.5)
Arriba a la derecha: CGPoint (x: 0.5 * Aspectratio, Y: 0.5)

Consejo: Resolution tiene una propiedad .aspect :
let aspectRatio: CGFloat = Resolution._1080p.aspect

Operadores de mezcla

Una forma rápida y conveniente de mezclar las pixas
Estos son los operadores compatibles BlendingMode :

&	!&	+	-	*	**	!**	%	~	°
.	.bajo	.Add	.sustraer	.multiplicar	.fuerza	.gama	.diferencia	.	coseno

<>	><	++	--	<->	>-<	+-+
.minimum	.máximo	.addwithalpha	.Unuminación de Withalpha	adentro	afuera	exclusivo

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

El modo de relleno de operador de mezcla global predeterminado es .fit , cámbielo así:
PIX.blendOperators.globalPlacement = .fill

Efecto Funcs de conveniencia

• .pixscaleresolution (a: ._1080p * 0.5) -> ResolutionPix
• .pixscaleresolution (por: 0.5) -> ResolutionPix
• .pixbrightness (0.5) -> nivelspix
• .PixDarkness (0.5) -> LevelSpix
• .pixcontrast (0.5) -> nivelspix
• .pixgamma (0.5) -> nivelspix
• .pixinvert () -> nivelspix
• .pixopacity (0.5) -> nivelspix
• .pixblur (0.5) -> blurpix
• .pixedge () -> EdgePix
• .pixthreshold (en: 0.5) -> Threshesholdpix
• .pixquantize (por: 0.5) -> Quantizepix
• .pixposition (en: cgpoint (x: 0.5, y: 0.5)) -> transformpix
• .pixrotatate (por: 0.5) -> transformpix
• .pixrotatate (byradians: .pi) -> transformpix
• .pixrotatate (bydegrees: 180) -> transformpix
• .pixscale (por: 0.5) -> transformpix
• .pixkaleidoscope () -> Kaleidoscopepix
• .pixtwirl (0.5) -> twirlpix
• .pixswap (.red, .blue) -> ChannelMixpix
• .pixChromakey (.Green) -> ChromakeyPix
• .pixhue (0.5) -> ColorShiftpix
• .pixsaturación (0.5) -> ColorShiftpix
• .pixcrop (cgrect (x: 0.25, y 0.25, ancho: 0.5, altura: 0.5)) -> Croppix
• .pixflipx () -> flipfloppix
• .pixflipy () -> flipfloppix
• .pixflopleft () -> flipfloppix
• .pixflopright () -> flipfloppix
• .pixrange (Insown: 0.0, Inigh: 0.5, Outlow: 0.5, Outhigh: 1.0) -> RangePix
• .pixrange (Inlow: .clar, hhigh: .Gray, Outlow: .Gray, OUTHIGH: .White) -> RangePIX
• .pixsharpen () -> afilado
• .pixslope () -> slopepix
• .pixvignetting (radio: 0.5, recuadro: 0.25, gamma: 0.5) -> lumalevelspix
• .pixlookup (pix: pixb, eje: .x) -> Lookuppix
• .pixlumablur (pix: pixb, radio: 0.5) -> lumablurpix
• .pixlumalevels (pix: pixb, brillo: 2.0) -> lumalevelspix
• .pixdisplace (pix: pixb, distancia: 0.5) -> desplazepix
• .pixremap (pix: pixb) -> remappix

Tenga en cuenta que estos funciones crearán nuevas fotos.
Tenga cuidado de sobrecargar la memoria de GPU, algunas funciones crean varias fotos.

Modo de bits

Algunos efectos como DisplaCepix y Slopepix pueden beneficiarse de una profundidad de bits más alta.
El valor predeterminado es de 8 bits. Cambiarlo así: PixelKit.main.render.bits = ._16

Habilite el modo de bits alto antes de crear cualquier foto.

Nota Los recursos aún no admiten bits más altos.
Actualmente hay algunos compensados ​​gamma con 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 obtener acceso a la cámara, en macOS, verifique la cámara en la caja de arena de la aplicación en la configuración de su proyecto Xcode en capacidades.

---

Inspirado por TouchDesigner creado por Anton Heestand Xyz