If you want simple IDE I suggest you to pick Notepad++(free) or Sublime Text(you can evaluate it as long as you want).
Bregma is right! You should play with Visual Studio(or Xcode, Netbeans, Eclipse, wateva). It's normal to be confused first 1-2 weeks. But after that you will adore all the features in it, I promoise! Don't be afraid! After all, it is only a White rectangle with some text (and a spinning rainbow in XCode).
I find Xcode extreamly confusing, but if you read carefully everything will be fine
There is a *big* (ok not that big but still) difference between regular shaders and effects. First of all an Effect(*.fx) represents not only a single shader but a set of techniques and passes( technique is a set of passes and pass is a set of vertex + pixel +... shaders).
Also when using effects there are some *helpers*, such as it is possible to describe a sampler directly into the Effect file(something that is not possible using ordinary shaders).
So basicly effects are sets of shaders (passes) wraped in techniques. The Effects also provide some 'simplification' and structures that are not usable when compiling ordinary shader.
That means : "Create a function called VS, that takes input:
variable Pos, type float4 with semantics POSITION.
Since 'float4 VS( float4 Pos: POSITION ): SV_POSITION' function is a vertex shader that means that the InputLayout object (the one that describes the data into the vertex buffers) defined in the C++ will provide a data which has assigned semantics called 'POSITION'. Think of the semantics lika a string that is describing the variable usage.
So "float4 Pos: POSITION" means : look for a data that belongs to the vertex buffers that also has assignd semantics 'POSITION' and assign the value to the Pos variable.
Next the SV_POSITION means: The function will return a float4 variable that will be used as vertex position. All semantics that begin with 'SV_' are reserved to the pipeline and they have special meaning. SV_POSITION in that particular case means that the Projected vertex position is returned by the function. Later in the pixel shader you can define a variable with semantics SV_POSITION and use the interpolated value for some calculations.
1 - the planet itself with the texture that represnts the surface of the planet
2 - the atmosphere( the thin blue arc around the planet)
What we can do here is to draw the shape of our planet two times ( pass A and pass B)
A - we draw the sphere apply the lighting and the texture
B - we draw the sphere a little bit bigger (we could use addition scaling in our vertex shader). Based on the vertex positions of the planet mesh, and the sun position, we compute the color of the sphere(based on the athmosphere) and a trasperancy, because the atmosphere is actually transperant.
Because the same code is executed at the same time for multiple programs(single program multiple data):
GPUs execute your shader program multiple times at once to save instruction cache.
By doing this a limitation comes up - all programs that are executed togrether must process the same instriction at the same time. if some of the executed programs pick TRUE path of the branch, and other pick the FALSE path of the branch, then both paths of the branch will be performed for each group of programs.
Also In other cases some threads may *stall* because the path they've picked is *shorter* than the others.
Compiler will try to flatten your branch to avod stalls.
That is why we try to avoid branched as much as possible. There are some other reasons to avoid branching but this one is the main reason.