Nebulae in Celestia using sprites

[LukeCEL]

Hi everyone! I'm starting a thread about making nebulae in Celestia, using point sprites.

Before we start, I should mention that I am not an expert! I'm not a professional astronomer, physicist, or a mathematician. I'm just a hobbyist, and this is just my experience making these nebulae add-ons. I hope this thread becomes a place for people to learn and exchange information about making these things. I am also not the first person to do sprite models! I would say the pioneer of making sprite models is Cham, but other people have used sprites to wonderful effect (just look around the Forums).

Download Link

The finished add-ons, as well as ASCII cmods for viewing/experimenting, are all available here: https://drive.google.com/drive/folders/1qBvr56J4kmSBaiHAs4Yj3xKEUXQqTfv-?usp=sharing

Introduction: Why Sprites?

Broadly speaking, there are two ways to make nebula models in Celestia. You can use a polygon mesh, and you can use point sprites. In a polygon mesh, a texture is wrapped around a surface. This texture can be, say, an image of the nebulae. With point sprites, points are displayed in 3D space. The "sprite" part of point sprites means that a specific texture is rendered at each point, no matter what angle you are looking from. The important thing to note is that if the sprite texture is something that is perfectly symmetrical along all lines of symmetry, like a circle, then when you view the sprite it looks like a sphere. This is how sprites give you a "volumetric" effect.

The vast majority of nebula add-ons on the Motherlode are made using the former method. I think it's because it's relatively easy to make a billboard model, and just UV-wrap an image of a nebula onto it. And to be fair these models look, well, photorealistic when viewed from the Earth. But when you view the models from the side, the model looks strange. (Imagine viewing a billboard from the side.)

Ultimately, I think why I think it is so difficult to make a 3D model of an a nebula using polygon meshes: 1) polygon meshes will always have these sharply defined surfaces at some viewing angle, while nebulae tend to be pretty fuzzy objects, and 2) it's difficult to take a single image of a nebula and turn that into a 3D model. Of course, that's not to say that it's impossible to make them using polygon meshes: I think jll's models are excellent, such as this Mz 3 (Ant Nebula) add-on.

But for me, the main reason that I started making sprites was because I found them to be easier to make, from a technological standpoint. With polygon meshes, you need to know a little bit about UV wrapping, transparency, and a whole bunch of other stuff. I don't know how to do that. But I do know how to plot points in 3D space. It requires only a little bit of knowledge of math. You can also use a 3D graphing software like GeoGebra 5, to do it for you.

Abell 39

So now that I've gotten my manifesto out of the way, I suppose I'll start with the simplest example: Abell 39, a near-perfect sphere. The download link is here.

Spherical nebulae like Abell 39 consist of an expanding shell of gas, that gets ionized by the central star to produce light. Visually, the shell appears as a "ring". This is because of limb brightening, where the outer areas appear to have more material than the inner areas. Here's a graphic that I think explains it well:

Courtesy of Weber State University, from here: https://physics.weber.edu/palen/clearinghouse/labs/ProppnShort/proppn.html

diagram.gif (11.16 KiB) Viewed 26951 times

In Celestia, this is modeled pretty well with a spherical shell where the shell is made up of point sprites. Here's how I made the model for Abell 39:

1. Open Blender.
2. Blender always starts with a default cube. Delete that by clicking on it, then pressing "X", then "Enter".
3. In the tab on the left, select "Create", then "Ico Sphere". An Ico Sphere is important because it places all the points equi-distant from each other. If we used another shape, like the UV Sphere, the points would not have an even distribution, and the sprites would be brighter near those areas.
4. Near the bottom left, go to where it says "Object Mode" and change that to "Edit Mode". The Ico Sphere should be selected in orange.
5. Press "W", and select "Subdivide Smooth" twice. This helps create more points that fill out the gaps.
6. Near the top left, go to "Export", then "Wavefront (.obj)".

Then, I opened the OBJ file using a text editor and grab the vertices. Each point needs a sprite size, and a color (in RGB). Using Microsoft Excel, it's pretty easy to do that.

In a text editor, I copy-pasted the vertex definitions into a text file, and added all of the other parts: the material definition, the mesh definition, the list of sprites, etc. For more information, you can look at my abell39.cmod as an example.

Later, I'm going to add more nebulae and explain (to the best of my ability) how I made them.

Cheers, LukeCEL

[Lafuente_Astronomy]

Well, this looks promising. Can this also be a tutorial post for members to make nebulae? Thanks in advance. And I'm looking forward to more of the work that you'll be making

[LukeCEL]

Can this also be a tutorial post for members to make nebulae?

Yep! Along with my posting the nebula add-ons, I'll be posting explanations of how I created them.

[Art Blos]

I have never been able to convert a sprite model from a ASCII to binary (binary writing improves performance several times). This is the main reason why I abandoned sprites. But, if you solve this problem, then this will be a real breakthrough.

[LukeCEL]

Hi Art Blos, I remember in the past, I unsuccessfully tried to convert sprite models from ASCII to binary. However, I just tried it right now, using the cmodfix tool.

I typed:

Code: Select all

cmodfix -b abell39.cmod abell39binary.cmod

or something to that effect. And the resulting output worked for me. Can you test this out?

Abell39.zip

(19.88 KiB) Downloaded 421 times

Added after 4 hours 6 minutes:
Caveats

Although I said I prefer sprites over polygon meshes, they are by no means perfect. There's one significant problem with sprites: they "break up".

When you zoom out, the sprites appear to become smaller, and when you zoom in, the sprites appear to become bigger. However, this effect only lasts for a certain distance range. Once you zoom in close enough, the sprites approach a certain size, but they don't appear to get bigger. When this happens, the sprites appear to "separate" from each other and you'll see the formation the sprites are in.

Here's an image of the Abell 39 model, where I went to the central star. Here, you can see the sprites forming a "disco ball" effect.

So how do you minimize this effect? The simple solution is to keep on adding sprites, but there is only so many sprites that you can add before it starts to impact performance. Generally, the more overlapping sprites, the more calculations that Celestia has to do and this slows things down.

When making sprite models, I recommend experimenting with different point sizes, opacities, and other factors. For spherical shells like Abell 39, I typically subdivide twice - that gives 642 vertices.

[LukeCEL]

IC 3568 (Lemon Slice Nebula)

"If IC 3568 did not exist, it might have been created by theoreticians." – Bruce Balick et al. (1987)

The first nebula I'm going to post here is IC 3568, also known as the Lemon Slice Nebula. It's very simple - just a simple shell, and outer halo, and some inner details inside the shell.

To create the shell, I used essentially the same method as before in Abell 39. For the halo, I used fewer sprites, and made those larger and less opaque. I used the list of vertices from the Abell 39 add-on and used every other point, which results in a roughly uniform distribution. That gives it less of a defined appearance. Be aware that the model appears to be "break up" as mentioned before, but I don't mind this as much, since the model looks fine to me from different distances.

https://commons.wikimedia.org/wiki/File:IC_3568_%22Lemon_Slice%22.jpg

IC3568.jpg (24.08 KiB) Viewed 26826 times

The inner details inside the shell are a bit more complex. When looking at a picture, it looked to me as if there were "rays" radiating outward from the center towards the surface of the shell.

To do this, I first:

1. generated random points on the sphere. This can be done by generating random X-, Y-, and Z-coordinates all between -1 and 1, and then normalizing them (i.e. setting the distance from the center to be the same, by dividing them by the distance to the center). I set the radius value to be a small number, such as 0.3 (I shrunk all the values down later).
2. Now that I have my X, Y, and Z values, I calculated azimuthal and inclination angles for them. Essentially I was converting from 3D cartesian coordinates to spherical coordinates. You can look up formulae for how to do that.
3. To generate the next layer of points, I let the azimuth and inclination values vary slightly by adding a small random number (between -1/8 and 1/8) to the azimuth and inclination values. This ensures that the rays don't end up being a perfectly straight line radiating from the central star.
4. I converted the azimuth and inclination, along with a slightly larger radius value (such as 0.4), back to cartesian coordinates that can be used for the point sprite.
5. I repeated this conversion from spherical to cartesian about 10 more times, until I was happy with the 3D shape of the "rays".
The finished add-on is available for download below, as well as the ASCII CMOD file, for those who want a closer look at it.

Enjoy:

[jujuapapa]

IC 3568 (Lemon Slice Nebula)
...
Enjoy:

No change for me, always the fuzzy point.... (even in opengl 2.0 mode)

[LukeCEL]

No change for me, always the fuzzy point.... (even in opengl 2.0 mode)

That's unfortunate. If that doesn't work, try downloading the ASCII CMOD and replacing the old CMOD file with it.

[jujuapapa]

That's unfortunate. If that doesn't work, try downloading the ASCII CMOD and replacing the old CMOD file with it.

It's ok with the ascii file cmod.

[LukeCEL]

Art Blos, I think I found what has been causing binary CMOD files to not work previously.

My binary IC 3568 model did not work because the original ASCII model had comments. The two material definitions look like this:

Code: Select all

material # represents halo
   opacity 0.02
   texture0 "27px.png"
   blend normal
end_material

material # represents inner shell and detail
   opacity 0.35
   texture0 "27px.png"
   blend normal
end_material

When that is converted to a binary CMOD, it does not work on some computers. To get around this problem, you need to first remove the comments, so it looks like this:

Code: Select all

material
   opacity 0.02
   texture0 "27px.png"
   blend normal
end_material

material
   opacity 0.35
   texture0 "27px.png"
   blend normal
end_material

With that in mind, the following binary CMOD file should work. Simply rename the file to "ic3568.cmod" and replace the old model file with this version.

[Art Blos]

LukeCEL < I apologize for being inactive in this thread. There is a lot of work before the release. I will return to the nebulae later.

[LukeCEL]

Ju 1 (Soap Bubble Nebula)

The Soap Bubble Nebula was pretty straightforward to do. It's very similar to the procedure for Abell 39.

First, I created an Ico Sphere in Blender, but I scaled it up a several times, by pressing "S" then dragging my cursor. Then, by changing the mode from "Object Mode" to "Sculpt Mode", I was able to add tiny imperfections to the Ico Sphere. On the left bar there is also an option to change from "Add" to "Subtract" so you carve out bits, instead of adding more.

In Blender, it's possible to scale using exact proportions, by pressing "S" then clicking. On the left bar, you will see "Resize Options" or something like that. You can enter specific coefficients for the X, Y, and Z directions. I enlarged the "X" value by 7.5%, which is a value I got by fitting an ellipse to an image of the nebula.

I also selected "Subdivide Smooth" three times as well. This allows you to get a finer point size and thus a thinner shell.

The finished add-on is available for download below, as well as the ASCII CMOD file, for those who want a closer look at it. And hopefully this time, the binary CMOD should actually work!

Enjoy:

[LukeCEL]

I was originally planning to make an add-on for all Abell planetary nebulae, but that would take too long, so I'm just going to release them as I go.

Abell 1 and Abell 8

Abell 1 and Abell 8 are both extremely faint and relatively simple nebulae. From what I can tell, Abell 1 looks quite similar to Abell 39 but is more faint and reddish, and is also slightly deformed. Abell 8 looks similar to Abell 39 but is reddish, see this picture.

To make such a model, open Blender and create an Ico Sphere. For Abell 1, before subdividing add some "dents" to model the deformed shape, using Sculpt Mode as mentioned earlier in Ju 1. After you save it as an OBJ file, edit it into a ASCII CMOD file but make all the points reddish, to match the color.

(Fixed an incorrect filename. Thanks SevenSpheres for notifying me of this.)

Abell 1 (left) and Abell 8 (right)

Enjoy:

[gironde]

I like all this

[LukeCEL]

Update: instead of using the Celestia Forums to upload add-ons and models directly, which has become quite tedious, I will start using a Google Drive link. It will be added to the first post.

Best,
LukeCEL

[LukeCEL]

Hi everyone, I'm gonna talk to you about cylindrically symmetric objects. A lot of objects in astronomy are cylindrically symmetrical, including bipolar nebulae.

Bipolar nebulae and such are great because they fit very nicely within a cylindrical coordinate system. If you understand what a polar coordinate system is, and a Cartesian coordinate system, then you'll very easily understand the cylindrical coordinate system. Like the polar coordinate system, one variable (the "radius") is the distance from the central "pole", and another variable (the "azimuth") is the angle about that central "pole" from another direction. The final coordinate simply defines the "height" along that central "pole".

But anyway, since these objects are cylindrically symmetric, we only need a "slice" of the object and we can build the rest of the object. Imagine rotating that "slice" 360 degrees around the pole, like a spinning top.

The curve on the left is spun around the blue axis to create the shape on the right.

So in practice, this is how I do it. Firstly, I create a set of points (2-dimensional) that follow the curve of the cross-section that I want. Note that these points have to be located equidistant from each other: if they're not, you will end up with ring-shaped gaps in your final model. In the final model, each of those 2-dimensional points appears as a "ring", and there are many rings stacked on top of each other.

Next, for each point I define the x-coordinate of that point as the radius, and the y-coordinate as the height. For the azimuth, I pick a bunch of angle values between 0 and 360 degrees, equally spaced out. Keep in mind that each ring will get a different amount of points, depending on its size. (The size of the ring depends on the circumference, whose size is proportional to the radius). Converting them to Cartesian is very simple:

x = radius * cos(azimuth);
y = radius * sin(azimuth);
z = height.

So that's the underlying math behind it. The next post will have a step by step tutorial for how to do it, using Abell 14 as an example. Abell 14 is a very symmetrical bipolar nebula.

Added after 30 minutes 24 seconds:
Abell 14

As mentioned before, Abell 14 is a very symmetrical bipolar nebula and an ideal one to use the cylindrical "spinning" technique (that's how I call it in my head). Here is a picture showing its structure.

You will need GeoGebra for this. I use GeoGebra Classic 5, because of unrelated limitations on GeoGebra Classic 6. The script that I used is a Perl script. Your computer will need to be able to run Perl.

Step 1: Creating the "point-list"

First, we need to come up with the "point-list". If you look at a picture of Abell 14, you'll see that it looks somewhat like two donuts stacked on top of each other. Below is the curve that I used. You'll see that although the entire curve is an ellipse (shown in orange), I only need the stuff in the top left quadrant (shown in black). This is because when "spinning" about the pole, you spin 360 degrees. Additionally, we can reflect the entire structure downwards to get the other lobe, since Abell 14 is bipolar. But if you're simulating, say, a comet tail or a bow shock, then that would not be necessary.

Next, open GeoGebra and create a new project. I inputted the equation of the curve into GeoGebra, like this:

You'll notice that I also added in the line y = 0. That's because for Abell 14, I want the points to start at y = 0 so that when the structure is reflected downwards, it has no gaps. (We're reflecting about the line y = 0; in 3D this corresponds the plane height = 0).

To start adding in the points, go to the second box at the top left and click on it. Select "Intersect" and click at where y = 0 intersects with the curve, like so:

You'll see that it creates a point called "A" at that point.
Go to the menu at top left and click on the circle icon. It looks like this:

CircleWithCenterThroughPoint.png (19.79 KiB) Viewed 26355 times

Now, click on point "A" to create your first circle. The radius of that circle should define how far you want the "rings" to be spaced out. With a larger radius, the points will be farther away and the sprites will have to be larger to make up for this. With a smaller radius, the points will be closer and the sprites will be smaller.

FirstCircle.png (15.02 KiB) Viewed 26355 times

Go back to "Intersect" and create a point at the intersection of your curve and your first circle.

SecondPoint.png (14.97 KiB) Viewed 26355 times

On that second point, create a circle and drag until your circle sits on the previous point. At this point, these circles should be interlinked—the radius of the circles pass through the centers of their neighboring circles, which means that all their radii are equal. On the other side of that circle is another intersection. So keep creating circles that are linked to each other, until you are happy with your "cross section":

My point list stops there because if you look at Abell 14, there is a sort of "cavity" on either end of Abell 14. Additionally, you may notice that I've renamed all the points on the curve to A1, A2, A3, etc. To do this, right-click on each point and click "Rename".

This is so that when you open up "Spreadsheet View" (by going to View → Spreadsheet), the list of points will be visible.

Select those points and copy-paste them out. That's your "point list".

Added after 28 minutes 29 seconds:
Step 2: Turning the "point list" into a 3D model

So this step is relatively straightforward, because I programmed a Perl script that does it for me. The perl script is available below.

To run it, open up your computer's command-line (Terminal for macOS, Command Prompt for Windows) and type in "perl " followed by the location of the abell14.pl file. If you drag that file directly into the command-line window, it will automatically put it there.

Inside the Perl script are some variables used to write the CMOD file. They are:

$opacity = the opacity of the points.

$pointsize = the size of the point sprites.

@rgb = the RGB color for the point sprites. For Abell 14, this is a reddish color.

@radii = this is a list of all the x-values from our "point-list".

@heights = this is a list of all the y-values from our "point-list".

The Perl script automatically deals with the mathematics and the formatting of the CMOD file. Once you run the Perl script, it will spit out the contents of an ASCII CMOD file that you can copy-paste into a .cmod file.

Even though the "cross section" only defines one lobe of the bipolar nebula, this file simply reflects it across the other side by inverting the x, y, and z coordinates. But say you don't want that. Say you want something that isn't bipolar.

In that case, change this line:

Code: Select all

my $total = 2 * scalar @points; # number of total points

to this:

Code: Select all

my $total = scalar @points; # number of total points

and change this line:

Code: Select all

for (my $j = 0; $j < $total / 2; $j++) {

to this:

Code: Select all

for (my $j = 0; $j < $total; $j++) {

and delete this bit of code:

Code: Select all

   # print other side
   printf '%.6f %.6f %.6f %.3f %s %s %s', -1*$points[$j][0], -1*$points[$j][1], -1*$points[$j][2], $points[$j][3], $points[$j][4], $points[$j][5], $points[$j][6];
   print "\n";


In the picture below, you can clearly see how the cross section makes up the entire nebula:

So, that's it. Below, I will upload the GeoGebra project file, as well as the perl script. The finished add-ons and ASCII models are available in the Google Drive folder at the top of the thread.

Enjoy:

[LukeCEL]

MyCn 18 (Etched Hourglass Nebula)

I'm releasing another bipolar nebula today. I'm using the same method as mentioned above. However, I didn't use an equation for the curve; instead, I traced out the density map from Vincent Icke's simulation of MyCn 18.

All the resources (the GeoGebra file, the Perl script, ASCII CMOD, and finished add-on) are available in the Google Drive link in the first post.

[LukeCEL]

Abell 2

Abell 2 is poorly studied, and only has very low-resolution photos taken of it, such as this one. Therefore, I tried my best to make a model consistent with the features visible. To "fill up" the space of the nebula, I generated points with random x-, y-, and z-coordinates and rejected those if they fell outside of the outer shell. This roughly works, but isn't the best method because inevitably some points will end up being closer or farther away and you don't get an even effect.

If you look at an image of Abell 2, it looks like there are two "cavities" going along the north-south axis. To recreate this, I used black sprites. When using black sprites, pay attention to the ordering of the materials, because it seems like if done improperly, you don't see the black sprites at all.

All the resources (ASCII CMOD and finished add-on) are available in the Google Drive link in the first post.

Abell 2, with its two "cavities"

Erratum: the readme says the central star is included, but this is not true: I didn't bother including the central star because there wasn't enough literature information on it. Thank you to The Minmus Derp for pointing this out.

Added after 3 hours 11 minutes:
Abell 3

The only paper I could find about Abell 3 is Akashi et al. (2018), which briefly mentioned that Abell 3 has a barrel-shaped structure.

I first created a prolate ellipsoid in Blender by taking an Ico Sphere and scaling it along one of the axis by pressing "S" then "Y". This allows you to drag the cursor to scale the ellipsoid along the Y direction. (Actually, I don't remember which direction I scaled it in, but for the sake of this I'm going to pretend like it was the Y-axis.) To recreate the barrel shape, I deleted all points whose Y value was not within a certain interval.

You'll notice that Abell 3 has a very "rough" appearance, in contrast to other models I made, like Ju 1, which appear very smooth. This is because there is a large variation in point sizes. The more variation, the "rougher" the texture appears.

Abell 5 and Abell 9

I couldn't find any paper that investigated the structures of either Abell 5 or Abell 9, so I had to imagine. I imagined that Abell 5 is barrel-shaped like Abell 3, but viewed face-on.

To recreate the shape of Abell 5, I used a similar method to Abell 3. However, I sculpted the model so it was more angular. Additionally, I made the size of the points depend on another axis. The farther it was from that axis, the larger the points would be.

I also imagined that Abell 9 has a similar shape but is viewed from a different angle. Here is the DSC code:

Code: Select all

Nebula "Abell 9"
{
   RA        5.4824
   Dec       36.0514
   Distance  13000
   Radius    1.17 # from angular radius 18.50 arcsec
   Mesh      "abell5.cmod"
   Axis      [-0.0559 0.8019 0.5948]
   Angle     194.927
   InfoURL   "http://simbad.u-strasbg.fr/simbad/sim-id?Ident=PN+A66+9"
}

Abell 4 and HaWe 10

Abell 4 and HaWe 10 are both simple planetary nebulae that look somewhat like Abell 39, so I reused the model. DSC code:

Code: Select all

Nebula "Abell 4"
{
   RA        2.75664
   Dec       42.5508
   Distance  18300 # from Gaia DR2 parallax
   Radius    0.89  # from angular radius 10.00 arcsec
   Mesh      "abell39.cmod"
   InfoURL   "http://simbad.u-strasbg.fr/simbad/sim-id?Ident=PN+A66+4"
}

Nebula "HaWe 10:HDW 7"
{
   RA       7.9198076
   Dec      9.5525499
   Distance 6660 # from Gaia DR2 parallax
   Radius   2.93 # from angular radius 110 arcsec
   Mesh     "abell39.cmod"
   InfoURL  "http://simbad.u-strasbg.fr/simbad/sim-id?Ident=PN+HDW+7"
}

STC code:

Code: Select all

"SDSS J075511.30+093309.2" # central star of HaWe 10
{
   RA 118.7971142
   Dec 9.5525499
   Distance 6660 # from parallax: 0.4896 +/- 0.1965 mas
   SpectralType "sdO"
   AppMag 17.888
}

Once again, all of the relevant files (ASCII CMOD and finished add-on) are in the Google Drive link in the first post.

[LukeCEL]

Abell 6

Abell 6 is an extremely faint nebula. In general this is true of all planetary nebulae, so these models are way brighter than in reality. To the unaided eye, they would probably be completely invisible.

That being said, looking at photographs we can get a basic idea of what Abell 6 looks like. I used various photographs as guides, including this one by Mike Keith. There is a "V"-shape, and on one side, there appears to be more emission than the other. To emulate this, I used two 3D inequalities to determine where I should generate points.

Here is a diagram showing the two inequalities I used. I randomly generated points using random X-, Y-, and Z-coordinates using the RAND() function in Excel, and rejected all points that were 1) outside the sphere x^2 + y^2 + z^2 = 1, or "above" the parabola shape z = y^2 - 0.5. (The axes might have been switched, I don't remember.)

While looking at the image, it also appears that some areas of the "shell" are brighter than others. There are several recreate this using sprites, but the way I did it was in Blender itself. I selected the Ico Sphere, went to "Edit Mode", selected individual faces by shift-clicking on them, and subdivided them by pressing "W". This creates more vertices (and thus more point sprites). Unfortunately this is a relatively crude method that tends to create triangle-shaped patches on your finished model.

Subdividing an individual face in Blender 2.83.

Anyway, the ASCII model and finished add-on are in the Google Drive folder in the first post.

[LukeCEL]

Abell 7

Abell 7 is the first planetary nebula in the Abell catalogue to show relatively complex features. These features are only visible in extremely long-exposure shots, such as this one by Don Goldman. That is the image that I based my model on.

These complex features cannot be easily made using equations, so I used GeoGebra to plot those extra sprites. As I've said earlier, GeoGebra Classic 5 is recommended over GeoGebra Classic 6 - this is because version 6 has a limit to the number of rows in your spreadsheet, something that will be crucial later on.

Moving on to the actual tutorial. The first component I finished was the outer "shells". Notice that in the photo, there appears to be an outer blue shell and an inner pink shell. Both shells appear poorly defined, and are also "mottled" in appearance. To recreate simple shells, the standard method I have is to take an Ico Sphere in Blender, subdivide a few times, and export the mesh as an OBJ and use those points.

For Abell 7 my procedure was modified slightly, in that I had to elongate the nebula in one axis. I measured it using GeoGebra by plotting a blue ellipse and playing around with the dimensions until they looked okay. I also did the same for the pink ellipse, which represents the inner pink shell and is made to be slightly smaller (by a certain coefficient). But instead of creating two "shells" in Blender, I took every other point and shrunk the coordinates by that coefficient.

Image of Abell 7 plotted in GeoGebra, with two reference ellipses. For this to work, the central star has to be at (0, 0). There are two sliders at the top left. The variable b represents the ratio of the vertical semi-axis to the horizontal, while the variable c represents the relative semi-axis of the pink ellipse compared to the blue.

Now that I finished the shells, I then started doing the actual details. Because each point corresponds to a sprite, you want to place points where there is brightness in the image.

Go to GeoGebra, then "View" then "Spreadsheet". That opens up Spreadsheet Mode. You should also have "Graphics" mode enabled. In cell A1, type (0, 0) and you'll notice that it appears on the Graphics view.

To place the points on a large scale, I recommend typing (0, 0) in cell A1, then dragging the bottom right corner downwards to create duplicates. They are all stacked on top of each other at (0, 0), and from there you can drag those points to wherever you want.

In my GeoGebra file, I actually made two different sets of points. One set is depicted with dark red rings, while the other as small pink discs. The dark red rings represent sprites with lower opacity and larger size, and the small pink discs represent sprites with higher opacity and smaller size. You can change the color and many other viewing options by right-clicking the cells, columns, or rows.

The beauty of the Spreadsheet view is that it allows you to select the entire column of points, and copy-paste it into a text file or Microsoft Excel, where it can then be split into further columns and manipulated at will.

What my GeoGebra file looks like.

Lastly, I assembled everything together in a Microsoft Excel spreadsheet. The first sheet, called "Shells", is where I handled the outer shells. The second sheet, called "FineDetail", handles the sprites corresponding to the pink points. The third sheet handles the sprites corresponding to the dark red points. Since I only added two dimensions, I needed a third dimension. You can look in the spreadsheet to see the exact formulae I used - essentially I used the distance from the center to create a range, such that the points would fall into an ellipsoidal shape. For some isolated regions, I set the depth to a distinctly different value so everything didn't fall into a plane, more or less.

This isolated region (white arrow) has a "depth" that is different from the rest of the points, to add variety. I did this by finding those points that fit within a certain bounding box, and adding/subtracting some constant to the "depth" value.

All the resources (the GeoGebra file, the Excel file, ASCII CMOD, and finished add-on) are available in the Google Drive link in the first post.