diff --git a/packages/editor/src/components/materials/MaterialEditor.tsx b/packages/editor/src/components/materials/MaterialEditor.tsx
index c126ac1fd3..d2b1d6b253 100644
--- a/packages/editor/src/components/materials/MaterialEditor.tsx
+++ b/packages/editor/src/components/materials/MaterialEditor.tsx
@@ -146,6 +146,7 @@ export function MaterialEditor(props: { materialUUID: EntityUUID }) {
   prototypeName.set(material.type)
 
   const parameters = useHookstate(0)
+
   return (
     <div style={{ position: 'relative' }}>
       <InputGroup name="Name" label={t('editor:properties.mesh.material.name')}>
@@ -186,7 +187,7 @@ export function MaterialEditor(props: { materialUUID: EntityUUID }) {
         values={materialComponent.parameters.value!}
         onChange={(k) => async (val) => {
           let prop
-          if (prototype.prototypeArguments![k].type === 'texture' && typeof val === 'string') {
+          if (prototype.prototypeArguments[k].type.value === 'texture') {
             if (val) {
               const priorUnload = textureUnloadMap.get(NO_PROXY)[k]
               if (priorUnload) {
@@ -232,7 +233,7 @@ export function MaterialEditor(props: { materialUUID: EntityUUID }) {
         <Button
           onClick={() => {
             setComponent(entity, MaterialComponent[MaterialComponents.State], {
-              pluginEntities: [...(materialComponent.pluginEntities.value ?? []), pluginByName[selectedPlugin.value]!]
+              pluginEntities: [pluginByName[selectedPlugin.value]]
             })
           }}
         >
diff --git a/packages/editor/src/components/materials/MaterialLibraryEntry.tsx b/packages/editor/src/components/materials/MaterialLibraryEntry.tsx
index eaa86d6bbf..692f96ffdf 100644
--- a/packages/editor/src/components/materials/MaterialLibraryEntry.tsx
+++ b/packages/editor/src/components/materials/MaterialLibraryEntry.tsx
@@ -32,7 +32,7 @@ import { getMutableState } from '@etherealengine/hyperflux'
 import MaterialComponentIcon from '@mui/icons-material/LocalFloristTwoTone'
 import { Grid } from '@mui/material'
 
-import { EntityUUID, UUIDComponent, getComponent } from '@etherealengine/ecs'
+import { EntityUUID, UUIDComponent, getOptionalComponent } from '@etherealengine/ecs'
 import { MaterialSelectionState } from '@etherealengine/engine/src/scene/materials/MaterialLibraryState'
 import { MaterialComponent, MaterialComponents } from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
 import { ItemTypes } from '../../constants/AssetTypes'
@@ -58,10 +58,12 @@ export type MaterialLibraryEntryProps = {
 }
 
 const nodeDisplayName = (node: MaterialLibraryEntryType) => {
-  return getComponent(
-    UUIDComponent.getEntityByUUID(node.uuid as EntityUUID),
-    MaterialComponent[MaterialComponents.State]
-  ).material?.name
+  return (
+    getOptionalComponent(
+      UUIDComponent.getEntityByUUID(node.uuid as EntityUUID),
+      MaterialComponent[MaterialComponents.State]
+    )?.material?.name ?? ''
+  )
 }
 
 export default function MaterialLibraryEntry(props: MaterialLibraryEntryProps) {
diff --git a/packages/editor/src/components/materials/MaterialLibraryPanelContainer.tsx b/packages/editor/src/components/materials/MaterialLibraryPanelContainer.tsx
index 81c9c08a05..1a63a0ab9c 100644
--- a/packages/editor/src/components/materials/MaterialLibraryPanelContainer.tsx
+++ b/packages/editor/src/components/materials/MaterialLibraryPanelContainer.tsx
@@ -34,7 +34,7 @@ import { getMutableState, getState, useHookstate, useState } from '@etherealengi
 import { Stack } from '@mui/material'
 
 import { pathJoin } from '@etherealengine/common/src/utils/miscUtils'
-import { EntityUUID, UUIDComponent, getComponent, useQuery } from '@etherealengine/ecs'
+import { EntityUUID, UUIDComponent, UndefinedEntity, getComponent, useQuery } from '@etherealengine/ecs'
 import { SourceComponent } from '@etherealengine/engine/src/scene/components/SourceComponent'
 import {
   createMaterialEntity,
@@ -109,7 +109,7 @@ export default function MaterialLibraryPanel() {
             <Button
               onClick={() => {
                 const newMaterial = new MeshBasicMaterial({ name: 'New Material' })
-                createMaterialEntity(newMaterial, '')
+                createMaterialEntity(newMaterial, '', UndefinedEntity)
               }}
             >
               New
diff --git a/packages/editor/src/functions/EditorControlFunctions.ts b/packages/editor/src/functions/EditorControlFunctions.ts
index 07fe6ae3c3..e42104cd80 100644
--- a/packages/editor/src/functions/EditorControlFunctions.ts
+++ b/packages/editor/src/functions/EditorControlFunctions.ts
@@ -138,10 +138,6 @@ const addOrRemoveComponent = <C extends Component<any, any>>(
   }
 }
 
-export const testst = {
-  setComponent: function () {}
-}
-
 const modifyName = (entities: Entity[], name: string) => {
   const scenes = getSourcesForEntities(entities)
 
@@ -246,7 +242,6 @@ const modifyMaterial = (nodes: string[], materialId: EntityUUID, properties: { [
         material[k] = v
       }
     })
-    material.needsUpdate = true
   }
 }
 
diff --git a/packages/editor/src/functions/addMediaNode.ts b/packages/editor/src/functions/addMediaNode.ts
index abe2cc73e4..a63a3ed44d 100644
--- a/packages/editor/src/functions/addMediaNode.ts
+++ b/packages/editor/src/functions/addMediaNode.ts
@@ -37,7 +37,6 @@ import { getComponent, getMutableComponent } from '@etherealengine/ecs/src/Compo
 import { Engine } from '@etherealengine/ecs/src/Engine'
 import { defineQuery } from '@etherealengine/ecs/src/QueryFunctions'
 import { AssetLoaderState } from '@etherealengine/engine/src/assets/state/AssetLoaderState'
-import { SourceComponent } from '@etherealengine/engine/src/scene/components/SourceComponent'
 import { createMaterialEntity } from '@etherealengine/engine/src/scene/materials/functions/materialSourcingFunctions'
 import { ComponentJsonType } from '@etherealengine/engine/src/scene/types/SceneTypes'
 import { getState } from '@etherealengine/hyperflux'
@@ -94,20 +93,21 @@ export async function addMediaNode(
           (mesh: Mesh) => mesh?.isMesh
         )[0]
         if (!material) return
+        if (!UUIDComponent.getEntityByUUID(material.uuid as EntityUUID)) createMaterialEntity(material, url)
+
         const materialEntity = UUIDComponent.getEntityByUUID(material.uuid as EntityUUID)
         if (materialEntity) material = getMaterial(material.uuid as EntityUUID)!
+        const materialStateComponent = getMutableComponent(materialEntity, MaterialComponent[MaterialComponents.State])
+
         iterateObject3D(intersected.object, (mesh: Mesh) => {
           if (!mesh?.isMesh) return
-          const src = getComponent(materialEntity, SourceComponent)
-          if (!src) return
-          if (!UUIDComponent.getEntityByUUID(material.uuid as EntityUUID)) createMaterialEntity(material, src)
-          const materialComponent = getMutableComponent(mesh.entity, MaterialComponent[MaterialComponents.State])
-          if (materialComponent.instances.value)
-            materialComponent.instances.set([...materialComponent.instances.value, mesh.entity])
-          //if (unregisterMaterialInstance(mesh.material as Material, mesh.entity) === 0) {
-          //  unregisterMaterial(mesh.material as Material)
-          //}
-          mesh.material = material
+          const materialInstanceComponent = getMutableComponent(
+            mesh.entity,
+            MaterialComponent[MaterialComponents.Instance]
+          )
+          if (materialInstanceComponent.uuid.value) materialInstanceComponent.uuid.set([material.uuid as EntityUUID])
+          if (materialStateComponent.instances.value)
+            materialStateComponent.instances.set([...materialStateComponent.instances.value, mesh.entity])
         })
       })
     } else {
diff --git a/packages/engine/src/assets/exporters/gltf/extensions/EEMaterialExporterExtension.ts b/packages/engine/src/assets/exporters/gltf/extensions/EEMaterialExporterExtension.ts
index 4d490c4585..a86c6ab2a0 100644
--- a/packages/engine/src/assets/exporters/gltf/extensions/EEMaterialExporterExtension.ts
+++ b/packages/engine/src/assets/exporters/gltf/extensions/EEMaterialExporterExtension.ts
@@ -26,7 +26,12 @@ Ethereal Engine. All Rights Reserved.
 import { CubeTexture, Material, Texture } from 'three'
 
 import { EntityUUID, UUIDComponent, getComponent } from '@etherealengine/ecs'
-import { MaterialComponent, MaterialComponents } from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
+import { NameComponent } from '@etherealengine/spatial/src/common/NameComponent'
+import {
+  MaterialComponent,
+  MaterialComponents,
+  materialByName
+} from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
 import matches from 'ts-matches'
 import { injectMaterialDefaults } from '../../../../scene/materials/functions/materialSourcingFunctions'
 import { GLTFWriter } from '../GLTFExporter'
@@ -52,6 +57,8 @@ export function isOldEEMaterial(extension: any) {
     .test(argValues)
 }
 
+export type MaterialExtensionPluginType = { id: string; parameters: { [key: string]: any } }
+
 export type EEMaterialExtensionType = {
   uuid: EntityUUID
   name: string
@@ -62,7 +69,7 @@ export type EEMaterialExtensionType = {
       contents: any
     }
   }
-  plugins: string[]
+  plugins: MaterialExtensionPluginType[]
 }
 
 export default class EEMaterialExporterExtension extends ExporterExtension {
@@ -75,7 +82,9 @@ export default class EEMaterialExporterExtension extends ExporterExtension {
   matCache: Map<any, any>
 
   writeMaterial(material: Material, materialDef) {
-    const argData = injectMaterialDefaults(material.uuid as EntityUUID)
+    const materialEntityUUID = materialByName[material.name]
+    const materialEntity = UUIDComponent.getEntityByUUID(materialEntityUUID)
+    const argData = injectMaterialDefaults(materialEntityUUID)
     if (!argData) return
     const result: any = {}
     Object.entries(argData).map(([k, v]) => {
@@ -106,17 +115,19 @@ export default class EEMaterialExporterExtension extends ExporterExtension {
     delete materialDef.normalTexture
     delete materialDef.emissiveTexture
     delete materialDef.emissiveFactor
-    const materialComponent = getComponent(
-      UUIDComponent.getEntityByUUID(material.uuid as EntityUUID),
-      MaterialComponent[MaterialComponents.State]
-    )
+    const materialComponent = getComponent(materialEntity, MaterialComponent[MaterialComponents.State])
     const prototype = getComponent(materialComponent.prototypeEntity!, MaterialComponent[MaterialComponents.Prototype])
+    const materialStates = getComponent(materialEntity, MaterialComponent[MaterialComponents.State])
+    const materialPlugins = materialStates.pluginEntities?.map((entity) => {
+      const plugin = getComponent(entity, MaterialComponent[MaterialComponents.Plugin])
+      return { id: plugin?.plugin?.id ?? '', name: plugin?.parameters ?? '' }
+    })
     materialDef.extensions = materialDef.extensions ?? {}
     materialDef.extensions[this.name] = {
-      uuid: material.uuid,
-      name: material.name,
-      prototype: material.userData.type ?? Object.keys(prototype.prototypeConstructor!)[0],
-      plugins: [] /**@TODO PLUGINS */,
+      uuid: getComponent(materialEntity, UUIDComponent),
+      name: getComponent(materialEntity, NameComponent),
+      prototype: Object.keys(prototype.prototypeConstructor!)[0],
+      plugins: materialPlugins,
       args: result
     }
     this.writer.extensionsUsed[this.name] = true
diff --git a/packages/engine/src/avatar/components/TransparencyDitheringComponent.tsx b/packages/engine/src/avatar/components/TransparencyDitheringComponent.tsx
index 0b405755ed..6648fb2762 100644
--- a/packages/engine/src/avatar/components/TransparencyDitheringComponent.tsx
+++ b/packages/engine/src/avatar/components/TransparencyDitheringComponent.tsx
@@ -23,12 +23,16 @@ All portions of the code written by the Ethereal Engine team are Copyright © 20
 Ethereal Engine. All Rights Reserved.
 */
 
-import { Entity, EntityUUID, defineComponent, getOptionalMutableComponent } from '@etherealengine/ecs'
+import { Entity, defineComponent, getOptionalMutableComponent } from '@etherealengine/ecs'
 import { defineState, matches } from '@etherealengine/hyperflux'
 import { matchesVector3 } from '@etherealengine/spatial/src/common/functions/MatchesUtils'
 import { PluginObjectType } from '@etherealengine/spatial/src/common/functions/OnBeforeCompilePlugin'
-import { MaterialComponent, MaterialComponents } from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
-import { getPluginByName } from '@etherealengine/spatial/src/renderer/materials/materialFunctions'
+import {
+  MaterialComponent,
+  MaterialComponents,
+  pluginByName
+} from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
+import { applyPluginShaderParameters } from '@etherealengine/spatial/src/renderer/materials/materialFunctions'
 import { Vector3 } from 'three'
 import {
   ditheringAlphatestChunk,
@@ -57,8 +61,7 @@ export const TransparencyDitheringComponent = Array.from({ length: maxDitherPoin
         distance: 2,
         exponent: 2,
         calculationType: ditherCalculationType.worldTransformed,
-        //internal
-        materialUUIDs: [] as EntityUUID[]
+        shaders: [] as string[]
       }
     },
 
@@ -75,12 +78,10 @@ export const TransparencyDitheringPlugin: PluginObjectType = {
   id: 'TransparencyDithering',
   priority: 10,
   compile: (shader, renderer) => {
-    const pluginEntity = getPluginByName(TransparencyDitheringPlugin.id)
+    const pluginEntity = pluginByName[TransparencyDitheringPlugin.id]
     const plugin = getOptionalMutableComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin])
     if (!plugin) return
 
-    plugin.shader[(shader as any).shaderName].set(shader)
-
     if (!shader.vertexShader.startsWith('varying vec3 vWorldPosition')) {
       shader.vertexShader = shader.vertexShader.replace(
         /#include <common>/,
@@ -97,12 +98,12 @@ export const TransparencyDitheringPlugin: PluginObjectType = {
         '#include <common>\n' + ditheringFragUniform
       )
     shader.fragmentShader = shader.fragmentShader.replace(/#include <alphatest_fragment>/, ditheringAlphatestChunk)
-    shader.uniforms.centers = {
-      value: Array.from({ length: maxDitherPoints }, () => new Vector3())
-    }
-    shader.uniforms.exponents = { value: Array.from({ length: maxDitherPoints }, () => 1) }
-    shader.uniforms.distances = { value: Array.from({ length: maxDitherPoints }, () => 1) }
-    shader.uniforms.useWorldCalculation = { value: Array.from({ length: maxDitherPoints }, () => 1) }
-    shader.uniforms.maxDitherPoints = { value: 1 }
+    applyPluginShaderParameters(pluginEntity, shader, {
+      centers: Array.from({ length: maxDitherPoints }, () => new Vector3()),
+      exponents: Array.from({ length: maxDitherPoints }, () => 2),
+      distances: Array.from({ length: maxDitherPoints }, () => 3),
+      useWorldCalculation: Array.from({ length: maxDitherPoints }, () => 1),
+      maxDitherPoints: 1
+    })
   }
 }
diff --git a/packages/engine/src/avatar/systems/TransparencyDitheringSystem.tsx b/packages/engine/src/avatar/systems/TransparencyDitheringSystem.tsx
index 0841b96a14..96140f1f35 100644
--- a/packages/engine/src/avatar/systems/TransparencyDitheringSystem.tsx
+++ b/packages/engine/src/avatar/systems/TransparencyDitheringSystem.tsx
@@ -38,6 +38,7 @@ import {
   useOptionalComponent
 } from '@etherealengine/ecs'
 import { useHookstate } from '@etherealengine/hyperflux'
+import { NameComponent } from '@etherealengine/spatial/src/common/NameComponent'
 import {
   MaterialComponent,
   MaterialComponents,
@@ -61,23 +62,17 @@ const execute = () => {
 
   for (const entity of TransparencyDitheringQuery()) {
     const ditherComponent = getComponent(entity, TransparencyDitheringComponent[0])
-    for (const uuid of ditherComponent.materialUUIDs) {
-      const materialComponent = getComponent(
-        UUIDComponent.getEntityByUUID(uuid),
-        MaterialComponent[MaterialComponents.State]
-      )
-      const material = materialComponent.material
-      if (!material) continue
+    for (const shader of ditherComponent.shaders) {
       for (let i = 0; i < maxDitherPoints; i++) {
         const ditherComponent = getOptionalComponent(entity, TransparencyDitheringComponent[i])
         if (!ditherComponent) break
-        if (!material.shader || !pluginComponent.shader) break
-        const shader = pluginComponent.shader[material.name]
-        if (!shader?.uniforms) break
-        shader.uniforms.centers.value[i] = ditherComponent.center
-        shader.uniforms.exponents.value[i] = ditherComponent.exponent
-        shader.uniforms.distances.value[i] = ditherComponent.distance
-        shader.uniforms.useWorldCalculation.value[i] = ditherComponent.calculationType
+        if (!pluginComponent.parameters) break
+        const parameters = pluginComponent.parameters[shader]
+        if (!parameters) break
+        parameters['centers'].value[i] = ditherComponent.center
+        parameters['exponents'].value[i] = ditherComponent.exponent
+        parameters['distances'].value[i] = ditherComponent.distance
+        parameters['useWorldCalculation'].value[i] = ditherComponent.calculationType
       }
     }
   }
@@ -92,7 +87,7 @@ const DitherReactor = () => {
 
   const modelComponent = useComponent(entity, ModelComponent)
   useEffect(() => {
-    getMutableComponent(entity, TransparencyDitheringComponent[0]).materialUUIDs.set([])
+    //getMutableComponent(entity, TransparencyDitheringComponent[0]).materialUUIDs.set([])
   }, [modelComponent.src])
 
   const sceneInstanceID = useModelSceneID(entity)
@@ -110,22 +105,21 @@ const DitherReactor = () => {
 const DitherChildReactor = (props: { entity: Entity; rootEntity: Entity }) => {
   const { entity, rootEntity } = props
 
-  const materialUUIDs = useComponent(rootEntity, TransparencyDitheringComponent[0]).materialUUIDs
+  //const materialUUIDs = useComponent(rootEntity, TransparencyDitheringComponent[0]).materialUUIDs
   const materialComponentUUID = useOptionalComponent(entity, MaterialComponent[MaterialComponents.Instance])?.uuid
   useEffect(() => {
     if (!materialComponentUUID?.value) return
     for (const materialUUID of materialComponentUUID.value) {
       const material = UUIDComponent.getEntityByUUID(materialUUID)
       const materialComponent = getMutableComponent(material, MaterialComponent[MaterialComponents.State])
+      const materialName = getComponent(material, NameComponent)
       if (materialComponent.pluginEntities.value)
-        materialComponent.pluginEntities.set([
-          ...materialComponent.pluginEntities.value,
-          pluginByName[TransparencyDitheringPlugin.id]
-        ])
+        materialComponent.pluginEntities.set([pluginByName[TransparencyDitheringPlugin.id]])
       materialComponent.material.value!.alphaTest = 0.5
       materialComponent.material.value!.side = FrontSide
       const ditheringComponent = getMutableComponent(rootEntity, TransparencyDitheringComponent[0])
-      ditheringComponent.materialUUIDs.set([...ditheringComponent.materialUUIDs.value, materialUUID])
+      if (!ditheringComponent.shaders.value.includes(materialName))
+        ditheringComponent.shaders.set([...ditheringComponent.shaders.value, materialName])
     }
   }, [materialComponentUUID])
 
diff --git a/packages/engine/src/scene/components/EnvMapBakeComponent.ts b/packages/engine/src/scene/components/EnvMapBakeComponent.ts
index d9ff349e25..aecac9e2fd 100644
--- a/packages/engine/src/scene/components/EnvMapBakeComponent.ts
+++ b/packages/engine/src/scene/components/EnvMapBakeComponent.ts
@@ -24,35 +24,15 @@ Ethereal Engine. All Rights Reserved.
 */
 
 import { useLayoutEffect } from 'react'
-import {
-  Mesh,
-  MeshLambertMaterial,
-  MeshPhysicalMaterial,
-  MeshStandardMaterial,
-  Object3D,
-  SphereGeometry,
-  Vector3
-} from 'three'
+import { MeshPhysicalMaterial, SphereGeometry, Vector3 } from 'three'
 
 import { getMutableState, useHookstate } from '@etherealengine/hyperflux'
 
-import {
-  defineComponent,
-  getComponent,
-  removeComponent,
-  setComponent
-} from '@etherealengine/ecs/src/ComponentFunctions'
-import { Entity } from '@etherealengine/ecs/src/Entity'
+import { defineComponent, removeComponent, setComponent } from '@etherealengine/ecs/src/ComponentFunctions'
 import { useEntityContext } from '@etherealengine/ecs/src/EntityFunctions'
 import { matches } from '@etherealengine/hyperflux'
 import { DebugMeshComponent } from '@etherealengine/spatial/src/common/debug/DebugMeshComponent'
 import { RendererState } from '@etherealengine/spatial/src/renderer/RendererState'
-import {
-  envmapParsReplaceLambert,
-  envmapPhysicalParsReplace,
-  envmapReplaceLambert,
-  worldposReplace
-} from '../classes/BPCEMShader'
 import { EnvMapBakeRefreshTypes } from '../types/EnvMapBakeRefreshTypes'
 import { EnvMapBakeTypes } from '../types/EnvMapBakeTypes'
 
@@ -122,47 +102,3 @@ export const EnvMapBakeComponent = defineComponent({
     return null
   }
 })
-
-// Hacky tentative solution, injects shader code into threejs' shaders for box projected envmaps
-// Depends on shader type to add pbr or non pbr shader logic
-export const applyBoxProjection = (entity: Entity, targets: Object3D[]) => {
-  const bakeComponent = getComponent(entity, EnvMapBakeComponent)
-  for (const target of targets) {
-    const child = target as Mesh<any, MeshStandardMaterial>
-    if (!child.material || child.type == 'VFXBatch') return
-
-    if (child.material instanceof MeshPhysicalMaterial || child.material instanceof MeshStandardMaterial) {
-      child.material = Object.assign(new MeshPhysicalMaterial(), child.material)
-      child.material.onBeforeCompile = (shader, renderer) => {
-        shader.uniforms.cubeMapSize = { value: bakeComponent.bakeScale }
-        shader.uniforms.cubeMapPos = { value: bakeComponent.bakePositionOffset }
-
-        if (!shader.vertexShader.startsWith('varying vec3 vWorldPosition'))
-          shader.vertexShader = 'varying vec3 vWorldPosition;\n' + shader.vertexShader
-
-        shader.vertexShader = shader.vertexShader.replace('#include <worldpos_vertex>', worldposReplace)
-
-        shader.fragmentShader = shader.fragmentShader.replace(
-          '#include <envmap_physical_pars_fragment>',
-          envmapPhysicalParsReplace
-        )
-      }
-    }
-    if ((child.material as any) instanceof MeshLambertMaterial) {
-      child.material.onBeforeCompile = function (shader) {
-        //these parameters are for the cubeCamera texture
-        shader.uniforms.cubeMapSize = { value: bakeComponent.bakeScale }
-        shader.uniforms.cubeMapPos = { value: bakeComponent.bakePositionOffset }
-        //replace shader chunks with box projection chunks
-
-        shader.fragmentShader = shader.fragmentShader.replace(
-          '#include <envmap_pars_fragment>',
-          envmapParsReplaceLambert
-        )
-        shader.fragmentShader = shader.fragmentShader.replace('#include <envmap_fragment>', envmapReplaceLambert)
-
-        shader.uniforms.envMap = { value: child.material.envMap }
-      }
-    }
-  }
-}
diff --git a/packages/engine/src/scene/components/EnvmapComponent.tsx b/packages/engine/src/scene/components/EnvmapComponent.tsx
index 47bcb0bd65..e0b77a1dc9 100644
--- a/packages/engine/src/scene/components/EnvmapComponent.tsx
+++ b/packages/engine/src/scene/components/EnvmapComponent.tsx
@@ -33,33 +33,49 @@ import {
   Mesh,
   MeshMatcapMaterial,
   MeshStandardMaterial,
+  Object3D,
   RGBAFormat,
   SRGBColorSpace,
-  Texture
+  Texture,
+  Vector3
 } from 'three'
 
 import { EntityUUID } from '@etherealengine/ecs'
-import { getMutableState, useHookstate } from '@etherealengine/hyperflux'
 
 import { isClient } from '@etherealengine/common/src/utils/getEnvironment'
 import { UUIDComponent } from '@etherealengine/ecs'
 import {
   defineComponent,
+  getComponent,
   getMutableComponent,
+  getOptionalMutableComponent,
+  setComponent,
   useComponent,
   useOptionalComponent
 } from '@etherealengine/ecs/src/ComponentFunctions'
 import { Entity } from '@etherealengine/ecs/src/Entity'
 import { useEntityContext } from '@etherealengine/ecs/src/EntityFunctions'
-import { RendererState } from '@etherealengine/spatial/src/renderer/RendererState'
+import { NameComponent } from '@etherealengine/spatial/src/common/NameComponent'
 import { GroupComponent } from '@etherealengine/spatial/src/renderer/components/GroupComponent'
 import { MeshComponent } from '@etherealengine/spatial/src/renderer/components/MeshComponent'
+import {
+  MaterialComponent,
+  MaterialComponents,
+  pluginByName
+} from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
+import { applyPluginShaderParameters } from '@etherealengine/spatial/src/renderer/materials/materialFunctions'
 import { createDisposable } from '@etherealengine/spatial/src/resources/resourceHooks'
 import { useTexture } from '../../assets/functions/resourceLoaderHooks'
+import {
+  envmapParsReplaceLambert,
+  envmapPhysicalParsReplace,
+  envmapReplaceLambert,
+  worldposReplace
+} from '../classes/BPCEMShader'
 import { EnvMapSourceType, EnvMapTextureType } from '../constants/EnvMapEnum'
 import { getRGBArray, loadCubeMapTexture } from '../constants/Util'
 import { addError, removeError } from '../functions/ErrorFunctions'
-import { EnvMapBakeComponent, applyBoxProjection } from './EnvMapBakeComponent'
+import { EnvMapBakeComponent } from './EnvMapBakeComponent'
 
 const tempColor = new Color()
 
@@ -210,18 +226,16 @@ const EnvBakeComponentReactor = (props: { envmapEntity: Entity; bakeEntity: Enti
   const { envmapEntity, bakeEntity } = props
   const bakeComponent = useComponent(bakeEntity, EnvMapBakeComponent)
   const group = useComponent(envmapEntity, GroupComponent)
-  const renderState = useHookstate(getMutableState(RendererState))
+  const uuid = useComponent(envmapEntity, MaterialComponent[MaterialComponents.Instance]).uuid
   const [envMaptexture, error] = useTexture(bakeComponent.envMapOrigin.value, envmapEntity)
-
-  /** @todo add an unmount cleanup for applyBoxprojection */
   useEffect(() => {
     const texture = envMaptexture
+    console.log(envmapEntity)
     if (!texture) return
-
     texture.mapping = EquirectangularReflectionMapping
     getMutableComponent(envmapEntity, EnvmapComponent).envmap.set(texture)
     if (bakeComponent.boxProjection.value) applyBoxProjection(bakeEntity, group.value)
-  }, [envMaptexture])
+  }, [envMaptexture, uuid])
 
   useEffect(() => {
     if (!error) return
@@ -256,3 +270,58 @@ export const updateEnvMapIntensity = (obj: Mesh<any, any> | null, intensity: num
     ;(obj.material as MeshStandardMaterial).envMapIntensity = intensity
   }
 }
+
+export type BoxProjectionParameters = {
+  cubeMapSize: Vector3
+  cubeMapPos: Vector3
+}
+
+export const BoxProjectionPlugin = {
+  id: 'BoxProjectionPlugin',
+  compile: (shader, renderer) => {
+    const pluginEntity = pluginByName[BoxProjectionPlugin.id]
+    const plugin = getOptionalMutableComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin])
+    if (!plugin) return
+
+    const shaderType = shader.shaderType
+    const isPhysical = shaderType === 'MeshStandardMaterial' || shaderType === 'MeshPhysicalMaterial'
+    const isSupported = isPhysical || shaderType === 'MeshLambertMaterial' || shaderType === 'MeshPhongMaterial'
+    if (!isSupported) return
+
+    if (isPhysical) {
+      if (!shader.vertexShader.startsWith('varying vec3 vWorldPosition'))
+        shader.vertexShader = 'varying vec3 vWorldPosition;\n' + shader.vertexShader
+      shader.vertexShader = shader.vertexShader.replace('#include <worldpos_vertex>', worldposReplace)
+      shader.fragmentShader = shader.fragmentShader.replace(
+        '#include <envmap_physical_pars_fragment>',
+        envmapPhysicalParsReplace
+      )
+    } else {
+      shader.fragmentShader = shader.fragmentShader.replace('#include <envmap_pars_fragment>', envmapParsReplaceLambert)
+      shader.fragmentShader = shader.fragmentShader.replace('#include <envmap_fragment>', envmapReplaceLambert)
+    }
+
+    applyPluginShaderParameters(pluginEntity, shader, {
+      cubeMapSize: new Vector3(0, 0, 0),
+      cubeMapPos: new Vector3(0, 0, 0)
+    })
+  }
+}
+
+const applyBoxProjection = (entity: Entity, targets: Object3D[]) => {
+  const bakeComponent = getComponent(entity, EnvMapBakeComponent)
+  for (const target of targets) {
+    const child = target as Mesh<any, MeshStandardMaterial>
+    if (!child.material || child.type == 'VFXBatch') return
+
+    const pluginEntity = pluginByName[BoxProjectionPlugin.id]
+    const materialEntity = UUIDComponent.getEntityByUUID(child.material.uuid as EntityUUID)
+    setComponent(materialEntity, MaterialComponent[MaterialComponents.State], { pluginEntities: [pluginEntity] })
+    getMutableComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin]).parameters[
+      getComponent(materialEntity, NameComponent)
+    ].set({
+      cubeMapSize: { value: bakeComponent.bakeScale },
+      cubeMapPos: { value: bakeComponent.bakePositionOffset }
+    })
+  }
+}
diff --git a/packages/engine/src/scene/materials/functions/materialSourcingFunctions.ts b/packages/engine/src/scene/materials/functions/materialSourcingFunctions.ts
index f518059254..c1cd08f74e 100644
--- a/packages/engine/src/scene/materials/functions/materialSourcingFunctions.ts
+++ b/packages/engine/src/scene/materials/functions/materialSourcingFunctions.ts
@@ -44,10 +44,12 @@ import {
   MaterialComponents,
   materialByHash,
   materialByName,
+  pluginByName,
   prototypeByName
 } from '@etherealengine/spatial/src/renderer/materials/MaterialComponent'
 import { extractDefaults } from '@etherealengine/spatial/src/renderer/materials/materialFunctions'
 import { Material } from 'three'
+import { MaterialExtensionPluginType } from '../../../assets/exporters/gltf/extensions/EEMaterialExporterExtension'
 import { SourceComponent } from '../../components/SourceComponent'
 import { getModelSceneID } from '../../functions/loaders/ModelFunctions'
 
@@ -109,7 +111,7 @@ export const createMaterialInstance = (path: string, sourceEntity: Entity, mater
   }
 }
 
-export const createMaterialEntity = (material: Material, path: string) => {
+export const createMaterialEntity = (material: Material, path: string, user?: Entity) => {
   const materialEntity = createEntity()
   setComponent(materialEntity, UUIDComponent, material.uuid as EntityUUID)
   setComponent(materialEntity, SourceComponent, path)
@@ -123,10 +125,25 @@ export const createMaterialEntity = (material: Material, path: string) => {
           getComponent(prototypeEntity, MaterialComponent[MaterialComponents.Prototype]).prototypeArguments
         )
       ).map((k) => [k, material[k]])
-    )
+    ),
+    instances: user != undefined ? [user] : [],
+    pluginEntities: material.userData.plugins
+      ? material.userData.plugins.map((plugin: MaterialExtensionPluginType) => pluginByName[plugin.id])
+      : []
   })
+  if (material.userData?.plugins) {
+    for (const pluginEntity of getComponent(materialEntity, MaterialComponent[MaterialComponents.State])
+      .pluginEntities!) {
+      getMutableComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin]).parameters[
+        getComponent(materialEntity, NameComponent)
+      ].set(
+        material.userData.plugins.find(
+          (plugin: MaterialExtensionPluginType) => plugin.id === getComponent(pluginEntity, NameComponent)
+        ).parameters
+      )
+    }
+  }
   setMaterialName(materialEntity, material.name)
-
   return materialEntity
 }
 
@@ -146,6 +163,7 @@ export const getPrototypeConstructorFromName = (name: string) => {
 
 /**Sets a unique name and source hash for a given material entity */
 export const setMaterialName = (entity: Entity, name: string) => {
+  if (name === '') name = 'Material'
   const materialComponent = getMutableComponent(entity, MaterialComponent[MaterialComponents.State])
   if (!materialComponent.material.value) return
   const oldName = getOptionalComponent(entity, NameComponent)
@@ -170,27 +188,17 @@ export const setMaterialName = (entity: Entity, name: string) => {
 }
 
 const uniqueSuffix = (name: string) => {
-  let i = 0
+  let i = 1
   while (materialByName[`${name}${i}`]) i++
   return `${name}${i}`
 }
 
-// export function registerMaterialPlugin(component: MaterialPluginType) {
-//   const materialLibrary = getMutableState(MaterialLibraryState)
-//   const src = component.src
-//   addMaterialSource(src)
-//   const srcItems = getSourceItems(src)!
-//   !srcItems.includes(component.plugin.id) &&
-//     materialLibrary.sources[hashMaterialSource(component.src)].entries.set([...srcItems, component.plugin.id])
-//   materialLibrary.plugins[component.plugin.id].set(component)
-// }
-
 export const injectMaterialDefaults = (materialUUID: EntityUUID) => {
-  const material = getComponent(
+  const material = getOptionalComponent(
     UUIDComponent.getEntityByUUID(materialUUID),
     MaterialComponent[MaterialComponents.State]
   )
-  if (!material.prototypeEntity) return
+  if (!material?.prototypeEntity) return
   const prototype = getComponent(
     material.prototypeEntity,
     MaterialComponent[MaterialComponents.Prototype]
diff --git a/packages/engine/src/scene/materials/systems/MaterialLibrarySystem.tsx b/packages/engine/src/scene/materials/systems/MaterialLibrarySystem.tsx
index e9698b5e97..18986ff40f 100644
--- a/packages/engine/src/scene/materials/systems/MaterialLibrarySystem.tsx
+++ b/packages/engine/src/scene/materials/systems/MaterialLibrarySystem.tsx
@@ -28,7 +28,7 @@ import React, { ReactElement, useEffect } from 'react'
 import {
   PresentationSystemGroup,
   QueryReactor,
-  getComponent,
+  getOptionalComponent,
   useComponent,
   useEntityContext
 } from '@etherealengine/ecs'
@@ -81,7 +81,7 @@ const MaterialEntityReactor = () => {
     if (materialComponent.instances.value)
       for (const sourceEntity of materialComponent.instances.value) {
         iterateEntityNode(sourceEntity, (childEntity) => {
-          const uuid = getComponent(childEntity, MaterialComponent[MaterialComponents.Instance]).uuid
+          const uuid = getOptionalComponent(childEntity, MaterialComponent[MaterialComponents.Instance])?.uuid
           if (uuid) setGroupMaterial(childEntity, uuid)
         })
       }
diff --git a/packages/engine/src/scene/systems/SceneObjectSystem.tsx b/packages/engine/src/scene/systems/SceneObjectSystem.tsx
index 0e60c8925d..1710d3f40a 100644
--- a/packages/engine/src/scene/systems/SceneObjectSystem.tsx
+++ b/packages/engine/src/scene/systems/SceneObjectSystem.tsx
@@ -138,7 +138,7 @@ export function setupObject(obj: Object3D, entity: Entity, forceBasicMaterials =
       newBasicMaterial.envMap = prevMaterial.envMap
       newBasicMaterial.vertexColors = prevMaterial.vertexColors
       newBasicMaterial.uuid = basicUUID
-      createMaterialEntity(newBasicMaterial, '')
+      createMaterialEntity(newBasicMaterial, '', entity)
       setComponent(entity, MaterialComponent[MaterialComponents.Instance], { uuid: [basicUUID] })
     } else {
       const UUID = child.material.uuid as EntityUUID
diff --git a/packages/spatial/src/common/functions/OnBeforeCompilePlugin.ts b/packages/spatial/src/common/functions/OnBeforeCompilePlugin.ts
index 7824b2b3e9..f669ed7766 100644
--- a/packages/spatial/src/common/functions/OnBeforeCompilePlugin.ts
+++ b/packages/spatial/src/common/functions/OnBeforeCompilePlugin.ts
@@ -50,7 +50,6 @@ import {
 export type PluginObjectType = {
   id: string
   priority?: number
-  parameters?: { [key: string]: any }
   compile: typeof Material.prototype.onBeforeCompile
 }
 
diff --git a/packages/spatial/src/renderer/materials/MaterialComponent.ts b/packages/spatial/src/renderer/materials/MaterialComponent.ts
index e5e8f2c916..83c9fd1fae 100644
--- a/packages/spatial/src/renderer/materials/MaterialComponent.ts
+++ b/packages/spatial/src/renderer/materials/MaterialComponent.ts
@@ -32,6 +32,7 @@ import {
 } from '@etherealengine/ecs'
 import { Entity, EntityUUID, UndefinedEntity } from '@etherealengine/ecs/src/Entity'
 import { TransparencyDitheringPlugin } from '@etherealengine/engine/src/avatar/components/TransparencyDitheringComponent'
+import { BoxProjectionPlugin } from '@etherealengine/engine/src/scene/components/EnvmapComponent'
 import { PluginObjectType, PluginType } from '@etherealengine/spatial/src/common/functions/OnBeforeCompilePlugin'
 import { Material, Shader, WebGLRenderer } from 'three'
 import { NoiseOffsetPlugin } from './constants/plugins/NoiseOffsetPlugin'
@@ -80,7 +81,7 @@ export const MaterialPrototypeDefinitions = [
   ShadowMaterial
 ] as MaterialPrototypeDefinition[]
 
-export const MaterialPlugins = [NoiseOffsetPlugin, TransparencyDitheringPlugin]
+export const MaterialPlugins = [NoiseOffsetPlugin, TransparencyDitheringPlugin, BoxProjectionPlugin]
 
 export enum MaterialComponents {
   Instance,
@@ -109,6 +110,7 @@ export const MaterialComponent = Array.from({ length: 4 }, (_, i) => {
             // material & material specific data
             material: {} as Material,
             parameters: {} as { [key: string]: any },
+            // all entities using this material. an undefined entity at index 0 is a fake user
             instances: [] as Entity[],
             pluginEntities: [] as Entity[],
             prototypeEntity: UndefinedEntity as Entity
@@ -123,7 +125,7 @@ export const MaterialComponent = Array.from({ length: 4 }, (_, i) => {
           return {
             // plugin state
             plugin: {} as PluginObjectType,
-            shader: {} as Record<string, Shader>
+            parameters: {} as { [key: string]: any }
           }
         default:
           return {}
diff --git a/packages/spatial/src/renderer/materials/constants/plugins/NoiseOffsetPlugin.ts b/packages/spatial/src/renderer/materials/constants/plugins/NoiseOffsetPlugin.ts
index a2d6ef1e71..a078bafa25 100644
--- a/packages/spatial/src/renderer/materials/constants/plugins/NoiseOffsetPlugin.ts
+++ b/packages/spatial/src/renderer/materials/constants/plugins/NoiseOffsetPlugin.ts
@@ -23,50 +23,53 @@ All portions of the code written by the Ethereal Engine team are Copyright © 20
 Ethereal Engine. All Rights Reserved.
 */
 
-import { useEffect } from 'react'
-import { IUniform, Uniform } from 'three'
+import { Uniform, Vector3 } from 'three'
 
 import { getState } from '@etherealengine/hyperflux'
 
-import { isClient } from '@etherealengine/common/src/utils/getEnvironment'
-import { getComponent, PresentationSystemGroup, useComponent } from '@etherealengine/ecs'
+import { getComponent, getOptionalComponent, PresentationSystemGroup } from '@etherealengine/ecs'
 import { ECSState } from '@etherealengine/ecs/src/ECSState'
 import { defineSystem } from '@etherealengine/ecs/src/SystemFunctions'
 import { generateNoiseTexture } from '@etherealengine/spatial/src/renderer/functions/generateNoiseTexture'
 import { PluginObjectType } from '../../../../common/functions/OnBeforeCompilePlugin'
-import { MaterialComponent, MaterialComponents } from '../../MaterialComponent'
-import { getPluginByName } from '../../materialFunctions'
-
-let time: IUniform | null = null
+import { MaterialComponent, MaterialComponents, pluginByName } from '../../MaterialComponent'
+import { applyPluginShaderParameters } from '../../materialFunctions'
+
+export type NoiseOffsetParameters = {
+  textureSize: Uniform
+  frequency: Uniform
+  noiseTexture: Uniform
+  time: Uniform
+  offsetAxis: Uniform
+}
 
 export const NoiseOffsetPlugin: PluginObjectType = {
   id: 'noiseOffset',
   priority: 0.4,
-  parameters: {
-    noiseTexture: null,
-    textureSize: 128,
-    frequency: 0.001
-  },
   compile: (shader, renderer) => {
-    const plugin = getComponent(getPluginByName(NoiseOffsetPlugin.id), MaterialComponent[MaterialComponents.Plugin])
-    if (!plugin) return
-    const parameters = plugin.parameters!
-    shader.uniforms['textureSize'] = new Uniform(parameters.textureSize)
-    shader.uniforms['noiseTexture'] = new Uniform(parameters.noiseTexture)
-    shader.uniforms['frequency'] = new Uniform(parameters.frequency)
-    const elapsedSeconds = getState(ECSState).elapsedSeconds
-    time = new Uniform(elapsedSeconds)
-    shader.uniforms['time'] = time
+    const pluginEntity = pluginByName[NoiseOffsetPlugin.id]
+    const plugin = getComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin])
+    if (!plugin || !plugin.parameters) return
+    applyPluginShaderParameters(pluginEntity, shader, {
+      textureSize: 64,
+      frequency: 0.00025,
+      amplitude: 0.005,
+      noiseTexture: generateNoiseTexture(64),
+      offsetAxis: new Vector3(0, 1, 0),
+      time: 0
+    })
+
     shader.vertexShader = shader.vertexShader.replace(
       'void main() {',
       `
         uniform sampler2D noiseTexture;
         uniform float textureSize; // The width of a slice
         uniform float frequency;
+        uniform float amplitude;
         uniform float time;
 
         vec3 sampleNoise(vec3 pos) {
-            float zSlice = floor(pos.z * textureSize);
+            float zSlice = (pos.z * textureSize);
             vec2 slicePos = vec2(zSlice / textureSize, fract(zSlice / textureSize));
             vec2 noisePos = slicePos + pos.xy / textureSize;
             return vec3(texture2D(noiseTexture, noisePos).r);
@@ -74,18 +77,17 @@ export const NoiseOffsetPlugin: PluginObjectType = {
 
         vec3 turbulence(vec3 position) {
           vec3 sum = vec3(0.0);
-          float frequency = 0.01;
-          float amplitude = 0.5;
+          float frequencyMutliplied = frequency;
+          float amplitudeMultiplied = amplitude;
 
           for (int i = 0; i < 4; i++) {
-              vec3 p = position * frequency;
-              p.z += time * 0.002;
-              p = fract(p);
-          
-              sum += sampleNoise(p).rgb * amplitude;
+              vec3 p = position * frequencyMutliplied;
+              p.z += time * 0.0015;
+
+              sum += sampleNoise(p).rgb * amplitudeMultiplied;
           
-              frequency *= 2.0;
-              amplitude *= 0.5;
+              frequencyMutliplied *= 2.0;
+              amplitudeMultiplied *= 7.0;
           }
         
           return sum;
@@ -94,19 +96,21 @@ export const NoiseOffsetPlugin: PluginObjectType = {
         void main() {
       `
     )
+    shader.vertexShader = shader.vertexShader.replace(
+      'void main() {',
+      `uniform vec3 offsetAxis;
+    void main() {`
+    )
     shader.vertexShader = shader.vertexShader.replace(
       '#include <begin_vertex>',
       `
         #include <begin_vertex>
-        float yMagnitude = smoothstep(0.2, 0.7, position.y);
         vec4 noiseWorldPosition = vec4(transformed, 1.0);
         noiseWorldPosition = modelMatrix * noiseWorldPosition;
         #ifdef USE_INSTANCING
           noiseWorldPosition = instanceMatrix * noiseWorldPosition;
         #endif
-        vec3 offset = turbulence(noiseWorldPosition.xyz) * 1.0;
-        offset.y *= 0.2;
-        //offset *= yMagnitude;
+        vec3 offset = turbulence(noiseWorldPosition.xyz) * offsetAxis;
         transformed += offset;
       `
     )
@@ -114,31 +118,17 @@ export const NoiseOffsetPlugin: PluginObjectType = {
 }
 
 const execute = () => {
-  if (!time) return
-  const elapsedSeconds = getState(ECSState).elapsedSeconds
-  time.value = elapsedSeconds
-}
-
-const reactor = () => {
-  if (!isClient) return null
-
-  const noiseOffset = useComponent(getPluginByName(NoiseOffsetPlugin.id), MaterialComponent[MaterialComponents.Plugin])
-
-  useEffect(() => {
-    if (!noiseOffset?.value || noiseOffset.parameters['noiseTexture']) return
-
-    time = noiseOffset.parameters.value!['time']
-    // Create new Perlin noise instance
-    const noiseTexture = generateNoiseTexture(noiseOffset.parameters['textureSize'].value)
-    noiseOffset.parameters['noiseTexture'].set(noiseTexture)
-  }, [noiseOffset])
-
-  return null
+  const plugin = getOptionalComponent(pluginByName[NoiseOffsetPlugin.id], MaterialComponent[MaterialComponents.Plugin])
+  if (!plugin || !plugin.parameters) return
+  for (const key in plugin.parameters) {
+    const parameters = plugin.parameters[key] as NoiseOffsetParameters
+    const elapsedSeconds = getState(ECSState).elapsedSeconds
+    parameters.time.value = elapsedSeconds
+  }
 }
 
 export const NoiseOffsetSystem = defineSystem({
   uuid: 'ee.spatial.material.NoiseOffsetSystem',
   insert: { before: PresentationSystemGroup },
-  execute,
-  reactor
+  execute
 })
diff --git a/packages/spatial/src/renderer/materials/materialFunctions.ts b/packages/spatial/src/renderer/materials/materialFunctions.ts
index 9f8407036d..42d8d6a7c0 100644
--- a/packages/spatial/src/renderer/materials/materialFunctions.ts
+++ b/packages/spatial/src/renderer/materials/materialFunctions.ts
@@ -30,11 +30,12 @@ import {
   createEntity,
   generateEntityUUID,
   getComponent,
+  getMutableComponent,
   getOptionalMutableComponent,
   setComponent
 } from '@etherealengine/ecs'
 import { isArray } from 'lodash'
-import { Color, Mesh, Texture } from 'three'
+import { Color, Mesh, Shader, Texture, Uniform } from 'three'
 import { NameComponent } from '../../common/NameComponent'
 import { PluginObjectType, addOBCPlugin, hasOBCPlugin } from '../../common/functions/OnBeforeCompilePlugin'
 import { GroupComponent } from '../components/GroupComponent'
@@ -44,7 +45,6 @@ import {
   MaterialPrototypeDefinition,
   MaterialPrototypeObjectConstructor,
   pluginByName,
-  pluginQuery,
   prototypeByName
 } from './MaterialComponent'
 
@@ -108,12 +108,8 @@ export const addMaterialPlugin = (materialEntity: Entity, pluginEntity: Entity)
   })
 }
 
-export const getPluginByName = (name: string) => {
-  return pluginQuery().filter((plugin) => getComponent(plugin, NameComponent) === name)[0]
-}
-
 export const getPluginObject = (pluginId: string) => {
-  const pluginEntity = getPluginByName(pluginId)
+  const pluginEntity = pluginByName[pluginId]
   const plugin = getOptionalMutableComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin])?.plugin
   return plugin
 }
@@ -130,6 +126,22 @@ export const applyMaterialPlugins = (materialEntity: Entity) => {
   }
 }
 
+export const applyPluginShaderParameters = (
+  pluginEntity: Entity,
+  shader: Shader,
+  parameters: { [key: string]: any }
+) => {
+  const pluginComponent = getMutableComponent(pluginEntity, MaterialComponent[MaterialComponents.Plugin])
+  const name = (shader as any).shaderName
+  if (!pluginComponent.parameters[name].value) pluginComponent.parameters[name].set({})
+  const parameterObject = pluginComponent.parameters[name]
+  for (const key in parameters) {
+    const parameterExists = !!parameterObject[key].value
+    if (!parameterExists) parameterObject[key].set(new Uniform(parameters[key]))
+    shader.uniforms[key] = parameterObject[key].value
+  }
+}
+
 export const getMaterial = (uuid: EntityUUID) => {
   return getComponent(UUIDComponent.getEntityByUUID(uuid), MaterialComponent[MaterialComponents.State]).material!
 }
@@ -153,12 +165,12 @@ export const updateMaterialPrototype = (materialEntity: Entity) => {
   const material = materialComponent.material
   if (!material || material.type === prototypeName) return
   const matKeys = Object.keys(material)
-  const commonParms = Object.fromEntries(
+  const commonParameters = Object.fromEntries(
     Object.keys(prototypeComponent.prototypeArguments)
       .filter((key) => matKeys.includes(key))
       .map((key) => [key, material[key]])
   )
-  const fullParameters = { ...extractDefaults(prototypeComponent.prototypeArguments), ...commonParms }
+  const fullParameters = { ...extractDefaults(prototypeComponent.prototypeArguments), ...commonParameters }
   const newMaterial = new prototypeConstructor(fullParameters)
   if (newMaterial.plugins) {
     newMaterial.customProgramCacheKey = () =>