MaTriXy

class RgbConversion(val rs: RenderScript, private val feedSize: Size, private val hasRotate: Boolean = true) {
    private var mInputAllocation: Allocation? = null
    private var mOutputAllocation: Allocation? = null
    private var mRotatedAllocation: Allocation? = null
    private val yuvToRgb = ScriptIntrinsicYuvToRGB.create(rs, Element.U8_4(rs))
    private val rotator = ScriptC_rotator(rs)
    var bufferCallback: ((ByteBuffer) -> Unit)? = null

    val inputSurface: Surface
        get() = mInputAllocation!!.surface

MaTriXy

//
//  ViewController.swift
//  CameraFilter
//

import UIKit
import AVFoundation

class ViewController: UIViewController, AVCaptureVideoDataOutputSampleBufferDelegate {
    

MaTriXy

Amazon changed the install in Linux 2. One no-longer using 'yum' See: https://aws.amazon.com/amazon-linux-2/release-notes/

Docker CE Install

sudo amazon-linux-extras install docker
sudo service docker start
sudo usermod -a -G docker ec2-user

MaTriXy

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,

MaTriXy

import Foundation
import UIKit

public class Checkmark: UIView {
    
    // MARK: Public variables
    public var initialLayerColor: UIColor = UIColor.blue {
        didSet {
            initialLayer.strokeColor = initialLayerColor.cgColor
        }

MaTriXy

import Foundation
import UIKit

public class Checkmark: UIView {
    
    // MARK: Public variables
    public var initialLayerColor: UIColor = UIColor.blue {
        didSet {
            initialLayer.strokeColor = initialLayerColor.cgColor
        }

MaTriXy

A non-exhaustive list of WebGL frameworks and libraries. It is mostly for learning purposes as some of the libraries listed are outdated/not maintained anymore.

Engines and libraries

• three.js: JavaScript 3D library
• stack.gl: an open software ecosystem for WebGL, built on top of browserify and npm.
• PixiJS: Super fast HTML 5 2D rendering engine that uses webGL with canvas fallback
• Pex: Pex is a javascript 3d library / engine allowing for seamless development between Plask and WebGL in the browser.
• Babylon.js: a complete JavaScript framework for building 3D games with HTML 5 and WebGL
• Filament: Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS and WASM/WebGL
• ClayGL: A WebGL graphic library helping you to

MaTriXy

/**
 * An [Observer] for [Event]s, simplifying the pattern of checking if the [Event]'s content has
 * already been handled.
 *
 * [onEventUnhandledContent] is *only* called if the [Event]'s contents has not been handled.
 */
class EventObserver<T>(private val onEventUnhandledContent: (T) -> Unit) : Observer<Event<T>> {
    override fun onChanged(event: Event<T>?) {
        event?.getContentIfNotHandled()?.let { value ->
            onEventUnhandledContent(value)

MaTriXy

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.support.v4.view.ViewCompat;
import android.util.AttributeSet;
import android.widget.FrameLayout;

/**

MaTriXy

import android.os.SystemClock;
import android.view.View;

import java.util.Map;
import java.util.WeakHashMap;

/**
 * A Debounced OnClickListener
 * Rejects clicks that are too close together in time.
 * This class is safe to use as an OnClickListener for multiple views, and will debounce each one separately.