Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Steve]

I softened the color of the sub-mesh and added a single option to disable showing the edges.  The smooth and flat shaded images are split-screen to show how it looks with and without the edges.  I left the edges visible in wireframe mode because they don't interfere much at all and without them there is no hist as to what the object's shape is.

[Raxx]

Looks good to me. Thanks Steve!

[nemyax]

Am I missing something or is there no way to convert a subdiv back to an untessellated mesh?

[Raxx]

Double click the subdivision mesh, set working divisions to 0, then convert to mesh.

[Raxx]

I know that it's about time to focus on the other editors, but here's a feature for the object editor that I would find extremely useful, and I'm sure others would as well.

Clone Mesh
A clone is a duplicate of a mesh shape. It's basically just a copy. If the original gets edited, the copy updates to that version of the original immediately. A clone can be transformed (moved, scaled, rotated). A clone can have its own unique parameters (it copies the original's when the clone is first created, including the original's transform). For example, if it's a mesh, then the smooth angle can be customized. If it's a subdivision mesh, then the working/final divisions and smooth angle can be customized. And of course the layer. Also, clones can have unique materials assigned to them (only the base material--if specific faces have assigned materials, those remain the same as the original's). It's only the mesh structure that remains exactly the same as the original.

The mesh structure of a clone can't be edited. Therefore it'd be useful that if it's a subdivision mesh, that it doesn't show the control mesh whatsoever in any of the shading modes (unless give it an option in its dialog box?). However, a clone can be converted to mesh to "unclone" it.

There are a lot of uses for this. The user can make a clone of the mesh and scale it -1, creating a mirror and then be able to do mirrored modeling while being able to see the changes on the other side immediately without the control mesh getting in the way if it's a subdivision mesh. Things like eyeballs, mirrored accessories and clothing, etc., becomes easy to do. If an object needs lots of copies of a mesh, like for example a metal chain, these can all be cloned and then when editing the original chain link, all the other chain links become updated immediately as well. It also greatly reduces file sizes for things like this.

Copying and pasting a clone results in a clone with the same parameters as the copied clone. Deleting the original mesh deletes the clone (maybe autodetect if there are clones of that mesh, and then ask if the user wants to delete the clones or not. If not, then the clones get converted to meshes).

As for morph targets, I think it'd be interesting if it reflected the original's morphs as well when setting and animating, with an option in its dialog box to not copy it.

This isn't an original idea of mine. It's something I used a lot in XSI when I used it for modeling. I think it'd be somewhat easy (compared to the *ahem* mirrored modeling feature) to implement as well, since it's just running a copy method every time a cloned mesh is modified, and in figure/sequence/scene editors it can be treated like a transformed instance of the original mesh when building the list of geometry.

[Steve]

This concept, or a very similar one, is called Instancing in OpenGL and D3D. At first glance it may seem simple, but there are a lot of nuances. If you allow editing of the per face properties in an instance (materials, texture coordinates, etc.), updating then when the geometry of the base shape changes is very complex. Vertex, edge, face, normal, tex-coord numbers often change throughout the mesh when just one small part is edited. This is the same, fundamental complexity with mirrored meshes.

What would be fairly easy to support: position, orientation, scale, materials (substituting different ones for the ones in the base model), and all global properties shown in the Properties editors such as subdivision level, parametric parameters, layer, smooth angle, etc.

Would  that be useful enough?  I had planned to add something like this at some point.

[Raxx]

This concept, or a very similar one, is called Instancing in OpenGL and D3D. At first glance it may seem simple, but there are a lot of nuances. If you allow editing of the per face properties in an instance (materials, texture coordinates, etc.), updating then when the geometry of the base shape changes is very complex. Vertex, edge, face, normal, tex-coord numbers often change throughout the mesh when just one small part is edited. This is the same, fundamental complexity with mirrored meshes.

What would be fairly easy to support: position, orientation, scale, materials (substituting different ones for the ones in the base model), and all global properties shown in the Properties editors such as subdivision level, parametric parameters, layer, smooth angle, etc.

As I described in the post above, clones shouldn't be editable meshes unless they're converted into their own independant shapes (and thus not being clones/instances anymore), so there wouldn't be any editing of materials (besides the base material), texture coords, or anything else p/e/f on these active instances. Thus this complexity is avoided. So yes, what you described as fairly easy to support is what I described, and therefore useful enough

[Steve]

Thanks, I understand better now.

[Raxx]

A small but important ASL request: A system time function to retrieve the timestamp and maybe a date function to accompany it. There are many obvious uses for this (evaluating script performance, timing out functions, timers, saving files with date, etc.) and I've always wondered why it hasn't been implemented.

[Steve]

I can see how they could be useful. I should probably add them.

But, since you asked, here's why :  Functions like this allow non repeatable scripts. As it stands things like parametric shapes are guaranteed to do exactly the same thing on any run with the same environment (other meshes, user attributes, etc.). Functions like irand() and frand() always return the same values when called in the same sequence.  So you're free to use them without worrying about inconsistencies from run to run.

[Raxx]

That's true, but in my opinion these types of restrictions should be in the hands of the users, that it should be up to the coder whether their script should have true inconsistent/unique features or not, and up to the end user whether or not to use the script and/or unique features. Obviously in Anim8or inconsistencies aren't that useful, but you never know, something outside the box could be done with it that'd surprise us.

Anyway, a memo in the ASL spec about the usefulness of the Xrand() functions vs timestamps would help alleviate the issue

[Raxx]

Another ASL-related request: Status Bar and Progress Bar output.

There's not much (read:nothing) in the way of GUI options for ASL. What I'd give for the ability to create custom dialog boxes in ASL...sigh. Anyway, something that *should* be simpler to implement is the ability to print to the status bar, and the ability to start/update/end the progress bar (same progress bar as what's shown when rendering). Yes, there's the console, but it's not a very user friendly method of informing the user about things. I've made progress bars in the console before but ugh, it's such a ghastly way of doing things.

Status bar text updates have lots of uses. Such as informing the start/stop of a script, latest warnings, error messages, debugging, etc. Same as the console but nicer. It could use the same .open/print/close functions as the console, but instead of "$console" it's "$statusbar".

Progress bar updates are useful in object editor scripts that take a long time to generate. Like my phur plugin, some of my export plugins, or some of the other mesh plugins others have done. The function to start/stop/update the progress bar could be as simple as SetProgressBar(#). Where it's a float value between 0 and 1 with 0 being off and 1 being full. Automatically sets to 0 upon script termination in case the user forgets to write it in.

And a side note, it'd be nice if the progress bar made use of the Windows task bar progress bar indicator (http://stackoverflow.com/questions/1146574/how-do-i-code-a-progress-bar-for-windows-7-to-also-update-itself-on-the-taskbar). So that when rendering or while a script is running, the user can glance at the task bar and easily tell if it's still going or not. This is a Win7+ feature but it should be relatively simple to do an OS version check for it.

This is a future-friendly ASL feature request since the status bar and progress bar are key parts of the Anim8or interface. Even if more GUI features are implemented in ASL, these two elements will remain relevant.

PS...Personally I'd love it if the console was embedded in the bottom of Anim8or's interface (expandable above the status bar). Oh, and custom coloring the text...

[Raxx]

Some other ASL requests that have weighed heavily on my mind for some time now. Usually after banging my head on the wall, I'd type up a big ol' write up of my grievances, then by the time my frustration's died down I'd realize it's more rant than request and delete it. This time it's a good night's sleep after, so hopefully I can articulate a good post

Here's an example of what I wrote last night trying to get a small matter accomplished:

ASL Snippet

 
if($he_sharedPoints[$he_Point[$curHEString2[$j]]].x != -1.0)
{
	if ($he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].x)]] != -1)
		$feature_neighbors[$he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].x)]]] = 1;
 
	if ($he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].x)]] != -1)
		$feature_neighbors[$he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].x)]]] = 1;
 
	if($he_sharedPoints[$he_Point[$curHEString2[$j]]].y != -1.0)
	{
		if ($he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].y)]] != -1)
			$feature_neighbors[$he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].y)]]] = 1;
 
		if ($he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].y)]] != -1)
			$feature_neighbors[$he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].y)]]] = 1;
 
		if($he_sharedPoints[$he_Point[$curHEString2[$j]]].z != -1.0)
		{
			if ($he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].z)]] != -1)
				$feature_neighbors[$he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].z)]]] = 1;
 
			if ($he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].z)]] != -1)
				$feature_neighbors[$he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].z)]]] = 1;
 
			if($he_sharedPoints[$he_Point[$curHEString2[$j]]].w != -1.0)
			{
				if ($he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].w)]] != -1)
					$feature_neighbors[$he_Pair1[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].w)]]] = 1;
 
				if ($he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].w)]] != -1)
					$feature_neighbors[$he_Pair2[$he_EdgeIndex[$fToInt($he_sharedPoints[$he_Point[$curHEString2[$j]]].w)]]] = 1;
			}
		}
	}
}
 

I built those lines slowly while it made sense, but now looking at it it'll take me a few minutes to actually figure out what's linking to where, and I'm the one that wrote it! There's also no simpler method that I could think of. To help myself out, I write nearly as many comments as lines of code, but still I would hate life if I had to come back to this code even a week later when it's not fresh in my mind. It's also only a small portion of the entire script, which I'm not going to share because it'd cause nightmares to all present.

Arrays in functions: Passing arrays as parameters, and returning arrays from functions. Without this, I have to create arrays beforehand outside of the $main function so that the function can fill in arrays. This is extremely counter intuitive, and hard to organize when multiple functions need to output arrays multiple times for the main function or between other functions.

Recursion: It's incredibly difficult converting algorithms that require recursion into non-recursive functions. A lot of 3D-related algorithms rely on binary trees/linked lists, and making non-recursive traversal functions (especially without custom data structures as requested below) is a stack of headaches rolled into one. I have to create stacks and counters and do convoluted orders of operations to try and cope with it.

Custom data structures: I'm not asking for anything super complicated like full-featured object definition. I just want to be able to make my own data structure out of the data types already available. I could make linked lists without having to create a dozen arrays with weird convoluted relationships to each other passing indices as values to be indices for other arrays.

An example of how it'd look creating a new data structure could be something like:

Code: [Select]

!datatype half-edge (int id, int next, int prev, point3 point, int edgeindex, int opposite);! indicates it's compiled first before the rest of the script, and needs to be asserted outside of the $main function. Then to use the half-edge data type, declare it like any other variable:

Code: [Select]

half-edge $HE[1];To assign the values, two methods can be used.

Code: [Select]

$HE[0] = (0, 1, -1, (0,0,0), 85, 23); // Can also have variables passed as values
$HE[0].id = 0;
$HE[0].next = 1;
$HE[0].prev= -1;
$HE[0].point = (0,0,0);
$HE[0].edgeindex = 85;
$HE[0].opposite = 23;It'd be useful to also be able to use custom data types within custom data types. For example a custom data type vertex:

Code: [Select]

!datatype vertex (int id, point3 loc);
vertex $v;Can be used in half-edge:

Code: [Select]

!datatype half-edge (int id, int next, int prev, vertex point, int edgeindex, int opposite);Writing to it can look like this:

Code: [Select]

$HE[0].point.id = 1;
$HE[0].point.loc =(0,0,0);
Pointers: Same * and & operators/behavior as in C++, would aid the use of custom data types, binary trees, linked lists...

Matrices: I'm already fairly deficient when it comes to 3D math, so I won't go into much detail here. Some means to make matrices Nxn size, and functions to perform operations on these.

Type conversion. toInt and toFloat functions for strings (like toInt("123.45") returns 123 and toFloat("123.45") returns 123.45. I made my own functions in ASL to do this but it'd obviously be much more efficient if this was built-in.

toString for ints and floats (yes there's PrintToString, this would basically be a simplified macro of that).

Automatic type conversion between ints and floats (for example $array[1.466] automatically converts down to $array[1]).

Adding two multiple strings appends them together in the order they appear. Example: $var = "Hello" + " " + "there" + ", " + "everyone!"; is a lot simpler than doing $var = PrintToString("%s%s%s%s%s", "Hello", " ", "there", ", ", "everyone!");

[Edit] Obviously, most of these requests are things found in regular programming languages. If instead an API/dll extension system was being worked on, I really couldn't care less about these requests and just wait for that to save myself all the headache

[Raxx]

Small request: Make it so that the axis buttons are triggered the same way as the p/e/f buttons. LMB enables only that axis and disables the others, RMB toggles by add/subtracting from the current set.

[Steve]

Raxx: sure, that makes sense.