홈페이지>프로그래밍 관련>기타 소스코드
다운로드

Asyncgraphics를 확인하십시오.
Pixelkit & Renderkit에서 영감을 얻었습니다.

픽셀 키트

iOS, MacOS 및 TVOS 용 라이브 그래픽
금속으로 구동되는 RenderKit에서 실행됩니다

Pixelkit은 사용자 정의 셰이더, 금속 성능 셰이더, 핵심 이미지 필터 및 비전을 결합하여 실시간 렌더링을위한 도구를 만듭니다.

예 : 카메라 효과 - 녹색 화면
정보 : 좌표 공간 - 혼합 연산자 - 효과 편의 기능 - 높은 비트 모드

카메라 픽스 Depthcamerapix ImagePix videopix ScreenCapturePix StreamInpix 슬로프 픽스
컬러 픽스 CirclePix 사각형 피스 Polygonpix 아크 픽스 라인 피스 Gradientpix 스택 픽스
Noisepix TextPix Metalpix TROWPIX 피드백 픽스 DelayPix 샤프 픽스 StreamOutpix
LevelSpix 블러 픽스 에지 픽스 임계 값 피스 QuantizePix 변환 픽스 kaleidoscopepix
ChannelMixPix ChromakeyPix Cornerpinpix ColorshiftPix flipfloppix RangePix 스타 픽스
Sepiapix ConvertPix 감소 클램프 픽스 freezepix Flarepix AirPlayPix 레코드 피스
블렌드 피스 크로스 픽스 Lookuppix 변위 재구성 재주문 Resolutionpix Croppix
Blendspix lumalevelspix lumablurpix lumatransformpix TimeMachinePix ArrayPix

설치하다

신속한 패키지 

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

설정

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

해결

Pixelkit에서 모든 픽스는 해상도를 가지고 있습니다. 일부 픽스는 해상도 (기본값으로 .auto )를 정의했으며 일부 픽스는 해상도를 도출했습니다.

.auto 해상도는보기를 채우고 뷰 크기에 따라 올바른 해상도를 얻습니다. 보기가 100x100 포인트 인 경우 해상도는 MacOS의 200x200 픽셀, iPhone의 300x300 픽셀입니다.

해상도 패키지를 가져와 해상도로 작동합니다. 

import Resolution

CGFloat 또는 Int 로 해상도를 곱하고 나눌 수 있습니다.

._1080p & ._4K 와 같은 사전 정의 된 해상도가 있습니다.

렌더링 된 이미지 

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

예 : 카메라 효과 

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

효과적인 편의 기능으로 수행 할 수도 있습니다. 

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

귀하의 info.plist 에 NSCameraUsageDescription 추가하려면 Remeber

예 : 녹색 화면

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 )

이것은 블렌드 연산자와 편의를 효과적으로 수행 할 수 있습니다. 

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

예 : 깊이 카메라

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 )

DepthCameraPIX Pixelkit v0.8.4 에 추가되었으며 iPhone X 또는 새로운 것이 필요합니다.

setup(with:filter:) DepthCameraPIX 의 메소드.
CameraPIX 에서 방향, 색상 및 깊이를 활성화합니다.

0.0 및 1.0 경계의 깊이 값에 대한 액세스를 얻으려면
16 bit 모드를 활성화 : PixelKit.main.render.bits = ._16

예 : 멀티 카메라 

 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 )

참고 MultiCameraPIX iOS 13이 필요합니다.

공간을 조정하십시오

Pixelkit 좌표 공간은 중앙에 원점 (0.0, 0.0)이있는 수직 축 (높이 1.0)으로 정상됩니다.
기본 Uikit 및 Swiftui 뷰와 비교하여 수직 축이 뒤집히고 원점이 움직입니다. Pixelkit에서 그래픽으로 작업 할 때 더 편한 것입니다. 전체 회전은 1.0으로 정의됩니다

중심 : cgpoint (x : 0, y : 0)
왼쪽 하단 : cgpoint (x : -0.5 * Aspectratio, y : -0.5)
오른쪽 상단 : cgpoint (x : 0.5 * Aspectratio, y : 0.5)

팁 : Resolution .aspect 속성이 있습니다.
let aspectRatio: CGFloat = Resolution._1080p.aspect

연산자를 혼합하십시오

픽스를 혼합하는 빠르고 편리한 방법
이들은 지원되는 BlendingMode 연산자입니다.

& !& + - * ** !** % ~ °
.위에 .아래에 .추가하다 .덜다 .곱하다 .힘 .감마 .차이점 .평균 코사인
<> >< ++ -- <-> >-< +-+
.최저한의 .최고 .addwithalpha .Subtractwithalpha 내부에 밖의 독점 
 let blendPix = ( CameraPIX ( ) !** NoisePIX ( at : . fullHD ( . portrait ) ) ) * CirclePIX ( at : . fullHD ( . portrait ) )

기본 글로벌 블렌드 연산자 채우기 모드는 .fit 입니다.
PIX.blendOperators.globalPlacement = .fill

편의에 영향을 미칩니다

  • .PixScaleresolution (to : ._1080p * 0.5) -> ResolutionPix
  • .PixScaleresolution (by : 0.5) -> ResolutionPix
  • .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 (at : 0.5) -> thresholdpix
  • .pixquantize (by : 0.5) -> QuantizePix
  • .pixPosition (at : cgpoint (x : 0.5, y : 0.5)) -> transformPix
  • .PixRotatate (by : 0.5) -> TransformPix
  • .PixRotatate (Byradians : .pi) -> TransformPix
  • .PixRotatate (Bydegrees : 180) -> TransformPix
  • .pixScale (by : 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, 너비 : 0.5, 높이 : 0.5)) -> Croppix
  • .pixflipx () -> flipfloppix
  • .pixflipy () -> flipfloppix
  • .pixflopleft () -> flipfloppix
  • .pixflopright () -> flipfloppix
  • .pixRange (Inlow : 0.0, indigh : 0.5, 전염 : 0.5, outhigh : 1.0) -> Rangepix
  • .pixRange (Inlow :. Clear, Inhigh : .Gray, 전매 : .Gray, Othigh :. White) -> RangePix
  • .pixsharpen () -> Shortenpix
  • .pixSlope () -> slopepix
  • .PixVignetting (반경 : 0.5, 삽입 : 0.25, 감마 : 0.5) -> lumalevelspix
  • .pixLookup (pix : pixb, Axis : .x) -> lookuppix
  • .pixlumablur (pix : pixb, 반경 : 0.5) -> lumablurpix
  • .pixlumalevels (pix : pixb, 밝기 : 2.0) -> lumalevelspix
  • .pixDisPlace (pix : pixb, 거리 : 0.5) -> 변위
  • .pixRemap (pix : pixb) -> 리모 픽

이 기능은 새로운 픽스를 생성 할 것임을 명심하십시오.
GPU 메모리를 과부하시키는 데주의를 기울이면 일부 기능은 여러 픽스를 만듭니다.

높은 비트 모드

Drivacepix 및 Slopepix 와 같은 일부 효과는 비트 깊이가 높을 수 있습니다.
기본값은 8 비트입니다. PixelKit.main.render.bits = ._16 처럼 변경하십시오

픽스를 만들기 전에 높은 비트 모드를 활성화하십시오.

참고 자원은 아직 더 높은 비트를 지원하지 않습니다.
현재 리소스가 포함 된 감마 오프셋이 있습니다.

금속 픽스 

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

유니폼 : 

 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

참고 :

  • 카메라 액세스를 얻으려면 MacOS에서 기능 아래 Xcode 프로젝트 설정의 앱 샌드 박스에서 카메라를 확인하십시오.

Anton Heestand XYZ가 만든 TouchDesigner에서 영감을 얻었습니다

확장하다
추가 정보
관련 애플리케이션
추천
관련 정보 전체