ICC_StarConfigBase_WIP

@Kopernicus:FOR[InterstellarConsortiumCatalogue]
{
	//Interstellar Consortium Catalogue Star Config Base by GregroxMun.
	//If you use this, PLEASE make sure you read the whole config and its comments.
	Body
	{
		name = ICC_SunAnalogue

		//Unique Body Identifier:
		identifier = ICC/SunAnalogue

		Template
		{
			name = Sun //make this object a star.
		}
		Properties
		{
			// default constants.
			radius = 69550000  // 1/10th of RSS Sun. 1 KSP-Scale Real Sun Radius.
			mass = 1.9891e28   // 1/100th of RSS Sun. 1 KSP-scale Real Sun Mass.

			// user inputs.
			luminosity = 1     // 1/100th of RSS Sun. Normalized to KSP-scale Real Sun.
			@radius *= 1       // 1/10th of RSS Sun. Normalized to KSP-scale Real Sun.
			@mass *= 1         // 1/100th of RSS Sun. Normalized to KSP-scale Real Sun.
			temperature = 5800 // Equal to RSS Sun. Used to find color.

			//"luminosity" and "temperature" values in the Properties{} node are NOT used by Kopernicus. This is strictly for keeping track of things.

			// Luminosity, Radius, and Temperature MUST be related by the equation:
			//			L = R^2 * T^4.
			// Where L = Your Star's Luminosity in Solar Luminosities.              ----   ----             (to be clear, that's 1/100th the real scale value)
			// Where R = [Your Star's Radius] / 69550000 meters.
			// Where T = [Your Star's Temperature] / 5800 Kelvins.
		}
		Orbit
		{
			referenceBody = Squad/Sun

			//Make sure the star is always referencing the stock solar system.
			//Orbital elements are computed by the IC spreadsheet found at the KSP Forums thread: https://forum.kerbalspaceprogram.com/index.php?/topic/177439-kopernicus-interstellar-consortium/
			//For this example I'll use the elements for the star Alternis. Make sure you've reserved a star with the Interstellar Consortium
			// and that you use your own star's orbital elements.
			semiMajorAxis = 4.71E+13
			eccentricity = 0 //Always 0.
			inclination = 16.01993527
			argumentOfPeriapsis = 90 //Always 90.
			longitudeOfAscendingNode = 120.5297059
			meanAnomalyAtEpoch = 0 //Always 0. IMPORTANT NOTE: MAYBE NOT, UNSURE OF THIS ONE.
			period = 1E+12 //Period should be arbitrarily high, there should be effectively no stellar motion. This is measured in seconds and is around 30,000 years.
		}

		//Fill in the relevant information from the spreadsheet here as well for I.C. plugin compatibility.
		//Make sure you take it from the "Star Position (Config Files)" table.
		@InterstellarConsortium
        {
            @position = 7.7, 3.9, 1.3
            @SOI = 0.8
        }

		ScaledVersion
		{
			Light
			{
				//This defines the light emitted by the star.

				//User Inputs

				ambientLightColor = 0,0,0,0
				sunAU = 69550000 //SET THIS EQUAL TO THE STAR'S RADIUS.
				sunFlare = //Sun Flare Filepath.
				//For stars, sun flare textures should omit the camera ghost particles. I've included a stockalike sun flare with no ghosts.

				//OK here is where things get confusing so pay close attention.
				//The above values are all misnomers.
				//They should be called Insolation and Luminosity, respectively.
				//The "luminosity" value here is equal to the watts per square meter recieved from the star at 13,599,840,256 meters, or 1 Kerbin Orbit Radius.
				//1 Kerbin Orbit Radius is NOT 1/10th of 1 astronomical unit, in fact it is equal to 0.090909317 au, which is close to 1/11th.
				//The value "radiationFactor" can be found by multiplying your star's luminosity value by 1.21.
				//The value "luminosity" can be found by taking the square root of your star's luminosity, then multiplying by 1.1, then multiplying by 1360.
				//The value "insolation" is the same as "luminosity" but you multiply by 0.15 instead of 1360.

				luminosity = 1496
				insolation = 0.165
				radiationFactor = 1.21

				//This is the point where you realize how much of a mess "Kerbol" is.

				//Color of sunlight. These should all be the same.
				//Use the calculator here: https://academo.org/demos/colour-temperature-relationship/
				//to figure out what color your star's light should be based upon the temperature you set up in the Properties node.
				//6600 K is true white, but anything between 5700 and 6800 K can safely be interpreted as true white.
				//Using the RGBA(R,G,B,A) scheme is probably the easiest way to input color here.
				//Make sure you don't forget to put in a value (255 is fine) as the A/alpha value. It doesn't matter what value is used for Alpha, but if you forget it, Kopernicus won't parse the color correctly.

				sunlightColor = RGBA(255,255,255,255)
				scaledSunlightColor = RGBA(255,255,255,255)
				IVASunColor = RGBA(255,255,255,255)
				sunLensFlareColor = RGBA(255,255,255,255)


				//Intensity Curves. These are also fairly complicated.
				//Intensity curve keys take the form of
				//key = distance in meters, sunlight intensity at that distance, 1st derivative, 2nd derivative.
				//Unless you are using a float curve editor or you have a good understanding of differential calculus (seriously), use 0 for the derivatives.
				//To make these curves, we need to know what the "habitable zone" of the star is.
				//Specifically, the distance at which Earth would have the same temperature as it does around the Sun.
				//This is found by Luminosity^0.5. To be clear, that's the actual luminosity you recorded in the Properties{} node, not the "luminosity" value from above in the Light{} node.
				//That distance will be in units of 1/10th of one astronomical unit, so multiply by 14959787070.0 to get the actual distance. We will call this value the "Local A.U. or LAU."
				//You will have to define three curves: IntensityCurve, IVAIntensityCurve, and ScaledIntensityCurve. The first two are identical to each other,
				//but the last one has its distance values divided by 6000.
				//The intensity curve we use can be defined a number of ways, but importantly, intensity must drop to zero before the end of the star's SOI according to Interstellar Consortium.
				//Physically speaking, the intensity of light should drop by the square of the distance. In reality, our eyes have a logarithmic vision, so to account for this,
				//we'll use the equation Intensity = Distance^-0.5.
				//In this config I'll define the intensity at a few points, but in your star system you should define the distances at orders of magnitude (0.01, 0.1, 1, 10, 100, 1000) and at the semimajoraxes of each of your planets. (Or periapsis AND apoapsis for eccentric bodies)
				//You can use a different intensity curve, for instance if you wanted to have the same lighting for all planets, as long as it fades to zero before the edge of its SOI.
				IntensityCurve
				{
					//we define this to be where intensity = 1. 1 LAU.
					//key = 14959787070 1 0 0

					//0.1 LAU.
					key = 1495978707 3.16227766 0 0

					//0.5 LAU.
					key = 747989354 1.41421356 0 0

					//1 LAU.
					key = 14959787070 1 0 0

					//5 LAU.
					key = 74798935350 0.447213595 0 0

					//10 LAU.
					key = 14959787070 0.316227766 0 0

					//100 LAU.
					key = 149597870700 0.1 0 0

					//1000 LAU.
					key = 1495978707000 0.0316227766 0 0

					//0.8 ki -- the edge of the SOI.
					//1 ki = 1E+13 meters.
					key = 8E+12 0.0 0 0

					//Very luminous stars might shine much further than the edge of their gravitational sphere of influence. But they should not shine too much further, and then only very dimly.
					//Likewise, dim red dwarf stars may fade to effectively zero long before you reach the edge of their SOI.
				}
				//duplicate the IntensityCurve and rename it to IVAIntensityCurve
				IVAIntensityCurve
				{
					key = 1495978707 3.16227766 0 0
					key = 747989354 1.41421356 0 0
					key = 14959787070 1 0 0
					key = 74798935350 0.447213595 0 0
					key = 14959787070 0.316227766 0 0
					key = 149597870700 0.1 0 0
					key = 1495978707000 0.0316227766 0 0
					key = 8E+12 0.0 0 0
				}
				//duplicate this again for the ScaledIntensityCurve, but this time divide all of the distance values by 6000.
				ScaledIntensityCurve
				{
					key = 249329.784 3.16227766 0 0
					key = 124664.892 1.41421356 0 0
					key = 2493297.84 1 0 0
					key = 12466489.2 0.447213595 0 0
					key = 2493297.84 0.316227766 0 0
					key = 24932978.4 0.1 0 0
					key = 249329784 0.0316227766 0 0
					key = 1.33333333e9 0.0 0 0
				}

				//Don't change this unless you know what you're doing.
				//This is the brightness curve for the sun lens flare.
				//The first number is some kind of inverse distance. The second number is size of the flare. Then of course, two derivatives.
				//The minimum size will represent the size of the stars in the stock skybox.
				brightnessCurve
                {
                    key = 0.000005 0.01 0 0
                    key = 0.00001 0.1 0 0
                    key = 0.0001 0.1 0 0
                    key = 0.001 0.3 0 0
                    key = 0.01 0.4 0 0
                    key = 0.1 4 0 0
                    key = 0.2 6 0 0
                    key = 0.3 10 0 0
                }

			}
			Material
			{
				//This defines the appearance of the surface of the star.

				//These colors should be the same as the temperature-based colors of the starlight.
				//If you used true white earlier but your star is really slightly cooler or hotter than that, you should use the true temperature colors here.
				emitColor0 = RGBA(255,243,231,255)
				//This color should be about 10 percent darker (but the same temperature) as emitColor0.
				emitColor1 = RGBA(230,218,208,255)
				//This color should be about 10 percent brighter (but the same temperature) as emitColor0, up to values of 255.
				rimColor = RGBA(255,255,254,255)

				//These are fine as they are, you shouldn't need to change them.
				rimBlend = 0.5
				rimPower = 1

				//sunspotColor should be a new temperature-color equal to about 0.65 times the temperature of
				sunspotColor = RGBA(255,201,157,255)

				//This are fine as it is, you shouldn't need to change it.
				sunspotPower = 1

			//	sunspotTex = filepath
				//sunspotTex can be used to customize the sunspot map. It is a grayscale texture where white represents darker regions and black represents lighter regions.
				//for most purposes the stock sunspot texture is fine, but red dwarfs can look good with larger sunspots, and brown dwarf sunspot textures might resemble gas giant bands.
				//I've commented out the sunspotTex line so that the stock sunspot will load.
			}
			Coronas
			{
				//This defines the texture of the corona rim texture of the star.
				//You can use your own texture if you want, but I've prepared a few sunspot textures for specific star spectral types.
				//The stock corona can also be used for M to early-K red and orange dwarf stars.
				Corona
				{
					Material
					{
						texture = //Corona Texture Filepath
					}
				}
				// Duplicate the above Corona node, you need two of them and they should be identical.

				Corona
				{
					Material
					{
						texture = //Corona Texture Filepath
					}
				}
			}
		}
	}
}