| Collision detection occurs and messages are sent upon collision | ||||||
|---|---|---|---|---|---|---|
| Static Collider | Rigidbody Collider | Kinematic Rigidbody Collider | Static Trigger Collider | Rigidbody Trigger Collider | Kinematic Rigidbody Trigger Collider | |
| Static Collider | Y | |||||
| Rigidbody Collider | Y | Y | Y | |||
| Kinematic Rigidbody Collider | Y | |||||
| Static Trigger Collider | ||||||
| Rigidbody Trigger Collider | ||||||
| Kinematic Rigidbody Trigger Collider | ||||||
| Trigger messages are sent upon collision | ||||||
|---|---|---|---|---|---|---|
| Static Collider | Rigidbody Collider | Kinematic Rigidbody Collider | Static Trigger Collider | Rigidbody Trigger Collider | Kinematic Rigidbody Trigger Collider | |
| Static Collider | Y | Y | ||||
| Rigidbody Collider | Y | Y | Y | |||
| Kinematic Rigidbody Collider | Y | Y | Y | |||
| Static Trigger Collider | Y | Y | Y | Y | ||
| Rigidbody Trigger Collider | Y | Y | Y | Y | Y | Y |
| Kinematic Rigidbody Trigger Collider | Y | Y | Y | Y | Y | Y |
https://tokenized.com/
What Is Theta (THETA)?
Theta (THETA) is a blockchain powered network purpose-built for video streaming. Launched in March 2019, the Theta mainnet operates as a decentralized network in which users share bandwidth and computing resources on a peer-to-peer (P2P) basis.The project is advised by Steve Chen, co-founder of YouTube and Justin Kan, co-founder of Twitch.
Theta features its own native cryptocurrency token, THETA, which performs various governance tasks within the network, and counts Google, Binance, Blockchain ventures, Gumi, Sony Europe and Samsung as Enterprise validators, along with a Guardian network of thousands of community-run guardian nodes.
Developers say that the project aims to shake up the video streaming industry in its current form — centralization, poor infrastructure and high costs mean that end users often end up with a poor experience. Content creators likewise earn less revenue due to the barriers between them and end users.
Who Are The Founders of Theta?
Theta was co-founded by Mitch Liu and Jieyi Long in 2018. Liu has a long history in the gaming and video industries, co-founding video advertising firm Tapjoy, mobile social gaming startup Gameview Studios, and THETA.tv, the live streaming platform whose DApp was the first to be built on the Theta protocol.
Long is Theta’s second co-founder and CTO, following similar multi-year experience in design automation, gaming, virtual reality, and large scale distributed systems. He authored multiple peer-reviewed academic papers and holds various patents in video streaming, blockchain and virtual reality.
Theta now has a modest team, and its official website lists strategic corporate investors as Samsung NEXT, Sony Innovation Fund, media investors BDMI Bertelsmann Digital Media Investments, CAA Creative Artists Agency, and traditional Silicon Valley VCs including DCM, Sierra Ventures and the VR Fund.
What Makes Theta Unique?
Theta’s main business concept is to decentralize video streaming, data delivery and edge computing, making it more efficient, cost-effective and fair for industry participants.
The network runs on a native blockchain, with two native tokens, known as Theta (THETA), Theta Fuel (TFUEL), powering the internal economy.
Theta’s appeal is threefold: viewers get rewarded with better quality streaming service, content creators improve their earnings and middlemen — video platforms — save money on building infrastructure and increase advertising and subscription revenues.
Users have an incentive to both watch network content and share network resources, as rewards come in the form of TFUEL tokens.
The platform is open source, and token holders receive governance powers as with many proof-of-stake (PoS)-based blockchain ecosystems.
In addition to video, data and computing, Theta caters to developers looking to launch decentralized applications (DApps) on its fully featured EVM-compatible Smart contract platform.
Related Pages:
Find out more about Livepeer here.
Find out more about LBRY here.
Crypto newbie? Find the answers to all your questions with Alexandria, CoinMarketCap’s dedicated education resource.
How Many Theta (THETA) Coins Are There in Circulation?
Theta involves two tokens: THETA and TFUEL. THETA exists only for governance purposes, with 5 TFUEL tokens issued per 1 THETA held at the time of the mainnet launch in 2019.
THETA itself launched in 2018, at which time it was distributed to buyers as an ERC-20 token on Ethereum. Afterwards, all ERC-20 THETA were converted to native THETA on the mainnet.
The total supply of THETA is capped at 1 billion (1,000,000,000) tokens. It is distributed in various proportions among all network participants, as well as the Theta team itself and a reserve pool.
TFUEL is used to power transactions in a similar way to gas on Ethereum (ETH). Its total supply is 5 billion (5,000,000,000) tokens.
How Is the Theta Network Secured?
Theta uses a financial incentive scheme to ensure user participation in governance activities, and hence its network is secured by its own users.
The network relies on proof-of-stake (PoS), and employs a multi-level Byzantine Fault Tolerance (BFT) consensus mechanism to balance security with high transaction throughput.
With the launch of Guardian nodes in June 2019, Theta ensured that no single entity controls the majority of THETA tokens being staked at any one time.
Where Can You Buy Theta (THETA)?
THETA, as the main token for the Theta platform, is freely tradable on major exchanges. Pairs include cryptocurrencies, fiat currencies and stablecoins.
As of October 2020, the highest volume pairs come from Binance, with the most popular trading currency being stablecoin Tether (USDT).
New to crypto? Check out CoinMarketCap’s easy guide to buying Bitcoin (BTC) or any other token.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using ArgosTweenSpacePuppy;
using BNG;
public class AS_Bond_Lichtenberg : MonoBehaviour
{
private AF_Instance af_Instance;
private List<AS_Bond> bondList = new List<AS_Bond>();
private AS_Bond bondPrefab;
private GameObject objectToMove;
private GameObject objectToStay;
private float tAccum_ST;
public float tDurr_ST = 3f;
public float tweenVAL;
private GameObject AllShape_1;
private GameObject AllShape_2;
public GameObject fulgurite_Container_Prefab;
public GameObject myFulgurite_Container;
private Vector3[] axisFLIPPER = { new Vector3 { x = 1, y = 0, z = 0 },
new Vector3 { x = 0, y = 1, z = 0 },
new Vector3 { x = 0, y = 0, z = 1 },
new Vector3 { x = -1, y = 0, z = 0 },
new Vector3 { x = 0, y =-1, z = 0 },
new Vector3 { x = 0, y = 0, z = -1},
};
private void Awake()
{
af_Instance = AF_Instance.Instance;
}
public void Create_New_Bond(Spoke_AllShape sas1, Spoke_AllShape sas2)
{
GameObject AS1 = sas1.myALL_SHAPE.gameObject;
Transform targ1 = sas1.targTransform;
GameObject AS2 = sas2.myALL_SHAPE.gameObject;
Transform targ2 = sas2.targTransform;///CALC HERE FOR NEW FIN ALIGNMENT
Determine_Target_Movement(AS1, targ1, AS2, targ2);
bondList.Add(af_Instance.New_Bond());
bondList[bondList.Count - 1].SetBond(sas1, sas2);
//ARE THEY IN A CONTAINER?
//IF NOT CREATE ONE:
//myFulgurite_Container = Instantiate(fulgurite_Container_Prefab);
//myFulgurite_Container.name = "FULGURATE_CONTAINER";
//myFulgurite_Container.transform.position = objectToStay.transform.position;
//myFulgurite_Container.transform.rotation = objectToStay.transform.rotation;
}
public void Set_Target_Transform(Transform targ)
{
Vector3 center = (objectToMove.transform.position + objectToStay.transform.position) / 2f;
int idx1 = objectToMove.GetComponent<Spoke_Handler>().Closest_Fin(center);
int idx2 = objectToStay.GetComponent<Spoke_Handler>().Closest_Fin(center);
Vector3 vin = objectToStay.GetComponent<Spoke_Handler>().spoke_AS[idx2].trans_to.vIN[idx1];
Vector3 vup = objectToStay.GetComponent<Spoke_Handler>().spoke_AS[idx2].trans_to.vUP[idx1];
Vector3 vInTrans = objectToStay.transform.TransformDirection(vin);
Vector3 vUpTrans = objectToStay.transform.TransformDirection(vup);
transform.position = targ.position;
transform.rotation = Quaternion.LookRotation(vInTrans, vUpTrans);
//Debug.Log("MOVE fin:" + idx1.ToString() + "STAY fin:" + idx2.ToString());
//Debug.Log("vin = " + vin.ToString("F1") + "vup = " + vup.ToString("F1"));
//Debug.Log("vin TRANs = " + vInTrans.ToString("F1") + "vup TRANs = " + vUpTrans.ToString("F1"));
//Flip it - for minimal rotation to bonding FIN
if (Vector3.Dot(vUpTrans, objectToMove.transform.up) < 0 || Vector3.Dot(vInTrans, objectToMove.transform.forward) < 0)
{
Quaternion qRota = Quaternion.AngleAxis(180, axisFLIPPER[idx1]);
transform.rotation *= qRota;
}
}
private void Create_Fulgurite_Container()
{
if (myFulgurite_Container == null)
{
myFulgurite_Container = Instantiate(fulgurite_Container_Prefab);
myFulgurite_Container.name = "FULGURITE_CONTAINER";
myFulgurite_Container.transform.position = objectToStay.transform.position;
myFulgurite_Container.transform.rotation = objectToStay.transform.rotation;
}
else
{
//STUB
}
}
private void AddFixedJoint(GameObject AS)
{
AS.AddComponent<FixedJoint>();
AS.GetComponent<FixedJoint>().connectedBody = myFulgurite_Container.GetComponent<Rigidbody>();
}
public void Determine_Target_Movement(GameObject AS1, Transform targ1, GameObject AS2, Transform targ2)
{
AllShape_1 = AS1;
AllShape_2 = AS2;
AF_Network_Grabable gbl_AS1 = AS1.GetComponent<Spoke_Handler>().netGrabbable;
AF_Network_Grabable gbl_AS2 = AS2.GetComponent<Spoke_Handler>().netGrabbable;
gbl_AS2.DropItem(null, true, true);
gbl_AS1.DropItem(null, true, true);
//gbl_AS1.enabled = false;
//gbl_AS2.enabled = false;
//AS1.GetComponent<Spoke_Handler>().SetAllActive_Colliders(false);
//AS2.GetComponent<Spoke_Handler>().SetAllActive_Colliders(false);
//Debug.Log("SetAllActive_Colliders(false)");
//Quaternion qRota;
//qRota = Quaternion.Euler(90, 0, 0);
//Two calls - only take this one
if (AS1 == af_Instance.last_Held_AllShape || (AS1.GetComponent<Spoke_Handler>().isBeingHeld))
{
objectToMove = AS1;
objectToStay = AS2;
af_Instance.Set_All_Active_Colliders(false,false);
Set_Target_Transform(targ2);
tAccum_ST = 0.0f;
Debug.Log("Start COROUTINE start:" + Time.time.ToString("F3"));
StartCoroutine(Move_to_Connect());
//transform.position = targ2.position;
//transform.rotation = targ2.rotation;
//transform.rotation *= qRota;
}
else
{
//objectToMove = AS2;
//objectToStay = AS1;
//Set_Target_Transform(targ1);
////transform.position = targ1.position;
////transform.rotation = targ1.rotation;
////transform.rotation *= qRota;
}
//tAccum_ST = 0.0f;
//Debug.Log("Start COROUTINE start:" + Time.time.ToString("F3"));
//StartCoroutine(Move_to_Connect());
}
private void Set_Occupied()
{
Vector3 center = (objectToMove.transform.position + objectToStay.transform.position) / 2f;
int idx1 = objectToMove.GetComponent<Spoke_Handler>().Closest_Fin(center);
int idx2 = objectToStay.GetComponent<Spoke_Handler>().Closest_Fin(center);
objectToMove.GetComponent<Spoke_Handler>().setOccupied(idx1, true, objectToStay.GetComponent<Spoke_Handler>().spoke_AS[idx2]);
objectToStay.GetComponent<Spoke_Handler>().setOccupied(idx2, true, objectToMove.GetComponent<Spoke_Handler>().spoke_AS[idx1]);
}
private IEnumerator Move_to_Connect()
{
int i = 0; //Sanity check for infinite loops
float linProg = tAccum_ST / tDurr_ST;
while (i < 180 && linProg < 1)
{
tAccum_ST += Time.deltaTime;
linProg = tAccum_ST / tDurr_ST;
Mathf.Clamp(tAccum_ST, 0, tDurr_ST);
tweenVAL = EaseMethods.ExpoEaseInOut(tAccum_ST, 0, 1, tDurr_ST);
Move_AllShape_Into_Place(tweenVAL);
yield return true;
i++;
}
tAccum_ST = tDurr_ST;
tweenVAL = 1;
Move_AllShape_Into_Place(tweenVAL);
Set_Occupied();
Create_Fulgurite_Container(); //CHECK WHETHER ITs FIRST ONE
AddFixedJoint(AllShape_1);
AddFixedJoint(AllShape_2);
//Reset Active Colliders - Need an RPC call here perhaps
AllShape_1.GetComponent<Spoke_Handler>().SetAllActive_Colliders(true, false);
AllShape_2.GetComponent<Spoke_Handler>().SetAllActive_Colliders(true, false);
//TEMPORARY
//af_Instance.SetGrab_Colliders(true);
af_Instance.Set_All_Active_Colliders(true,false);
//Debug.Log("FINISHED COROUTINE start:" + Time.time.ToString("F3"));
StopCoroutine("Move_to_Connect");
}
private void Move_AllShape_Into_Place(float val)
{
objectToMove.transform.position = Vector3.Lerp(objectToMove.transform.position, transform.position, val);
objectToMove.transform.rotation = Quaternion.Slerp(objectToMove.transform.rotation, transform.rotation, val);
}
void Update()
{
//connectionTimer += Time.deltaTime;
//Debug.Log("connectionTimer = " + connectionTimer.ToString("F2"));
}
}
//TRANS_TO [0]
//VIN
// 0, -1, 0
// 0, 0, -1
//-1, 0, 0
// 0, 1, 0
// 0, 0, -1
// 1, 0, 0
//VUP
// 0, 0, -1
//-1, 0, 0
// 0, 1, 0
// 0, 0, -1
// 1, 0, 0
// 0, 1, 0
//TRANS_TO [1]
//VIN
// 0, 0, 1
//-1, 0, 0
// 0, -1, 0
// 0, 0, 1
// 1, 0, 0
// 0, 1, 0
//VUP
// 1, 0, 0
// 0, -1, 0
// 0, 0, 1
//-1, 0, 0
// 0, 1, 0
// 0, 0, -1
//TRANS_TO [2]
//VIN
// 1, 0, 0
// 0, 1, 0
// 0, 0, -1
//-1, 0, 0
// 0, -1, 0
// 0, 0, 1
//VUP
// 0, 1, 0
// 0, 0, -1
//-1, 0, 0
// 0, 1, 0
// 0, 0, 1
//-1, 0, 0
//TRANS_TO [3]
//VIN
// 0, -1, 0
// 0, 0, 1
// 1, 0, 0
// 0, 1, 0
// 0, 0, 1
//-1, 0, 0
//VUP
// 0, 0, 1
// 1, 0, 0
// 0, 1, 0
// 0, 0, 1
//-1, 0, 0
// 0, 1, 0
//TRANS_TO [4]
//VIN
// 0, 0, 1
// 1, 0, 0
// 0, 1, 0
// 0, 0, 1
// 1, 0, 0
// 0, -1, 0
//VUP
//-1, 0, 0
// 0, 1, 0
// 0, 0, -1
// 1, 0, 0
// 0, -1, 0
// 0, 0, 1
//TRANS_TO [5]
//VIN
//-1, 0, 0
// 0, -1, 0
// 0, 0, 1
// 1, 0, 0
// 0, 1, 0
// 0, 0, -1
//VUP
// 0, 1, 0
// 0, 0, 1
//-1, 0, 0
// 0, 1, 0
// 0, 0, -1
// 1, 0, 0