# allgemeine exe frage



## Fragender (14. Apr 2009)

hay
ich weiß die frage gehört hier eigentlich nicht in dieses forum aber ich hoffe es antwortet trotzdem jemand 
und zwar alle Spiele für windows sind immer in einer .exe datei. in welcher programmiersprache sind solche spiele (z.B. World of warcraft oder andere) programmiert?
vielleicht kann ja jemand helfen


----------



## SlaterB (14. Apr 2009)

programmiersprache solche spiele z.B. World of warcraft - Google-Suche
->
Programmiersprachen von folgenden Spielen


----------



## Fragender (14. Apr 2009)

danke
aber warum benutzt man nicht java?


----------



## faetzminator (14. Apr 2009)

Du hast nicht alle Antworten des Forums (vom Link) gelesen, was?


----------



## Fragender (14. Apr 2009)

ja sorry ok jetzt weiß ichs


----------



## icarus2 (15. Apr 2009)

Ömm, aber ich glaube nicht, dass ein Spiel wie Crysis nur auf C++ basiert. Da ist doch bestimmt Assembler drinne und so Zeug, oder lieg ich da falsch?

(In der Plauderecke wurde mir das auf jeden Fall gesagt) ^^


----------



## maki (15. Apr 2009)

Da dieses Thema nichts konkretes mit Java sondern eher mit SW Entwicklung im Allgemeinen zu tun hat habe ich es verschoben.


----------



## Empire Phoenix (15. Apr 2009)

Genau genommen besteht Farcry aus C++ , Lua, und ShaderSprachen.

Ein Beispiel für eine ShaderSprache? (entnommen aus der jMonkeyEngine)


parallax.frag

```
uniform sampler2D baseMap;
uniform sampler2D normalMap;
uniform sampler2D specularMap;

varying vec3 viewDirection;
varying vec3 lightDirection;

uniform float heightValue;

void main(void)
{
	/* Normalize view and light directions(need per-pixel normalized length) */
	vec3 normalizedViewDirection = normalize( viewDirection );
	vec3 normalizedLightDirection = normalize( lightDirection );

	/* Extract colors from baseMap and specularMap */
//	vec4  baseColor      = texture2D( baseMap, gl_TexCoord[0].xy );
	vec4  specularColor  = texture2D( specularMap, gl_TexCoord[0].xy );

	float height = length(specularColor.xyz) * heightValue - heightValue * 0.5;
	vec2 newTexcoord = gl_TexCoord[0].xy - normalizedViewDirection.xy * height;
	vec4 baseColor = texture2D( baseMap, newTexcoord );

	
	/* Calculate diffuse - Extract and expand normal and calculate dot angle to lightdirection */
	vec3  normal = normalize( ( texture2D( normalMap, gl_TexCoord[0].xy ).xyz * 2.0 ) - 1.0 );
	float NDotL = dot( normal, normalizedLightDirection ); 
	   
	/* Calculate specular - Calculate reflection vector and dot angle to viewdirection  */
	vec3  reflection = normalize( ( ( 2.0 * normal ) * NDotL ) - normalizedLightDirection ); 
	float RDotV = max( 0.0, dot( reflection, normalizedViewDirection ) );
	   	   
	/* Sum up lighting models with OpenGL provided light/material properties */
	vec4  totalAmbient   = ( gl_FrontLightModelProduct.sceneColor + gl_FrontLightProduct[0].ambient ) * baseColor; 
	vec4  totalDiffuse   = gl_FrontLightProduct[0].diffuse * max( 0.0, NDotL ) * baseColor; 
	vec4  totalSpecular  = gl_FrontLightProduct[0].specular * specularColor * ( pow( RDotV, gl_FrontMaterial.shininess ) );	

	/* Sum up lighting models with hardcoded lighting properties(for debugging) */
//	vec4  totalAmbient   = vec4(0.2, 0.2, 0.2, 1.0) * baseColor; 
//	vec4  totalDiffuse   = vec4(1.0, 1.0, 1.0, 1.0) * max( 0.0, NDotL ) * baseColor; 
//	vec4  totalSpecular  = vec4(1.0, 1.0, 1.0, 1.0) * specularColor * ( pow( RDotV, 25.0 ) );	

	/* Set final pixel color as sum of lighting models */
    gl_FragColor = totalAmbient + totalDiffuse + totalSpecular;
}
```

parallax.vert

```
//attribute vec3 modelTangent;
//attribute vec3 modelBinormal;

varying vec3 viewDirection;
varying vec3 lightDirection;

void main(void)
{
	/* Transform vertices and pass on texture coordinates */
	gl_Position = ftransform();
	gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0 * vec4(4.0, 4.0, 1.0, 1.0);
	
	/* Transform vertex into viewspace */
	vec4 vertexViewSpace = gl_ModelViewMatrix * gl_Vertex;
	
	/* Get view and light directions in viewspace */
	vec3 localViewDirection = -vertexViewSpace.xyz;
	vec3 localLightDirection = gl_LightSource[0].position.xyz;
	
	/* Calculate tangent info - stored in colorbuffer */
	vec3 normal = gl_NormalMatrix * gl_Normal;
	vec3 tangent = gl_NormalMatrix * (gl_Color.xyz*2.0-1.0);
	vec3 binormal = cross( tangent, normal );

	/* Calculate tangent info - stored in attributes */
//	vec3 normal = gl_NormalMatrix * gl_Normal;
//	vec3 tangent = gl_NormalMatrix * modelTangent;
//	vec3 binormal = cross( normal, tangent );
//	vec3 binormal = gl_NormalMatrix * modelBinormal;

	/* Calculate tangent info - stored in texturecoordinates */
//	vec3 normal = gl_NormalMatrix * gl_Normal;
//	vec3 tangent = gl_NormalMatrix * gl_MultiTexCoord1.xyz;
//	vec3 binormal = gl_NormalMatrix * gl_MultiTexCoord2.xyz;
	
	/* Transform localViewDirection into texture space */
	viewDirection.x = dot( tangent, localViewDirection );
	viewDirection.y = dot( binormal, localViewDirection );
	viewDirection.z = dot( normal, localViewDirection );

	/* Transform localLightDirection into texture space */
	lightDirection.x = dot( tangent, localLightDirection );
	lightDirection.y = dot( binormal, localLightDirection );
	lightDirection.z = dot( normal, localLightDirection );
}
```


----------



## icarus2 (15. Apr 2009)

Ja, ich glaub Assembler ist ja ne Shader sprache, falls ich mich da net irre


----------



## Geeeee (15. Apr 2009)

Nein, ShaderSprachen sind sowas wie "Grafikkarten-Programmiersprachen" und werden z.B. wie OpenGL Shader Language (GLSL) durch den Treiber / Bibliothek auf der Grafikkarte ausgeführt.
Im Gegensatz zu Assembler ist das quasi eine -immer mehr wachsende- Hochsprache. Man kann z.B. ja auch schon grafikunabhängige Berechnungen per ShaderLanguage auf die GPU auslagern.


----------



## newcron (17. Apr 2009)

In der Regel ist es so, dass die Grafik und Engine des Spiels in C++ (mit Assembler) entwickelt wird, viele Effekte (Bloom, Cellshading,...) werden per Cellshadern (Programme in Shadersprachen wie GLSL, die auf der Grafikkarte laufen und die CPU damit nicht mehr belasten) auf der Grafikkarte hinzugefügt. Die tatsächliche Handlung des Spiels, also die Story, die Interaktion mit weiteren Charakteren (wenn du z.B. bei irgend einem Händler etwas kaufst) werden in Scriptsprachen - häufig LUA - geschrieben. 
Die Trennung hat den Vorteil, dass Änderungen an der Handlung des Spiels (die Preise im Laden etwas erhöhen, den Schmied mit dem Händler platz tauschen lassen, oder einen Haufen Gegner angreifen zu lassen) unabhängig von der tatsächlichen Engine entwicklung funktioniert und alle Änderungen an dieser möglich sind, ohne etwas neu kompilieren zu müssen - was bei solch großen Anwendungen einige Stunden dauern kann. Alles was notwendig ist, ist das entsprechende Lua Script zu bearbeiten und das Spiel neu zu starten.

Spiele macht man nicht in Java, weil du mit C++ hardwarenaher programmieren kannst und das Programm komplett vorkompiliert wird, während Java nur zu Bytecode kompiliert wird, weshalb Java auch als Langsamer als C gilt. (Darüber kann man streiten, und wenn man sich mit der JVM auskennt, kann man viele Teile von Programmen fast gleich schnell machen, aber das würde jetzt zu weit ins Detail gehen...)


----------

