PixelKit Télécharger - Téléchargement du code source de PixelKit

Découvrez Asyncgraphics.
Inspiré par Pixelkit & Renderkit.

Pixelkit

Graphiques en direct pour iOS, macOS et TVOS
Fonctionne sur Renderkit, alimenté par le métal

Pixelkit combine des shaders personnalisés, des shaders de performances métalliques, des filtres d'image de base et de la vision pour créer des outils pour le rendu en temps réel.

Exemples: Effets de la caméra - Écran vert
Info: Coordonne Space - Mélanger les opérateurs - Fonction de commodité à effet - Mode bit élevé


Camerapix	De profondeur	ImagePix	Videopixe	ScreencapturePix	Streampix	Salin


Colon	Pix de cercle	Rectanglepix	Polygonpix	Arcpix	Ligne de ligne	Gradientpix	Pix


Bruits	Textpix	Metal-tin	Tourbillon	FeedbackPix	Tablier	Affliger	Streamoutpix


Niveau	Flou	Poix	Seuil	Quanzizix	Transformpix	Kaléidoscopepix


Canalmixpix	Chromakeypix	Cornerpinpix	ColorShiftPix	Flipfloppix	Gamme	Étoiles


Sepiapix	Convertissant	Réduction	Clampix	Congélation	Flarepix	AirPlayPix	Record


Mélange	Croisement	Lookuppix	Déplacer	Remappix	Réorganiser	ResolutionPix	Crop-Capix


Mixage	Lumalevelspix	Lumablurpix	Lumatransformpix	TimeMachinePix	Arraypix

Installer

Package rapide

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

Installation

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

Résolution

Dans Pixelkit, tous les pix ont une résolution. Certains Pix ont défini des résolutions (par défaut à .auto ) et certaines pix ont dérivé des résolutions.

La résolution .auto remplira la vue et obtiendra la résolution correcte en fonction de la taille de la vue. Si une vue est de 100x100 points, la résolution sera de 200x200 pixels sur macOS et 300x300 pixels sur iPhone.

Importez le package de résolution pour travailler avec les résolutions:

import Resolution

Vous pouvez multiplier et diviser les résolutions avec un CGFloat ou Int .

Il existe des résolutions prédéfinies comme ._1080p & ._4K .

Image rendue

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

Exemple: effets de la caméra

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

Cela peut également être fait avec des fonctions de commodité d'effet:

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

Remeber pour ajouter NSCameraUsageDescription à votre info.plist

Exemple: écran vert

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 )

Cela peut également être fait avec des opérateurs de mélange et des fonctions de commodité à effet:

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

Exemple: appareil photo en profondeur

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 a été ajoutée dans Pixelkit v0.8.4 et nécessite un iPhone X ou plus récent.

Remarque pour utiliser la setup(with:filter:) Méthode de DepthCameraPIX .
Il s'occupera de l'orientation, de la couleur et de la profondeur de la profondeur sur le CameraPIX .

Pour accéder aux valeurs de profondeur ouide des limites de 0,0 et 1,0,
Activer le mode 16 bit comme ceci: PixelKit.main.render.bits = ._16

Exemple: plusieurs caméras

 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 )

Remarque MultiCameraPIX nécessite iOS 13.

Coordonner l'espace

L'espace de coordonnées Pixelkit est normal à l'axe vertical (1,0 de hauteur) avec l'origine (0,0, 0,0) au centre.
Notez que par rapport à l'Uikit natif et Swiftui visualise, l'axe vertical est retourné et l'origine est déplacée, ceci est plus convertisse lorsque vous travaillez avec des graphiques dans Pixelkit. Une rotation complète est définie par 1.0

Centre: CGPoint (X: 0, Y: 0)
En bas à gauche: CGPoint (x: -0,5 * Aspectratio, Y: -0,5)
En haut à droite: CGPoint (x: 0,5 * Aspectratio, Y: 0,5)

Astuce: Resolution a une .aspect .
let aspectRatio: CGFloat = Resolution._1080p.aspect

Mélanger les opérateurs

Un moyen rapide et pratique de mélanger les pixes
Ce sont les opérateurs BlendingMode pris en charge:

`&`	`!&`	`+`	`-`	`*`	`**`	`!**`	`%`	`~`	`°`
.sur	.sous	.ajouter	.soustraire	.multiplier	.pouvoir	.gamma	.différence	.moyenne	cosinus

`<>`	`><`	`++`	`--`	`<->`	`>-<`	`+-+`
.minimum	.maximum	.Addithalpha	. Substractwithalpha	à l'intérieur	dehors	exclusif

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

Le mode de remplissage de l'opérateur de mélange global par défaut est .fit , changez-le comme ceci:
PIX.blendOperators.globalPlacement = .fill

Effet Funcs Funcs

.PixScaleResolution (à: ._1080p * 0,5) -> ResolutionPix
.PixScaleResolution (par: 0,5) -> ResolutionPix
.PixBrightness (0,5) -> NIVEALSPIX
.PixDarkness (0,5) -> NIVEALSPIX
.PixContrast (0,5) -> NIVEALSPIX
.PixGamma (0,5) -> NIVEALSPIX
.Pixinvert () -> NIVEALSPIX
.Pixopacity (0,5) -> niveaux
.pixBlur (0,5) -> Blurpix
.pixEdge () -> EdgePix
.PixThreshold (à: 0,5) -> ThresholdPix
.Pixquantize (par: 0,5) -> Quantizix
.PIXOSITION (AT: CGPOINT (X: 0,5, Y: 0,5)) -> TransformPix
.PixrotaTate (par: 0,5) -> transformpix
.Pixrotatate (Byradians: .pi) -> TransformPix
.PixrotaTate (bydegrees: 180) -> transformpix
.PixScale (par: 0,5) -> TransformPix
.pixkaleidoscope () -> kaleidoscoperpix
.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, largeur: 0,5, hauteur: 0,5)) -> Croppix
.pixflipx () -> flipfloppix
.pixflipy () -> flipfloppix
.pixflopleft () -> flipfloppix
.PixflompRight () -> flipfloppix
.PixRange (Inlow: 0,0, Inhigh: 0,5, Outlow: 0,5, outhigh: 1,0) -> RangePix
.PixRange (Inlow: .Clear, inhigh: .gray, Outlow: .gray, outhigh: .white) -> rangePix
.pixsharpen () -> SharpenPix
.Pixslope () -> SlovePix
.PIXVIGNTting (Radius: 0,5, encart: 0,25, gamma: 0,5) -> LumalevelSpix
.pixlookup (PIX: PIXB, axe: .x) -> lookuppix
.PixlumAblur (Pix: Pixb, rayon: 0,5) -> Lumablurpix
.Pixlumalevels (Pix: Pixb, luminosité: 2.0) -> LumalevelSpix
.PixDisplace (PIX: PIXB, Distance: 0,5) -> Déplacepix
.PixRemap (PIX: PIXB) -> Remappix

Gardez à l'esprit que ces funcs créeront de nouveaux pix.
Faites attention à surcharger la mémoire GPU, certaines funcs créent plusieurs pix.

Mode bit haut

Certains effets tels que les déplacepix et le salice peuvent bénéficier d'une profondeur de bit plus élevée.
La valeur par défaut est de 8 bits. Changez-le comme ceci: PixelKit.main.render.bits = ._16

Activez le mode bit haut avant de créer des pix.

Remarque Les ressources ne prennent pas encore en charge les bits plus élevés.
Il y a actuellement un compensation gamma avec les ressources.

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

Notes:

Pour obtenir un accès à la caméra, sur macOS, cochez la caméra dans l'application Sandbox dans les paramètres du projet Xcode sous Capacités.

Inspiré par TouchDesigner créé par Anton Heestand Xyz

Développer

PixelKit

Pixelkit

Installer

Package rapide

Installation

Swiftui

Uikit

Résolution

Image rendue

Exemple: effets de la caméra

Exemple: écran vert

Exemple: appareil photo en profondeur

Exemple: plusieurs caméras

Coordonner l'espace

Mélanger les opérateurs

Effet Funcs Funcs

Mode bit haut

Metalpixs

Uniformes:

Notes:

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