Rename TextureFrame to ImageTexture

Author: Keavon

editor/src/messages/portfolio/document/node_graph/node_properties.rs

@@ -19,7 +19,7 @@ use graphene_core::raster::{
 use graphene_core::text::Font;
 use graphene_core::vector::misc::CentroidType;
 use graphene_core::vector::style::{GradientType, LineCap, LineJoin};
-use graphene_std::application_io::TextureFrame;
+use graphene_std::application_io::TextureFrameTable;
 use graphene_std::transform::Footprint;
 use graphene_std::vector::misc::BooleanOperation;
 use graphene_std::vector::style::{Fill, FillChoice, FillType, GradientStops};
@@ -154,7 +154,7 @@ pub(crate) fn property_from_type(node_id: NodeId, index: usize, ty: &Type, numbe
 						Some(x) if x == TypeId::of::<Curve>() => curves_widget(document_node, node_id, index, name, true),
 						Some(x) if x == TypeId::of::<GradientStops>() => color_widget(document_node, node_id, index, name, ColorButton::default().allow_none(false), true),
 						Some(x) if x == TypeId::of::<VectorDataTable>() => vector_widget(document_node, node_id, index, name, true).into(),
-						Some(x) if x == TypeId::of::<RasterFrame>() || x == TypeId::of::<ImageFrameTable<Color>>() || x == TypeId::of::<TextureFrame>() => {
+						Some(x) if x == TypeId::of::<RasterFrame>() || x == TypeId::of::<ImageFrameTable<Color>>() || x == TypeId::of::<TextureFrameTable>() => {
 							raster_widget(document_node, node_id, index, name, true).into()
 						}
 						Some(x) if x == TypeId::of::<GraphicGroupTable>() => group_widget(document_node, node_id, index, name, true).into(),

node-graph/gcore/src/application_io.rs

@@ -64,24 +64,25 @@ impl Size for web_sys::HtmlCanvasElement {
 	}
 }
 
-pub type TextureFrameTable = Instances<TextureFrame>;
+// TODO: Rename to ImageTextureTable
+pub type TextureFrameTable = Instances<ImageTexture>;
 
 #[derive(Debug, Clone)]
-pub struct TextureFrame {
+pub struct ImageTexture {
 	#[cfg(feature = "wgpu")]
 	pub texture: Arc<wgpu::Texture>,
 	#[cfg(not(feature = "wgpu"))]
 	pub texture: (),
 }
 
-impl Hash for TextureFrame {
+impl Hash for ImageTexture {
 	fn hash<H: Hasher>(&self, state: &mut H) {
 		#[cfg(feature = "wgpu")]
 		self.texture.hash(state);
 	}
 }
 
-impl PartialEq for TextureFrame {
+impl PartialEq for ImageTexture {
 	fn eq(&self, other: &Self) -> bool {
 		#[cfg(feature = "wgpu")]
 		return self.texture == other.texture;
@@ -91,12 +92,12 @@ impl PartialEq for TextureFrame {
 	}
 }
 
-unsafe impl StaticType for TextureFrame {
-	type Static = TextureFrame;
+unsafe impl StaticType for ImageTexture {
+	type Static = ImageTexture;
 }
 
 #[cfg(feature = "wgpu")]
-impl Size for TextureFrame {
+impl Size for ImageTexture {
 	fn size(&self) -> UVec2 {
 		UVec2::new(self.texture.width(), self.texture.height())
 	}

node-graph/gcore/src/graphic_element.rs

@@ -1,4 +1,4 @@
-use crate::application_io::{TextureFrame, TextureFrameTable};
+use crate::application_io::{ImageTexture, TextureFrameTable};
 use crate::instances::Instances;
 use crate::raster::image::{Image, ImageFrameTable};
 use crate::raster::BlendMode;
@@ -106,9 +106,9 @@ impl From<ImageFrameTable<Color>> for GraphicGroupTable {
 		Self::new(GraphicGroup::new(vec![GraphicElement::RasterFrame(RasterFrame::ImageFrame(image_frame))]))
 	}
 }
-impl From<TextureFrame> for GraphicGroupTable {
-	fn from(texture_frame: TextureFrame) -> Self {
-		Self::new(GraphicGroup::new(vec![GraphicElement::RasterFrame(RasterFrame::TextureFrame(TextureFrameTable::new(texture_frame)))]))
+impl From<ImageTexture> for GraphicGroupTable {
+	fn from(image_texture: ImageTexture) -> Self {
+		Self::new(GraphicGroup::new(vec![GraphicElement::RasterFrame(RasterFrame::TextureFrame(TextureFrameTable::new(image_texture)))]))
 	}
 }
 impl From<TextureFrameTable> for GraphicGroupTable {
@@ -179,11 +179,14 @@ impl GraphicElement {
 	}
 }
 
+// TODO: Rename to Raster
 #[derive(Clone, Debug, Hash, PartialEq, DynAny)]
 pub enum RasterFrame {
 	/// A CPU-based bitmap image with a finite position and extent, equivalent to the SVG <image> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/image
+	// TODO: Rename to ImageTable
 	ImageFrame(ImageFrameTable<Color>),
 	/// A GPU texture with a finite position and extent
+	// TODO: Rename to ImageTextureTable
 	TextureFrame(TextureFrameTable),
 }
 
@@ -224,7 +227,7 @@ impl Artboard {
 	pub fn new(location: IVec2, dimensions: IVec2) -> Self {
 		Self {
 			graphic_group: GraphicGroupTable::default(),
-			label: String::from("Artboard"),
+			label: "Artboard".to_string(),
 			location: location.min(location + dimensions),
 			dimensions: dimensions.abs(),
 			background: Color::WHITE,
@@ -375,7 +378,8 @@ async fn append_artboard<C: Ctx + Clone + 'n>(
 	let artboard = artboard.eval(ctx).await;
 	// let foot = ctx.footprint();
 	// log::debug!("{:?}", foot);
-	// Get the penultimate element of the node path, or None if the path is too short
+	// Get the penultimate element of the node path, or None if the path is too short.
+	// This is used to get the ID of the user-facing "Artboard" node (which encapsulates this internal "Append Artboard" node).
 	let encapsulating_node_id = node_path.get(node_path.len().wrapping_sub(2)).copied();
 	artboards.append_artboard(artboard, encapsulating_node_id);
 
@@ -394,8 +398,8 @@ impl From<ImageFrameTable<Color>> for GraphicElement {
 	}
 }
 // TODO: Remove this one
-impl From<TextureFrame> for GraphicElement {
-	fn from(texture: TextureFrame) -> Self {
+impl From<ImageTexture> for GraphicElement {
+	fn from(texture: ImageTexture) -> Self {
 		GraphicElement::RasterFrame(RasterFrame::TextureFrame(TextureFrameTable::new(texture)))
 	}
 }
@@ -446,7 +450,7 @@ trait ToGraphicElement: Into<GraphicElement> {}
 
 impl ToGraphicElement for VectorDataTable {}
 impl ToGraphicElement for ImageFrameTable<Color> {}
-impl ToGraphicElement for TextureFrame {}
+impl ToGraphicElement for ImageTexture {}
 
 impl<T> From<T> for GraphicGroup
 where

node-graph/gcore/src/graphic_element/renderer.rs

@@ -276,6 +276,7 @@ pub struct RenderMetadata {
 	pub clip_targets: HashSet<NodeId>,
 }
 
+// TODO: Rename to "Graphical"
 pub trait GraphicElementRendered {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams);
 
@@ -992,8 +993,8 @@ impl GraphicElementRendered for RasterFrame {
 		};
 
 		match self {
-			RasterFrame::ImageFrame(image_frame) => {
-				for instance in image_frame.instances() {
+			RasterFrame::ImageFrame(image) => {
+				for instance in image.instances() {
 					let image = &instance.instance;
 					if image.data.is_empty() {
 						return;
@@ -1004,8 +1005,8 @@ impl GraphicElementRendered for RasterFrame {
 					render_stuff(image, *instance.alpha_blending);
 				}
 			}
-			RasterFrame::TextureFrame(texture) => {
-				for instance in texture.instances() {
+			RasterFrame::TextureFrame(image_texture) => {
+				for instance in image_texture.instances() {
 					let image =
 						vello::peniko::Image::new(vec![].into(), peniko::Format::Rgba8, instance.instance.texture.width(), instance.instance.texture.height()).with_extend(peniko::Extend::Repeat);
 

node-graph/gcore/src/instances.rs

@@ -1,4 +1,4 @@
-use crate::application_io::{TextureFrame, TextureFrameTable};
+use crate::application_io::{ImageTexture, TextureFrameTable};
 use crate::raster::image::{Image, ImageFrameTable};
 use crate::raster::Pixel;
 use crate::transform::{Transform, TransformMut};
@@ -171,18 +171,18 @@ impl TransformMut for GraphicGroupTable {
 	}
 }
 
-// TEXTURE FRAME
-impl Transform for Instance<'_, TextureFrame> {
+// IMAGE TEXTURE
+impl Transform for Instance<'_, ImageTexture> {
 	fn transform(&self) -> DAffine2 {
 		*self.transform
 	}
 }
-impl Transform for InstanceMut<'_, TextureFrame> {
+impl Transform for InstanceMut<'_, ImageTexture> {
 	fn transform(&self) -> DAffine2 {
 		*self.transform
 	}
 }
-impl TransformMut for InstanceMut<'_, TextureFrame> {
+impl TransformMut for InstanceMut<'_, ImageTexture> {
 	fn transform_mut(&mut self) -> &mut DAffine2 {
 		self.transform
 	}

node-graph/gcore/src/raster/image.rs

@@ -53,6 +53,8 @@ pub struct Image<P: Pixel> {
 	/// to an svg string. This is used as a cache in order to not have to encode the data on every graph evaluation.
 	#[cfg_attr(feature = "serde", serde(skip))]
 	pub base64_string: Option<String>,
+	// TODO: Add an `origin` field to store where in the local space the image is anchored.
+	// TODO: Currently it is always anchored at the top left corner at (0, 0). The bottom right corner of the new origin field would correspond to (1, 1).
 }
 
 impl<P: Pixel + Debug> Debug for Image<P> {
@@ -256,6 +258,7 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 	})
 }
 
+// TODO: Rename to ImageTable
 pub type ImageFrameTable<P> = Instances<Image<P>>;
 
 /// Construct a 0x0 image frame table. This is useful because ImageFrameTable::default() will return a 1x1 image frame table.

node-graph/interpreted-executor/src/node_registry.rs

@@ -12,7 +12,7 @@ use graphene_core::{concrete, generic, Artboard, GraphicGroupTable};
 use graphene_core::{Cow, ProtoNodeIdentifier, Type};
 use graphene_core::{Node, NodeIO, NodeIOTypes};
 use graphene_std::any::{ComposeTypeErased, DowncastBothNode, DynAnyNode, FutureWrapperNode, IntoTypeErasedNode};
-use graphene_std::application_io::TextureFrame;
+use graphene_std::application_io::ImageTexture;
 use graphene_std::wasm_application_io::*;
 use graphene_std::Context;
 use graphene_std::GraphicElement;
@@ -122,7 +122,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::ops::IntoNode<GraphicGroupTable>, input: VectorDataTable, params: []),
 		async_node!(graphene_core::ops::IntoNode<GraphicGroupTable>, input: ImageFrameTable<Color>, params: []),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => ImageFrameTable<Color>]),
-		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => TextureFrame]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => ImageTexture]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => VectorDataTable]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => GraphicGroupTable]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => GraphicElement]),
@@ -293,7 +293,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => ShaderInputFrame]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => WgpuSurface]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Option<WgpuSurface>]),
-		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => TextureFrame]),
+		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => ImageTexture]),
 	];
 	let mut map: HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeConstructor>> = HashMap::new();
 	for (id, entry) in graphene_core::registry::NODE_REGISTRY.lock().unwrap().iter() {

node-graph/wgpu-executor/src/lib.rs

@@ -6,7 +6,7 @@ pub use executor::GpuExecutor;
 
 use dyn_any::{DynAny, StaticType};
 use gpu_executor::{ComputePassDimensions, GPUConstant, StorageBufferOptions, TextureBufferOptions, TextureBufferType, ToStorageBuffer, ToUniformBuffer};
-use graphene_core::application_io::{ApplicationIo, EditorApi, SurfaceHandle, TextureFrame};
+use graphene_core::application_io::{ApplicationIo, EditorApi, ImageTexture, SurfaceHandle};
 use graphene_core::raster::image::ImageFrameTable;
 use graphene_core::raster::{Image, SRGBA8};
 use graphene_core::transform::{Footprint, Transform};
@@ -912,7 +912,7 @@ async fn render_texture<'a: 'n>(
 }
 
 #[node_macro::node(category(""))]
-async fn upload_texture<'a: 'n>(_: impl ExtractFootprint + Ctx, input: ImageFrameTable<Color>, executor: &'a WgpuExecutor) -> TextureFrame {
+async fn upload_texture<'a: 'n>(_: impl ExtractFootprint + Ctx, input: ImageFrameTable<Color>, executor: &'a WgpuExecutor) -> ImageTexture {
 	// let new_data: Vec<RGBA16F> = input.image.data.into_iter().map(|c| c.into()).collect();
 
 	let input = input.one_instance().instance;
@@ -931,9 +931,9 @@ async fn upload_texture<'a: 'n>(_: impl ExtractFootprint + Ctx, input: ImageFram
 		_ => unreachable!("Unsupported ShaderInput type"),
 	};
 
-	TextureFrame {
+	ImageTexture {
 		texture: texture.into(),
-		// TODO: Find an alternate way to encode the transform and alpha_blend now that these fields have been moved up out of TextureFrame
+		// TODO: Find an alternate way to encode the transform and alpha_blend now that these fields have been moved up out of ImageTexture
 		// transform: input.transform,
 		// alpha_blend: Default::default(),
 	}