No

>No

1v1 me
Sword Base
10% Gravity
Spartan Lasers only
Fgt

I will join on this s-

>99% H2A

No

Casul

Demote other admins.
Post porn relentlessly.
Post pics of dead hedgehogs.
Watch the world burn.

If I had to guess, I'd say it's a cartoon scorpion.

Implying your posts contain thought.

Get your nut.

Battlefield, except for Hardline.
Assassins Creed.  Unity was fucked, but I still sunk a lot of time into it and had a lot of fun.
I can't think of any others, but I know there are more.
Have the Halos been a yearly release?  I mean, barring stuff like Spartan Assault and remasters, haven't they generally been 2+ years between games?  Either way, I usually buy all of them.

Don't expect anyone to care, but I don't care because I spent the last 10 hours or so figuring out how to blend texture mapping, normal mapping, and environment-map (skybox) reflections in one HLSL Phong shader, plus getting it all to work in DirectX, and it all finally works.

The texture and normal are usually used for floors, but oh well.

Texture mapping + cube-mapped reflections



Normal mapping (a little overkill)




So the gibberish for the shader looks something like:
struct Mtrl
{
float4 ambient;
float4 diffuse;
float4 spec;
float  specPower;
};

struct DirLight
{
float4 ambient;
float4 diffuse;
float4 spec;
float3 dirW; 
};

uniform extern float4x4 gWorld;
uniform extern float4x4 gWorldInv;
uniform extern float4x4 gWorldInvTrans;
uniform extern float4x4 gWVP;
uniform extern Mtrl     gMtrl;
uniform extern DirLight gLight;
uniform extern float3   gEyePosW;
uniform extern texture  gTex;
uniform extern texture  gEnvMap;
uniform extern texture  gNormalMap;

uniform extern float gReflectivity;
uniform extern float gNormalPower;
uniform extern float gTexBlend;


sampler TexS = sampler_state
{
Texture = <gTex>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU  = WRAP;
    AddressV  = WRAP;
};

sampler NormalMapS = sampler_state
{
Texture = <gNormalMap>;
MinFilter = ANISOTROPIC;
MaxAnisotropy = 8;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU  = WRAP;
    AddressV  = WRAP;
};

sampler EnvMapS = sampler_state
{
Texture = <gEnvMap>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU  = WRAP;
    AddressV  = WRAP;
};

struct OutputVS
{
float4 posH      : POSITION0;
    float3 toEyeT    : TEXCOORD0;
    float3 lightDirT : TEXCOORD1;
    float2 tex0      : TEXCOORD2;
float3 normalW : TEXCOORD3;
float3 toEyeW : TEXCOORD4;
};

OutputVS PhongEnvNMVS( float3 posL : POSITION0,
float3 normalL : NORMAL0,
float3 tangentL : TANGENT0,
float3 binormalL : BINORMAL0,
float2 tex0 : TEXCOORD0)
{
    // Zero out the output.
OutputVS outVS = (OutputVS)0;

////////////////////////// TANGENT SPACE CALCULATIONS:
// Build Tangent Binormal-basis.
float3x3 TBN;
TBN[0] = tangentL;
TBN[1] = binormalL;
TBN[2] = normalL;

// Transform matrix from object space to tangent space
float3x3 toTangentSpace = transpose(TBN);
// Transform eye position to local space.
float3 eyePosL = mul(float4(gEyePosW, 1.0f), gWorldInv);
// Transform to-eye vector to tangent space.
float3 toEyeL = eyePosL - posL;
// Transform light direction to tangent space.
outVS.toEyeT = mul(toEyeL, toTangentSpace);
///////////////////////////////////////////////////////

float3 lightDirL = mul(float4(gLight.dirW, 0.0f), gWorldInv).xyz;
outVS.lightDirT  = mul(lightDirL, toTangentSpace);

// Transform to homogeneous clip space.
outVS.posH = mul(float4(posL, 1.0f), gWVP);

// Pass texture coordinates to be interpolated during rasterization.
outVS.tex0 = tex0;
outVS.normalW = mul(float4(normalL, 0.0f), gWorldInvTrans).xyz;
float3 posW  = mul(float4(posL, 1.0f), gWorld).xyz;
outVS.toEyeW = gEyePosW - posW;

    return outVS;
}

float4 PhongEnvNMPS( float3 toEyeT    : TEXCOORD0,
float3 lightDirT : TEXCOORD1,
float2 tex0      : TEXCOORD2,
float3 normalW : TEXCOORD3,
float3 toEyeW : TEXCOORD4) : COLOR
{
// Normalize, because interpolated normals can warp
toEyeT    = normalize(toEyeT);
lightDirT = normalize(lightDirT);
normalW = normalize(normalW);
toEyeW  = normalize(toEyeW);

// Light vector is opposite the direction of the light.
float3 lightVecT = -lightDirT;
// Sample normal map.
float3 normalT = tex2D(NormalMapS, tex0);
// Expand from [0, 1] compressed interval to true [-1, 1] interval.
    normalT = (2.0f*normalT - 1.0f) * gNormalPower;
// Make it a unit vector.
normalT = normalize(normalT);

//Compute the normal reflection vector
float rN = reflect(-lightVecT, normalT);
// Determine the diffuse light intensity that strikes the vertex.
float tN  = pow(max(dot(rN, toEyeT), 0.0f), gMtrl.specPower);
float sN = max(dot(lightVecT, normalT), 0.0f);

// If the diffuse light intensity is low, kill the specular lighting term.
// It doesn't look right to add specular light when the surface receives
// little diffuse light.
if(sN <= 0.0f)
     tN = 0.0f;

// Sample the environment map and get the reflected color + add the normal component to it
float3 envMapTex = reflect(-toEyeW, normalW) + (normalT*gNormalPower);
float3 reflectedColor = texCUBE(EnvMapS, envMapTex);

// Light vector is opposite the direction of the light.
float3 lightVecW = -gLight.dirW;
// Compute the reflection vector.
float3 r = reflect(-lightVecW, normalW);
// Determine how much (if any) specular light makes it into the eye.
float t = pow(max(dot(r, toEyeW), 0.0f), gMtrl.specPower);
float s = max(dot(lightVecW, normalW), 0.0f);


// Get the texture color, and multiply it by how blended it should be.
float4 texColor = tex2D(TexS, tex0) * gTexBlend;

// Weighted average between the reflected color, and usual
// diffuse/ambient material color modulated with the texture color.
float3 ambientMtrl = gReflectivity*reflectedColor + (1.0f-gReflectivity)*(gMtrl.ambient*texColor);
float3 diffuseMtrl = gReflectivity*reflectedColor + (1.0f-gReflectivity)*(gMtrl.diffuse*texColor);

// Compute the ambient, diffuse and specular terms separately.
float3 spec = tN*(gMtrl.spec*gLight.spec).rgb;
float3 diffuse = sN*(diffuseMtrl*gLight.diffuse.rgb);
float3 ambient = ambientMtrl*gLight.ambient;

// Compute the final color: ambient + diffuse + specular:
float3 final = (ambient + diffuse)*texColor.rgb + spec;

// Output the color and the alpha.
    return float4(final, gMtrl.diffuse.a*texColor.a);
}

technique PhongEnvNMTech
{
    pass P0
    {
        // Specify the vertex and pixel shader associated with this pass.
        vertexShader = compile vs_2_0 PhongEnvNMVS();
        pixelShader  = compile ps_2_0 PhongEnvNMPS();
    }
}

I really wish MS didn't own Banjo.
Rayman would also be really awesome.
Working within Nintendo, I'd vote for Paper Mario.  Out of all Mario clones (fucking Dr. Mario...really?), Paper Mario would at least have some uniqueness, considering he had like 5000 paper-themed abilities in the game, and quite a few iconic moves.

Apartment stuff
Figuring out how normal mapping works in DirectX
Vidya

Yup.  That's a crack lighter.

Yeah, maybe in dingo time.

Quote from: Cocos on March 31, 2015, 05:23:11 PM

Who dictates that?

Me. Feel free to disagree with me, I don't care. But that's my personal interpretation.

Those set of rules seem a little...picky, for lack of a better word. 

You're entitled to your own opinion, just like I am with mine, and it's not as if my end-goal is to sell the concepts of mods to you.  I really don't care if you hate mods, PC gaming, drinking, etc... but would rather you not voice those opinions so aggressively/offensively/stubbornly.

Anywho: sometimes creation kits and whatnot are separate because the devs want to give players the creative medium of something like Forge, but want to give them tools that run off a separate architecture what the actual game itself runs in.  Good examples of this are Halo 2 Vista's map editor (it's pretty much a beefed up Forge mode that ran in a separate .exe, but was included in the install) and Starcraft II's editor.

Also consider the tool-creation aspect of making a game.  A massive chunk of development goes into slaving over a custom game engine, and as someone who's slaved over game engines, I'd personally be extremely happy to see that my work didn't serve one purpose and then fade into oblivion, and that someone picked my engine to make a custom MLP-themed space-adventure, or some shit, rather than just using Unity or GameMaker.

Quote

Also, I guess I'm supposed to say a game is trash, since the launcher that allows me to adjust the resolution of the game to something I can see is its own .exe, hence "not inside the game itself".

I would say the resolution of the game is inside the game itself, yeah. You can fucking see it, with your eyeballs, on the screen.

Yes, but the component that allows me to adjust what I can "fucking see, with my eyeballs, on the screen" is sometimes in an .exe separate from the game itself, and sometimes it's not even that, but is a text file that I have to edit manually.  That would make it an edit to a game done from outside, or *pulls sunglasses* a mod.

Okay.

I don't care what you'd say. I obviously disagree.

But why not let the developers decide whether or not they consider it "pissing on their art"?  Why are you insulted on their behalf?  If they're giving out the tools to the public, I doubt they see it that way.

It's also pretty snobbish, and just plain wrong, to believe that your own creation is infallible, and to believe that no one is better at your job than you.

Quote from: Cocos on March 31, 2015, 05:13:00 PM

So would you say people piss all over Halo whenever they use Forge mode, in order to make maps that are better than the vanilla ones?

No, because Forge is an actual part of the game.

It's arguable that the Creation Kits that developers like Bethesda release to the public are just as much an "actual part of the game", regardless of the fact that it's a separate program.

Also, please respond to the rest of my post.

I don't play an obscene amount of RTS games, but my favorites were Starcraft II and Age of Empires II.