I think there is some confusion.
If you want a white light, just buy white LEDs, they are MUCH cheaper.
LEDs don't use voltage. They use current.
LEDs need a minimum voltage in order to switch on. After that, you can destroy them by allowing too big a current to flow. For example if you apply 8.8V without limiting the current, all the LEDs will break. Too little current, and you won't see them.
If you want to have control over the brightness of the three component colours of the RGB LEDs, they need to be wired independently, so the voltages that are relevant are:
Voltage: Red - 2.0v // Green/Blue 3.0-3.4v
not the sum - they are in parallel, not series.
The spec for the RGB LEDs say they switch on at different voltages.
They can all be driven by the same voltage providing it is bigger than the biggest value. For simplicity, lets use 5V to drive them, because that is sufficient, is easy to arrange, and is Arduino friendly.
What this means is each colour component needs a different value of resistor to limit the current to a safe level. It's current that needs controlling, not voltage.
Here's a way to work it out. The spec. says:
Max Continuous Total Forward Current: 25mA
So, lets guess and divide by 3, to get 8mA/colour (near enough, and smaller)
To get 8mA for Red:
5V-2.0V (red forward voltage) / 8mA = resistor = 375 ohm, nearest (larger) common value is 390 ohm
To get 8mA for Green:
5V-3.0V (green forward voltage) / 8mA = resistor = 250 ohm, nearest (larger) common value is 270 ohm
To get 8mA for Blue:
5V-3.4V (blue forward voltage) / 8mA = resistor = 200 ohm, nearest (larger) common value is 220 ohm
I recommend trying these out in a breadboard because the brightness of each colour may be significantly different at the same current, and you may want to tweak them a bit (I'm sure someone has solved this, but I can't find the reference, sorry).
Now, you just need to adjust the colours using PWM, knowing that you are getting close to the maximum brightness from the RGB LED.
The spec. for an Arduino's ATmega says 200mA tops, so that would mean 200mA/25mA (max current/RGB LED) = 8 RGB LEDs at full brightness. Drop the brightness by 25%, and you could drive them directly with the Arduino.
If you want all of the LEDs to be the same colour, then they can be wired in parallel.
You will use 3 ADC pins for your colour-setting potentiometers, so you only have 15 pins left. This could divide nicely into 5 groups of 3 pins for each RGB triple. That is enough to drive 10 RGB LEDs at slightly reduced brightness. You could even have 5 independent colours, with pairs of RGB LEDs showing the same colour.
There are only 6 PWM pins, which means that hardware in the microcontroller controls the ratio of on to off. But, if all you want to do is control some LEDs and read your potentiometers, you could do PWM in software using delayMicroseconds().
Have a look at the example Examples->Analog->AnalogInput and you'll see them using the value of an analogue input to control the time that a LED is on and off. The same technique would allow you to drive all 15 pins (with some ingenuity) as if they are PWM.
If you don't like that approach, you could dig into using interrupts from the PWM timers so that you can switch the other pins to match. So you get the ability to use analogWrite to set the colours, and three small 'interrupt service routines' to make all the pins follow the PWM pins.
To drive more current, and use a simpler arrangement with the 6 hardware PWM pins, use something like a ULN2803, which contains 8 Darlington transistors in one handy package. If you want all the same colour RGB LEDs, I'd spread the load over 6 of the Darlington transistors; put 5 RGB LEDs onto each of 3 Darlingtons. Put 5 of the Reds onto one, 5 of the Blue's onto another, 5 greens onto another, and repeat for the other 5 RGB LEDs. Then drive the 6 Darlington transistors from the 6 PWM pins.
If you follow this approach, you may be tempted to reduce the number of resistors. You might want to have one resistor for the 5 RGB Red LEDs which are in parallel, and similarly for the green and blue. When combining parallel resistors into one, it'll need a much smaller (1/5th) resistance to get enough current for all the LEDs. There are a few issues, but IMHO, the main one is if an LED fails, more current will go through the other LEDs, which may cause one to fail, so more current will flow through the remainder,which may cause another to fail, ... It may be worse. If one part of an RGB LED gets too hot and fails, it may cause the other components in the same LED to get too hot, and fail, which may cause a fault to spread from the red channel to the other colours.
A reasonable alternative is to use resistor arrays:
http://www.rapidonline.com/Electronic-Components/Resistors-Potentiometer/Resistor-Arrays/SIL-Resistor-networks/29581
where a singe component has multiple resistors in one component.
If you want to drive every LED component independently, then you could use shift registers, like 74HC595, because the Arduino hasn't got enough pins to drive each one directly. The code to actually vary the brightness using PWM is much more complex than simply switching them on and off. So try to work that out (or find an example) before trying the technique.
Any technique controlling each LED for part of the time will reduce the brightness. The technique is called time-division multiplexing, which is 'time sharing' a pin between several uses. It is sometimes just called 'multiplexing'. It is popular, but if you have an LED for 1/2 the time, it will be (very roughly) 1/2 as bright, so you might want to experiment with this before building it.
It is not inherent in using shift registers (e.g. 74HC595) that you need to 'multiplex' LEDs and hence reduce the brightness. We can use shift registers to 'make' enough extra pins to control something for all of the time, and reduce the need for 'time-sharing' pins.
You can use a shift register to directly drive a LED and switch it on all the time, look at the code at http://www.arduino.cc/en/Tutorial/ShftOut22.
I think the code in John_Ryan's example is a better fit for situations where you are trying to drive lots of LEDs full on or off, with very few pins. which isn't the problem I think you have posed.
You could drive the LEDs as a "time-division-multiplexed matrix". As you only want 10 RGB LEDs, (30 individual LEDs), and there are 15 Arduino pins available, which is enough to drive 56 LEDs (7 groups x 8 LEDs/group) using time-multiplexing, each LED part of the time. This would give reduced brightness, but individual control of every LED. The software would be a bit more complex, and use the same technique as software PWM.
I'd recommend something like Darlington transistors to sink current from groups of LEDs to keep the brightness high. If you are sneaky, and fiddle directly with the PWM timers, you could use the PWM timers to drive the brightness of every individual LED (but at reduced overall brightness because the LEDs are each on for a fraction of the time).
There are chips which drive LEDs with PWM, e.g. TLC5940, which combine shift registers and PWM. So the cost and hardware complexity may give you the level of control you want. I'd recommend some experiments with the Arduino and some Darlington drivers, and or shift registers first though, because that will help you understand what those chips can do.
Next, look at your PC PSU, and try to find a spare 5V. It is DC.
I'd put a few hundred microfarad of capacitors on your circuit across the 5V PSU wires to reduce electrical noise.
Summary:
a. RGB LEDs use current not voltage, and need independent control of each LED, so don't sum the voltages, it isn't relevant
b. if your PC PSU has a spare 5V, it is DC, and you could use it
c. at slightly reduced brightness, you could drive 10 RGB LEDs directly with an Arduino, but software gets a bit more complex
d. simplify the hardware by using current amplifiers (e.g. Darlington transistors) to allow the 6 PWM pins to drive groups of RGB LEDs
HTH
GB-)