armory3d.armortools/paint/sources/util_render.ts

let util_render_material_preview_size: i32           = 256;
let util_render_node_preview_size: i32               = 512;
let util_render_decal_preview_size: i32              = 512;
let util_render_layer_preview_size: i32              = 200;
let util_render_font_preview_size: i32               = 200;
let util_render_screen_aligned_full_vb: gpu_buffer_t = null;
let util_render_screen_aligned_full_ib: gpu_buffer_t = null;

function util_render_make_material_preview() {
	context_raw.material_preview = true;

	let sphere: mesh_object_t   = scene_get_child(".Sphere").ext;
	sphere.base.visible         = true;
	let meshes: mesh_object_t[] = scene_meshes;
	scene_meshes                = [ sphere ];
	let painto: mesh_object_t   = context_raw.paint_object;
	context_raw.paint_object    = sphere;

	sphere.material                    = project_materials[0].data;
	context_raw.material.preview_ready = true;

	context_raw.saved_camera = mat4_clone(scene_camera.base.transform.local);
	let m: mat4_t = mat4_create(0.9146286343879498, -0.0032648027153306235, 0.404281837254303, 0.4659988049397712, 0.404295023959927, 0.007367569133732468,
	                            -0.9145989516155143, -1.0687517188018691, 0.000007410128652369705, 0.9999675337275382, 0.008058532943908717,
	                            0.015935682577325486, 0, 0, 0, 1);
	transform_set_matrix(scene_camera.base.transform, m);
	let saved_fov: f32    = scene_camera.data.fov;
	scene_camera.data.fov = 0.92;
	viewport_update_camera_type(camera_type_t.PERSPECTIVE);

	let probe: world_data_t       = scene_world;
	let _probe_strength: f32      = probe.strength;
	probe.strength                = 2;
	let _envmap_angle: f32        = context_raw.envmap_angle;
	context_raw.envmap_angle      = 0.0;
	let _brush_scale: f32         = context_raw.brush_scale;
	context_raw.brush_scale       = 1.5;
	let _brush_nodes_scale: f32   = context_raw.brush_nodes_scale;
	context_raw.brush_nodes_scale = 1.0;

	let _envmap: gpu_texture_t = scene_world._.envmap;
	scene_world._.envmap = context_raw.preview_envmap;
	// No resize
	_render_path_last_w = util_render_material_preview_size;
	_render_path_last_h = util_render_material_preview_size;
	camera_object_build_proj(scene_camera);
	camera_object_build_mat(scene_camera);

	make_material_parse_mesh_preview_material();
	let _commands: () => void = render_path_commands;
	render_path_commands      = render_path_preview_commands_preview;
	render_path_render_frame();
	render_path_commands = _commands;

	context_raw.material_preview = false;
	_render_path_last_w          = sys_w();
	_render_path_last_h          = sys_h();

	// Restore
	sphere.base.visible      = false;
	scene_meshes             = meshes;
	context_raw.paint_object = painto;

	transform_set_matrix(scene_camera.base.transform, context_raw.saved_camera);
	viewport_update_camera_type(context_raw.camera_type);
	scene_camera.data.fov = saved_fov;
	camera_object_build_proj(scene_camera);
	camera_object_build_mat(scene_camera);

	probe.strength                = _probe_strength;
	context_raw.envmap_angle      = _envmap_angle;
	context_raw.brush_scale       = _brush_scale;
	context_raw.brush_nodes_scale = _brush_nodes_scale;
	scene_world._.envmap          = _envmap;

	make_material_parse_mesh_material();
	context_raw.ddirty = 0;
}

function util_render_make_decal_preview() {
	if (context_raw.decal_image == null) {
		context_raw.decal_image = gpu_create_render_target(util_render_decal_preview_size, util_render_decal_preview_size, gpu_texture_format_t.RGBA64);
	}
	context_raw.decal_preview = true;

	let plane: mesh_object_t   = scene_get_child(".Plane").ext;
	plane.base.transform.scale = vec4_create(1, 1, 1);
	plane.base.transform.rot   = quat_from_euler(-math_pi() / 2, 0, 0);
	transform_build_matrix(plane.base.transform);
	plane.base.visible          = true;
	let meshes: mesh_object_t[] = scene_meshes;
	scene_meshes                = [ plane ];
	let painto: mesh_object_t   = context_raw.paint_object;
	context_raw.paint_object    = plane;

	context_raw.saved_camera = mat4_clone(scene_camera.base.transform.local);
	let m: mat4_t            = mat4_identity();
	m                        = mat4_translate(m, 0, 0, 1);
	transform_set_matrix(scene_camera.base.transform, m);
	let saved_fov: f32    = scene_camera.data.fov;
	scene_camera.data.fov = 0.92;
	viewport_update_camera_type(camera_type_t.PERSPECTIVE);
	scene_world._.envmap = context_raw.preview_envmap;

	// No resize
	_render_path_last_w = util_render_decal_preview_size;
	_render_path_last_h = util_render_decal_preview_size;
	camera_object_build_proj(scene_camera);
	camera_object_build_mat(scene_camera);

	make_material_parse_mesh_preview_material();
	let _commands: () => void = render_path_commands;
	render_path_commands      = render_path_preview_commands_decal;
	render_path_render_frame();
	render_path_commands = _commands;

	context_raw.decal_preview = false;
	_render_path_last_w       = sys_w();
	_render_path_last_h       = sys_h();

	// Restore
	plane.base.visible       = false;
	scene_meshes             = meshes;
	context_raw.paint_object = painto;

	transform_set_matrix(scene_camera.base.transform, context_raw.saved_camera);
	scene_camera.data.fov = saved_fov;
	viewport_update_camera_type(context_raw.camera_type);
	camera_object_build_proj(scene_camera);
	camera_object_build_mat(scene_camera);

	scene_world._.envmap = context_raw.show_envmap ? context_raw.saved_envmap : context_raw.empty_envmap;

	make_material_parse_mesh_material();
	context_raw.ddirty = 1; // Refresh depth for decal paint
}

function util_render_make_text_preview() {
	let current: gpu_texture_t = _draw_current;
	let in_use: bool           = gpu_in_use;
	if (in_use)
		draw_end();

	let text: string      = context_raw.text_tool_text;
	let font: draw_font_t = context_raw.font.font;
	let font_size: i32    = util_render_font_preview_size;
	let text_w: i32       = math_floor(draw_string_width(font, font_size, text));
	let text_h: i32       = math_floor(draw_font_height(font, font_size));
	let tex_w: i32        = text_w + 32;
	if (tex_w < 512) {
		tex_w = 512;
	}
	if (context_raw.text_tool_image != null && context_raw.text_tool_image.width < tex_w) {
		gpu_delete_texture(context_raw.text_tool_image);
		context_raw.text_tool_image = null;
	}
	if (context_raw.text_tool_image == null) {
		context_raw.text_tool_image = gpu_create_render_target(tex_w, tex_w, gpu_texture_format_t.RGBA32);
	}
	draw_begin(context_raw.text_tool_image, true, 0xff000000);
	draw_set_font(font, font_size);
	draw_set_color(0xffffffff);
	draw_string(text, tex_w / 2 - text_w / 2, tex_w / 2 - text_h / 2);
	draw_end();

	if (in_use)
		draw_begin(current);
}

function util_render_make_font_preview() {
	let current: gpu_texture_t = _draw_current;
	let in_use: bool           = gpu_in_use;
	if (in_use)
		draw_end();

	let text: string      = "Abg";
	let font: draw_font_t = context_raw.font.font;
	let font_size: i32    = util_render_font_preview_size;
	let text_w: i32       = math_floor(draw_string_width(font, font_size, text)) + 8;
	let text_h: i32       = math_floor(draw_font_height(font, font_size)) + 8;
	let tex_w: i32        = text_w + 32;
	if (context_raw.font.image == null) {
		context_raw.font.image = gpu_create_render_target(tex_w, tex_w, gpu_texture_format_t.RGBA32);
	}
	draw_begin(context_raw.font.image, true, 0x00000000);
	draw_set_font(font, font_size);
	draw_set_color(0xffffffff);
	draw_string(text, tex_w / 2 - text_w / 2, tex_w / 2 - text_h / 2);
	draw_end();
	context_raw.font.preview_ready = true;

	if (in_use)
		draw_begin(current);
}

function util_render_make_brush_preview() {
	if (render_path_paint_live_layer_locked) {
		return;
	}

	let current: gpu_texture_t = _draw_current;
	let in_use: bool           = gpu_in_use;
	if (in_use)
		draw_end();

	context_raw.material_preview = true;

	// Prepare layers
	if (render_path_paint_live_layer == null) {
		render_path_paint_live_layer = slot_layer_create("_live");
	}

	let l: slot_layer_t = render_path_paint_live_layer;
	slot_layer_clear(l);

	if (context_raw.brush.image == null) {
		context_raw.brush.image      = gpu_create_render_target(util_render_material_preview_size, util_render_material_preview_size);
		context_raw.brush.image_icon = gpu_create_render_target(50, 50);
	}

	let _material: slot_material_t = context_raw.material;
	context_raw.material           = slot_material_create();

	// Prevent grid jump
	context_raw.material.nodes.pan_x = context_raw.brush.nodes.pan_x;
	context_raw.material.nodes.pan_y = context_raw.brush.nodes.pan_y;
	context_raw.material.nodes.zoom  = context_raw.brush.nodes.zoom;

	let _tool: tool_type_t = context_raw.tool;
	context_raw.tool       = tool_type_t.BRUSH;

	let _layer: slot_layer_t = context_raw.layer;
	if (slot_layer_is_mask(context_raw.layer)) {
		context_raw.layer = context_raw.layer.parent;
	}

	let _fill_layer: slot_material_t = context_raw.layer.fill_layer;
	context_raw.layer.fill_layer     = null;

	render_path_paint_use_live_layer(true);
	make_material_parse_paint_material(false);

	let hid: i32 = history_undo_i - 1 < 0 ? config_raw.undo_steps - 1 : history_undo_i - 1;
	map_set(render_path_render_targets, "texpaint_undo" + hid, map_get(render_path_render_targets, "empty_black"));

	// Set plane mesh
	let painto: mesh_object_t = context_raw.paint_object;
	let visibles: bool[]      = [];
	for (let i: i32 = 0; i < project_paint_objects.length; ++i) {
		let p: mesh_object_t = project_paint_objects[i];
		array_push(visibles, p.base.visible);
		p.base.visible = false;
	}
	let merged_object_visible: bool = false;
	if (context_raw.merged_object != null) {
		merged_object_visible                  = context_raw.merged_object.base.visible;
		context_raw.merged_object.base.visible = false;
	}

	let cam: camera_object_t = scene_camera;
	context_raw.saved_camera = mat4_clone(cam.base.transform.local);
	let saved_fov: f32       = cam.data.fov;
	viewport_update_camera_type(camera_type_t.PERSPECTIVE);
	let m: mat4_t = mat4_identity();
	m             = mat4_translate(m, 0, 0, 0.5);
	transform_set_matrix(cam.base.transform, m);
	cam.data.fov = 0.92;
	camera_object_build_proj(cam);
	camera_object_build_mat(cam);
	m = mat4_inv(scene_camera.vp);

	let planeo: mesh_object_t = scene_get_child(".Plane").ext;
	planeo.base.visible       = true;
	context_raw.paint_object  = planeo;

	let v: vec4_t               = vec4_create();
	v                           = vec4_create(m.m00, m.m01, m.m02);
	let sx: f32                 = vec4_len(v);
	planeo.base.transform.rot   = quat_from_euler(-math_pi() / 2, 0, 0);
	planeo.base.transform.scale = vec4_create(sx, 1.0, sx);
	planeo.base.transform.loc   = vec4_create(m.m30, -m.m31, 0.0);
	transform_build_matrix(planeo.base.transform);

	render_path_paint_live_layer_drawn = 0;
	render_path_base_draw_gbuffer();

	// Paint brush preview
	let _brush_radius: f32     = context_raw.brush_radius;
	let _brush_opacity: f32    = context_raw.brush_opacity;
	let _brush_hardness: f32   = context_raw.brush_hardness;
	context_raw.brush_radius   = 0.33;
	context_raw.brush_opacity  = 1.0;
	context_raw.brush_hardness = 0.8;
	let _x: f32                = context_raw.paint_vec.x;
	let _y: f32                = context_raw.paint_vec.y;
	let _last_x: f32           = context_raw.last_paint_vec_x;
	let _last_y: f32           = context_raw.last_paint_vec_y;
	let _pdirty: i32           = context_raw.pdirty;
	context_raw.pdirty         = 2;

	let points_x: f32[] = [ 0.2, 0.2, 0.35, 0.5, 0.5, 0.5, 0.65, 0.8, 0.8, 0.8 ];
	let points_y: f32[] = [ 0.5, 0.5, 0.35 - 0.04, 0.2 - 0.08, 0.4 + 0.015, 0.6 + 0.03, 0.45 - 0.025, 0.3 - 0.05, 0.5 + 0.025, 0.7 + 0.05 ];
	for (let i: i32 = 1; i < points_x.length; ++i) {
		context_raw.last_paint_vec_x = points_x[i - 1];
		context_raw.last_paint_vec_y = points_y[i - 1];
		context_raw.paint_vec.x      = points_x[i];
		context_raw.paint_vec.y      = points_y[i];
		render_path_paint_commands_paint(false);
	}

	context_raw.brush_radius     = _brush_radius;
	context_raw.brush_opacity    = _brush_opacity;
	context_raw.brush_hardness   = _brush_hardness;
	context_raw.paint_vec.x      = _x;
	context_raw.paint_vec.y      = _y;
	context_raw.last_paint_vec_x = _last_x;
	context_raw.last_paint_vec_y = _last_y;
	context_raw.prev_paint_vec_x = -1;
	context_raw.prev_paint_vec_y = -1;
	context_raw.pdirty           = _pdirty;
	render_path_paint_use_live_layer(false);
	context_raw.layer.fill_layer = _fill_layer;
	context_raw.layer            = _layer;
	context_raw.material         = _material;
	context_raw.tool             = _tool;
	sys_notify_on_next_frame(function() {
		make_material_parse_paint_material(false);
	});

	// Restore paint mesh
	context_raw.material_preview = false;
	planeo.base.visible          = false;
	for (let i: i32 = 0; i < project_paint_objects.length; ++i) {
		project_paint_objects[i].base.visible = visibles[i];
	}
	if (context_raw.merged_object != null) {
		context_raw.merged_object.base.visible = merged_object_visible;
	}
	context_raw.paint_object = painto;
	transform_set_matrix(scene_camera.base.transform, context_raw.saved_camera);
	scene_camera.data.fov = saved_fov;
	viewport_update_camera_type(context_raw.camera_type);
	camera_object_build_proj(scene_camera);
	camera_object_build_mat(scene_camera);

	// Scale layer down to to image preview
	l                         = render_path_paint_live_layer;
	let target: gpu_texture_t = context_raw.brush.image;
	draw_begin(target, true, 0x00000000);
	draw_set_pipeline(pipes_copy);
	draw_scaled_image(l.texpaint, 0, 0, target.width, target.height);
	draw_set_pipeline(null);
	draw_end();

	// Scale image preview down to icon
	let texpreview: render_target_t      = map_get(render_path_render_targets, "texpreview");
	texpreview._image                    = context_raw.brush.image;
	let texpreview_icon: render_target_t = map_get(render_path_render_targets, "texpreview_icon");
	texpreview_icon._image               = context_raw.brush.image_icon;
	render_path_set_target("texpreview_icon");
	render_path_bind_target("texpreview", "tex");
	render_path_draw_shader("Scene/supersample_resolve/supersample_resolve");

	context_raw.brush.preview_ready = true;
	context_raw.brush_blend_dirty   = true;

	if (in_use)
		draw_begin(current);
}

function util_render_make_node_preview(canvas: ui_node_canvas_t, node: ui_node_t, image: gpu_texture_t, group: ui_node_canvas_t = null,
                                       parents: ui_node_t[] = null) {
	let res: parse_node_preview_result_t = make_material_parse_node_preview_material(node, group, parents);
	if (res == null || res.scon == null) {
		return;
	}

	if (util_render_screen_aligned_full_vb == null) {
		util_render_create_screen_aligned_full_data();
	}

	let _scale_world: f32                               = context_raw.paint_object.base.transform.scale_world;
	context_raw.paint_object.base.transform.scale_world = 3.0;
	transform_build_matrix(context_raw.paint_object.base.transform);

	_gpu_begin(image);
	gpu_set_pipeline(res.scon._.pipe);
	let empty: string[] = [ "" ];
	uniforms_set_context_consts(res.scon, empty);
	uniforms_set_obj_consts(res.scon, context_raw.paint_object.base);
	uniforms_set_material_consts(res.scon, res.mcon);
	gpu_set_vertex_buffer(util_render_screen_aligned_full_vb);
	gpu_set_index_buffer(util_render_screen_aligned_full_ib);
	gpu_draw();
	gpu_end();

	context_raw.paint_object.base.transform.scale_world = _scale_world;
	transform_build_matrix(context_raw.paint_object.base.transform);
}

function util_render_pick_pos_nor_tex() {
	context_raw.pick_pos_nor_tex = true;
	context_raw.pdirty           = 1;
	let _tool: tool_type_t       = context_raw.tool;
	context_raw.tool             = tool_type_t.PICKER;
	make_material_parse_paint_material();
	if (context_raw.paint2d) {
		render_path_paint_set_plane_mesh();
	}
	render_path_paint_commands_paint(false);

	if (context_raw.paint2d) {
		render_path_paint_restore_plane_mesh();
	}
	context_raw.tool             = _tool;
	context_raw.pick_pos_nor_tex = false;
	make_material_parse_paint_material();
	context_raw.pdirty = 0;
}

function util_render_get_decal_mat(): mat4_t {
	util_render_pick_pos_nor_tex();
	let decal_mat: mat4_t = mat4_identity();
	let loc: vec4_t       = vec4_create(context_raw.posx_picked, context_raw.posy_picked, context_raw.posz_picked);
	let rot: quat_t       = quat_from_to(vec4_create(0.0, 0.0, -1.0), vec4_create(context_raw.norx_picked, context_raw.nory_picked, context_raw.norz_picked));
	let scale: vec4_t     = vec4_create(context_raw.brush_radius * 0.5, context_raw.brush_radius * 0.5, context_raw.brush_radius * 0.5);
	decal_mat             = mat4_compose(loc, rot, scale);
	return decal_mat;
}

function util_render_create_screen_aligned_full_data() {
	// Over-sized triangle
	let data: i16[] = [
		-math_floor(32767 / 3),
		-math_floor(32767 / 3),
		0,
		32767,
		0,
		0,
		0,
		0,
		0,
		0,
		0,
		0,
		32767,
		-math_floor(32767 / 3),
		0,
		32767,
		0,
		0,
		0,
		0,
		0,
		0,
		0,
		0,
		-math_floor(32767 / 3),
		32767,
		0,
		32767,
		0,
		0,
		0,
		0,
		0,
		0,
		0,
		0
	];
	let indices: u32[] = [ 0, 1, 2 ];

	// Mandatory vertex data names and sizes
	let structure: gpu_vertex_structure_t = {};
	gpu_vertex_struct_add(structure, "pos", gpu_vertex_data_t.I16_4X_NORM);
	gpu_vertex_struct_add(structure, "nor", gpu_vertex_data_t.I16_2X_NORM);
	gpu_vertex_struct_add(structure, "tex", gpu_vertex_data_t.I16_2X_NORM);
	gpu_vertex_struct_add(structure, "col", gpu_vertex_data_t.I16_4X_NORM);
	util_render_screen_aligned_full_vb = gpu_create_vertex_buffer(math_floor(data.length / math_floor(gpu_vertex_struct_size(structure) / 2)), structure);
	let vertices: buffer_t             = gpu_lock_vertex_buffer(util_render_screen_aligned_full_vb);
	for (let i: i32 = 0; i < math_floor((vertices.length) / 2); ++i) {
		buffer_set_i16(vertices, i * 2, data[i]);
	}
	gpu_vertex_buffer_unlock(util_render_screen_aligned_full_vb);

	util_render_screen_aligned_full_ib = gpu_create_index_buffer(indices.length);
	let id: u32_array_t                = gpu_lock_index_buffer(util_render_screen_aligned_full_ib);
	for (let i: i32 = 0; i < id.length; ++i) {
		id[i] = indices[i];
	}
	gpu_index_buffer_unlock(util_render_screen_aligned_full_ib);
}