PixelKit -Download - PixelKit Quellcode Download

Schauen Sie sich Asyncgraphics an.
Inspiriert von Pixelkit & Renderkit.

Pixelkit

Live -Grafiken für iOS, MacOS und TVOS
Läuft auf Renderkit, angetrieben von Metall

Pixelkit kombiniert benutzerdefinierte Shader, Metall-Performance-Shader, Kernbildfilter und Vision, um Tools für das Rendering in Echtzeit zu erstellen.

Beispiele: Kameraeffekte - grüner Bildschirm
Info: Space Coordinate - Mischbetreiber - Effekt Convenience Funcs - High -Bit -Modus


Camerapix	Tiefenkamerapix	ImagePix	Videopix	ScreencapturePix	Streaminpix	Slopepix


Colorpix	Circlepix	Rechteck	Polygonpix	Arcpix	Linepix	GradientPix	Stackpix


Noisepix	TextPix	Metalpix	Twirlpix	Feedbackpix	Verzögerung	Sharpenpix	Streamoutpix


Levelspix	Blurpix	Edgepix	Schwellenwertpix	Quantizepix	Transformpix	Kaleidoskopepix


ChannelMixpix	Chromakeypix	Cornerpinpix	ColorShiftpix	Flipfloppix	RangePix	Starpix


Sepiapix	Convertpix	Recordpix	Clamppix	Freepix	Flarepix	AirPlaypix	RecordPix


Blendpix	Crossspix	Lookuppix	Verdrängung	Remappix	Reorderpix	Auflösungpix	Croppix


BlendSpix	Lumalevelspix	Lumablurpix	Lumatransformpix	Timemachinepix	Arraypix

Installieren

Schnellpaket

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

Aufstellen

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

Auflösung

In Pixelkit haben alle Bilder eine Auflösung. Einige Bilder haben Auflösungen definiert (standardmäßig .auto ) und einige Bilder haben Auflösungen abgeleitet.

Die Auflösung .auto füllt die Ansicht und erhält die richtige Auflösung basierend auf der Ansichtsgröße. Wenn eine Ansicht 100x100 Punkte beträgt, beträgt die Auflösung 200x200 Pixel auf MacOS und 300 x 300 Pixel auf dem iPhone.

Importieren Sie das Resolutionspaket, um mit Auflösungen zu arbeiten:

import Resolution

Sie können die Auflösungen mit einem CGFloat oder Int multiplizieren und teilen.

Es gibt vordefinierte Auflösungen wie ._1080p & ._4K .

Bild gemacht

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

Beispiel: Kameraeffekte

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

Dies kann auch mit Effektfunktionen erfolgen:

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

NSCameraUsageDescription

Beispiel: grüner Bildschirm

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 )

Dies kann auch mit Mischbetreibern und Effektfunktionen erfolgen:

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

Beispiel: Tiefenkamera

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 )

Das DepthCameraPIX wurde in Pixelkit v0.8.4 hinzugefügt und benötigt ein iPhone X oder neuer.

Hinweis, um das setup(with:filter:) Methode der DepthCameraPIX .
Es wird sich um Orientierung, Farbe und die Tiefe des CameraPIX ermöglichen.

Zu Zugang zu Tiefenwerten zu erhalten, OUSIDE der 0,0- und 1,0 Grenzen,
Aktivieren Sie 16 bit -Modus wie diesen: PixelKit.main.render.bits = ._16

Beispiel: Multi -Kamera

 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 )

Hinweis MultiCameraPIX erfordert iOS 13.

Raum koordinieren

Der Pixelkit -Koordinatenraum wird mit dem Ursprung (0,0, 0,0) in der Mitte an die vertikale Achse (1,0 in Höhe) normiert.
Beachten Sie, dass die vertikale Achse im Vergleich zu nativen UIKIT- und Swiftui -Ansichten umgedreht wird und der Ursprung bewegt wird. Dies ist bei der Arbeit mit Grafiken in Pixelkit konkurrierlicher. Eine vollständige Rotation wird durch 1.0 definiert

Mitte: cgpoint (x: 0, y: 0)
Unten links: CGPoint (x: -0,5 * Aspektratio, y: -0,5)
Oben rechts: CGPoint (x: 0,5 * Aspektratio, Y: 0,5)

Tipp: Resolution hat ein .aspect -Eigentum:
let aspectRatio: CGFloat = Resolution._1080p.aspect

Mischbetreiber

Eine schnelle und bequeme Möglichkeit, Bilder zu mischen
Dies sind die unterstützten BlendingMode -Operatoren:

`&`	`!&`	`+`	`-`	`*`	`**`	`!**`	`%`	`~`	`°`
.über	.unter	.hinzufügen	.subtrahieren	.multiplizieren	.Leistung	.Gamma	.Unterschied	.Durchschnitt	Kosinus

`<>`	`><`	`++`	`--`	`<->`	`>-<`	`+-+`
.Minimum	.maximal	.AddWithalpha	.SubtractWithalpha	innen	draußen	Exklusiver

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

Der Standard -Global Blend Operator Fill -Modus ist .fit , ändern Sie ihn wie folgt:
PIX.blendOperators.globalPlacement = .fill

Effekt Convenience -Funcs

.pixScalereSolution (bis: ._1080p * 0.5) -> Auflösungspix
.pixScalereSolution (von: 0,5) -> Auflösungspix
.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 (bei: 0,5) -> Schwellenwertpix
.pixquantize (von: 0,5) -> quantizepix
.pixPosition (at: cgpoint (x: 0,5, y: 0,5) -> transformpix
.pixrotatat (von: 0,5) -> TransformPix
.pixrotatat (Byradianer: .pi) -> Transformpix
.pixrotatat (byDegrees: 180) -> Transformpix
.pixscale (von: 0.5) -> TransformPix
.pixkaleidoscope () -> kaleidoscopepix
.pixtWirl (0,5) -> Twirlpix
.pixswap (.red, .Blue) -> ChannelMixPix
.pixchromakey (.green) -> chromakeypix
.Pixhue (0,5) -> ColorShiftpix
.PixSaturation (0,5) -> ColorShiftpix
.pixcrop (CGRECT (x: 0,25, y 0,25, Breite: 0,5, Höhe: 0,5) -> Croppix
.pixflipx () -> Flipfloppix
.pixflipy () -> Flipfloppix
.pixflopleft () -> FliPloppix
.pixflopright () -> Flipfloppix
.pixrange (Inlow: 0,0, inheitet: 0,5, Outlow: 0,5, Suithigh: 1,0) -> RangePix
.pixrange (Inlow: .Clear, Inhail: .Gray, Outlow: .gray, Outhigh: .White) -> RangePix
.pixsharpen () -> scharfepix
.pixslope () -> slopepix
.Pixvignettierung (Radius: 0,5, Einschub: 0,25, Gamma: 0,5) -> Lumalevelspix
.pixlookup (pix: pixb, axis: .x) -> Lookuppix
.pixlumablur (pix: pixb, radius: 0,5) -> lumablurpix
.pixlumalevels (pix: pixb, Helligkeit: 2.0) -> lumalevelspix
.pixDisport
.pixremap (pix: pixb) -> remappix

Denken Sie daran, dass diese Funcs neue Bilder erstellen.
Achten Sie darauf, dass das GPU -Speicher überlastet wird. Einige Funcs erstellen mehrere Bilder.

Hochbitmodus

Einige Effekte wie Verschiebung und Slopepix können von einer höheren Bit -Tiefe profitieren.
Die Standardeinstellung beträgt 8 Bit. Ändern Sie es so: PixelKit.main.render.bits = ._16

Aktivieren Sie den hohen Bitmodus, bevor Sie Bilder erstellen.

Beachten Sie, dass Ressourcen noch keine höheren Bits unterstützen.
Derzeit gibt es einen Gamma -Offset mit Ressourcen.

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 " ) ]

Uniformen:

 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

Anmerkungen:

Überprüfen Sie die Kamera in der App Sandbox in Ihren XCode -Projekteinstellungen unter den Funktionen, um Kamerazugriff auf MacOS zu erhalten.

Inspiriert von TouchDesigner, erstellt von Anton Heestand XYZ

Expandieren

PixelKit

Pixelkit

Installieren

Schnellpaket

Aufstellen

Swiftui

Uikit

Auflösung

Bild gemacht

Beispiel: Kameraeffekte

Beispiel: grüner Bildschirm

Beispiel: Tiefenkamera

Beispiel: Multi -Kamera

Raum koordinieren

Mischbetreiber

Effekt Convenience -Funcs

Hochbitmodus

Metalpixs

Uniformen:

Anmerkungen:

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