The computer monitor is a lot of pixels. This is like a litebrite machine.
I played with this when I was a kid. You can draw a picture by picking what color to put in each place.
The computer monitor is an automatic version of the same thing. But instead of picking which light bulb to put at each hole, it has 3 light bulbs. They are RED, BLUE, and GREEN. So if you put 100% power to red, and 100% power to green, and 0% power to blue, then the output for that hole is YELLOW. Because it is GREEN and RED light at the same time, and that looks YELLOW.
This is pretty smart. So we can make all the colors on a mini color wheel using ON (100%) and OFF (0%).
But then the people got even smarter. Instead of using ON and OFF, we can use
fading lights, like the fancy ones if you have ever seen that, where giving less ELECTRICITY to the light will cause less BRIGHTNESS.
This allows us to make a whole lot more colors. For example, we can have 100% RED, but only 25% GREEN and 0% BLUE. And now it makes orange instead of yellow!
And we can apply that to create 255 shades of green, times 255 shades of red, times 255 shades of blue, for a total of 16581375 different colors we can choose to show in that one single pin! Wow! It's better than a litebrite machine!
So, the way I think about you problem requires understanding how Warcraft III, and Retera Model Studio, and all these things are instructions for the advanced "litebrite" like machine for what to show.
The problem you are having is that the
Reforged machine works differently by 20 years than the
Warcraft III machine.
So above are some examples of how the
Warcraft III machine (2002) decides the final color for these pixels. There were some different functions in the graphics card at the time, and the computer could pick one of the functions. "Add" was one of the functions, like in the picture above. But "overwrite unless alpha" that I tried to show above is also one of the functions. (It is not actually called this in the technology, I made up that name as an example.)
The math behind it is slightly more complicated than overwrite unless alpha, but we could think of it like a function. If we are just adding, then obviously we could say the color
X at the target point is
X = Y + Z where
X,
Y, and
Z are 3-part vectors where each part is a number to represent how much ELECTRICITY we put in RED, GREEN, or BLUE at that hole on the screen. In this case,
Y is the previous color value on the screen (red team color), and
Z is the new incoming color value from the Grunt file, at that indicated coordinate.
In a similar way, the function getting used for this "alpha" related stuff adds a fourth invented number that exists in the computer but obviously is not actually on the screen at the end.
Sometimes we could almost express that like the following, but maybe that is confusing:
X.xyz = Y.xyz * (100% - Z.a) + Z.xyz * Z.a
So, for example, if the Grunt file has {100%, 50%, 0%, 100%} for the new Z value, then the first three are used to mean orange, and the last one is used to mean that it completely blocks out what is behind it, if we use this particular math function for combining new data. Then, assuming we have some
{Y.x, Y.y, Y.z} that are the previous color at that spot, the math would be:
Then
X = {Y.x * (100% - Z.a) + Z.x * Z.a, Y.y * (100% - Z.a) + Z.y * Z.a, Y.z * (100% - Z.a) + Z.z * Z.a } or if we insert our example numbers:
X = {Y.x * (100% - (100%)) + (100%) * (100%), Y.y * (100% - (100%)) + (50%) * (100%), Y.z * (100% - (100%)) + (0%) * (100%) }
or if we then evaluate:
X = {100%, 50%, 0%} and so it is the exact color from the Grunt texture. But if we put a different input to the function, such as {100%, 50%, 0%, 0%} for the new Z value data, then the output is the team color. That is, the solid red, which was
Y in this equation.
So the result is that in this mode, the machine composes the "player color" by using two layers -- the color beneath that is a simple solid color, and the layer on top that uses the hardware pipeline.
And, in the 2002 version of the
hardware there was only this simple function, available in each Graphics Card hardware, for the computer code to execute.
But on the Reforged they use a new
hardware design that allows us to have programmable shaders. This means that the fundamental math to decide the color used can be
specific to the game program and send into the hardware, then run on every single pixel on the screen separately.
So in the Reforged version of this, the texture data has more numbers. Where the old 2002 system would have a texture file with {100%, 50%, 0%, 100%} for the Grunt in the manner I suggested above, Reforged has more numbers for every pixel of the surface. To reiterate, the old game texture for Grunt was 256 x 256 cells, and each cell would be like this:
Red=100%
Green=50%
Blue=0%
Alpha=100%
(Above describes and orange cell.)
However, the 2020 Reforged program sends
its own instructions to the hardware
for every pixel and so it can do more advanced math. And so the Grunt texture in the Reforged system, in each cell, has the data available in the following format:
Red=100%
Green=50%
Blue=0%
Alpha=100%
TeamColor=0%
If you have followed me so far, and you can imagine replacing
X.xyz = Y.xyz * (100% - Z.a) + Z.xyz * Z.a with a new more complex equation that uses
Z.t where
t is the % of Team Color, then you will understand what is happening in Reforged. Maybe that math function would be something like:
X.xyz = Y.xyz * (100% - Z.a) + (Z.xyz * (100% - Z.t) + C.xyz * Z.t) * Z.a
... That is assuming some new vector
C whose values are
{100%, 0%, 0%} meaning solid red, that is the
team color vector. So then
every pixel of the texture file has a corresponding TeamColor-ness value Z.t which is included in the math function to decide color
separate from the transparency data Z.a for that pixel.
And that is why it is impossible to express the Reforged graphic file as a Classic graphic file!
So in the above case, Retera Model Studio knows the programming difference of the two systems. I can make a file that loosely matches how you want the thing to look, and we can put alpha on there or not, but we can never put
both alpha and team color-ness in each pixel. This kind of tattered-but-player-color thing is not possible on the 2002 math function.
So I understand what you want. Obviously, I was able to
change the code of Retera Model Studio to match Reforged so it would even render how you want!
But this render is loading 5 numbers for the tattered red surface, and there is both a
transparency number "alpha" and a
TeamColor-ness number!
So it can render in the way shown above, even though, like in this picture, the
triangles of the
"tattered-red" surface have no tatter data! They are a wide, over-estimate shape!
Or, shown in isolation:
On the 2002 system,
there is not a math blend function for painting both holes in the shape and also color that changes by player! They are one and the same -- color that changes by player is a hole to another layer underneath, that is a simple solid color of the color that changes by player.
By contrast, if we think about "tattered" shapes on the old 2002 system, such as this one:
Even if we
turn off the texture, this thing has holes it in that are shaped by the TRIANGLES part. That is a simpler, older technology.
So, if you want your shape to have both holes and also be red, then if you understand what I am saying, as an artist you should change the triangular formation to construct a shape that will have both holes and also be red.
Approved
