add camera movement

GrafikaProjekt/pliki/projekt.vcxproj

@@ -11,49 +11,41 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\Camera.h" />
-    <ClInclude Include="src\mesh.h" />
-    <ClInclude Include="src\model.h" />
-    <ClInclude Include="src\objload.h" />
-    <ClInclude Include="src\Physics.h" />
-    <ClInclude Include="src\picopng.h" />
-    <ClInclude Include="src\Render_Utils.h" />
-    <ClInclude Include="src\Shader_Loader.h" />
-    <ClInclude Include="src\stb_image.h" />
-    <ClInclude Include="src\Texture.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="src\Box.cpp" />
     <ClCompile Include="src\Camera.cpp" />
     <ClCompile Include="src\main.cpp" />
-    <ClCompile Include="src\Physics.cpp" />
-    <ClCompile Include="src\picopng.cpp" />
     <ClCompile Include="src\Render_Utils.cpp" />
     <ClCompile Include="src\Shader_Loader.cpp" />
+    <ClCompile Include="src\SOIL\image_DXT.c" />
+    <ClCompile Include="src\SOIL\image_helper.c" />
+    <ClCompile Include="src\SOIL\SOIL.c" />
+    <ClCompile Include="src\SOIL\stb_image_aug.c" />
     <ClCompile Include="src\Texture.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="shaders\shader_4_1.frag" />
+    <ClInclude Include="src\Camera.h" />
-    <None Include="shaders\shader_4_1.vert" />
+    <ClInclude Include="src\objload.h" />
-    <None Include="shaders\shader_4_sun.frag" />
+    <ClInclude Include="src\Render_Utils.h" />
-    <None Include="shaders\shader_4_sun.vert" />
+    <ClInclude Include="src\Shader_Loader.h" />
+    <ClInclude Include="src\SOIL\image_DXT.h" />
+    <ClInclude Include="src\SOIL\image_helper.h" />
+    <ClInclude Include="src\SOIL\SOIL.h" />
+    <ClInclude Include="src\SOIL\stbi_DDS_aug.h" />
+    <ClInclude Include="src\SOIL\stbi_DDS_aug_c.h" />
+    <ClInclude Include="src\SOIL\stb_image_aug.h" />
+    <ClInclude Include="src\Texture.h" />
+  </ItemGroup>
+  <ItemGroup>
     <None Include="shaders\shader_color.frag" />
     <None Include="shaders\shader_color.vert" />
-    <None Include="shaders\shader_red.frag" />
-    <None Include="shaders\shader_red.vert" />
-    <None Include="shaders\shader_spec_tex.frag" />
-    <None Include="shaders\shader_spec_tex.vert" />
     <None Include="shaders\shader_tex.frag" />
     <None Include="shaders\shader_tex.vert" />
-    <None Include="shaders\shader_tex_2.frag" />
-    <None Include="shaders\shader_tex_2.vert" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
-    <ProjectGuid>{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}</ProjectGuid>
+    <ProjectGuid>{10701B86-9B0B-46A1-85DA-6238CBCC507B}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
-    <RootNamespace>scenaPodwodna</RootNamespace>
+    <RootNamespace>grk-cw6</RootNamespace>
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-    <ProjectName>scena_podwodna</ProjectName>
+    <ProjectName>grk-cw6</ProjectName>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

GrafikaProjekt/pliki/projekt.vcxproj.filters

@@ -14,67 +14,76 @@
       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
     </Filter>
     <Filter Include="Shader Files">
-      <UniqueIdentifier>{e9364a22-c274-41c1-9f8e-146ccf27d19a}</UniqueIdentifier>
+      <UniqueIdentifier>{0a247bb8-2e8e-4a90-b0ef-17415b0941ba}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\SOIL">
+      <UniqueIdentifier>{1e762b0e-a07f-4d7a-aedf-9503776529c7}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\Camera.h">
+    <ClCompile Include="src\Render_Utils.cpp">
       <Filter>Source Files</Filter>
-    </ClInclude>
+    </ClCompile>
-    <ClInclude Include="src\mesh.h">
+    <ClCompile Include="src\Shader_Loader.cpp">
       <Filter>Source Files</Filter>
-    </ClInclude>
+    </ClCompile>
-    <ClInclude Include="src\model.h">
+    <ClCompile Include="src\Camera.cpp">
       <Filter>Source Files</Filter>
-    </ClInclude>
+    </ClCompile>
+    <ClCompile Include="src\SOIL\image_helper.c">
+      <Filter>Source Files\SOIL</Filter>
+    </ClCompile>
+    <ClCompile Include="src\SOIL\SOIL.c">
+      <Filter>Source Files\SOIL</Filter>
+    </ClCompile>
+    <ClCompile Include="src\SOIL\stb_image_aug.c">
+      <Filter>Source Files\SOIL</Filter>
+    </ClCompile>
+    <ClCompile Include="src\SOIL\image_DXT.c">
+      <Filter>Source Files\SOIL</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Texture.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
     <ClInclude Include="src\objload.h">
       <Filter>Source Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\Physics.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\picopng.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
     <ClInclude Include="src\Render_Utils.h">
       <Filter>Source Files</Filter>
     </ClInclude>
     <ClInclude Include="src\Shader_Loader.h">
       <Filter>Source Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\stb_image.h">
+    <ClInclude Include="src\Camera.h">
       <Filter>Source Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\SOIL\image_DXT.h">
+      <Filter>Source Files\SOIL</Filter>
+    </ClInclude>
+    <ClInclude Include="src\SOIL\image_helper.h">
+      <Filter>Source Files\SOIL</Filter>
+    </ClInclude>
+    <ClInclude Include="src\SOIL\SOIL.h">
+      <Filter>Source Files\SOIL</Filter>
+    </ClInclude>
+    <ClInclude Include="src\SOIL\stb_image_aug.h">
+      <Filter>Source Files\SOIL</Filter>
+    </ClInclude>
+    <ClInclude Include="src\SOIL\stbi_DDS_aug.h">
+      <Filter>Source Files\SOIL</Filter>
+    </ClInclude>
+    <ClInclude Include="src\SOIL\stbi_DDS_aug_c.h">
+      <Filter>Source Files\SOIL</Filter>
+    </ClInclude>
     <ClInclude Include="src\Texture.h">
       <Filter>Source Files</Filter>
     </ClInclude>
   </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="src\main.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Physics.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\picopng.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Render_Utils.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Shader_Loader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Texture.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Box.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Camera.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
   <ItemGroup>
     <None Include="shaders\shader_color.frag">
       <Filter>Shader Files</Filter>
@@ -82,41 +91,11 @@
     <None Include="shaders\shader_color.vert">
       <Filter>Shader Files</Filter>
     </None>
-    <None Include="shaders\shader_red.frag">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_red.vert">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_spec_tex.frag">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_spec_tex.vert">
-      <Filter>Shader Files</Filter>
-    </None>
     <None Include="shaders\shader_tex.frag">
       <Filter>Shader Files</Filter>
     </None>
     <None Include="shaders\shader_tex.vert">
       <Filter>Shader Files</Filter>
     </None>
-    <None Include="shaders\shader_tex_2.frag">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_tex_2.vert">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_4_1.frag">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_4_1.vert">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_4_sun.frag">
-      <Filter>Shader Files</Filter>
-    </None>
-    <None Include="shaders\shader_4_sun.vert">
-      <Filter>Shader Files</Filter>
-    </None>
   </ItemGroup>
 </Project>

GrafikaProjekt/pliki/render.py

@@ -1,7 +0,0 @@
-
-import os
-rootdir = './'
-for filename in os.listdir(rootdir):
-    if filename.endswith(".md"):
-        name = filename[:-3]
-        os.system(f'pandoc -s -o {name}.html {name}.md --css style.css')   

GrafikaProjekt/pliki/shaders/shader_4_1.frag

@@ -1,21 +0,0 @@
-#version 410 core
-
-uniform vec3 objectColor;
-//uniform vec3 lightDir;
-uniform vec3 lightPos;
-uniform vec3 cameraPos;
-
-in vec3 interpNormal;
-in vec3 fragPos;
-
-void main()
-{
-	vec3 lightDir = normalize(lightPos-fragPos);
-	vec3 V = normalize(cameraPos-fragPos);
-	vec3 normal = normalize(interpNormal);
-	vec3 R = reflect(-normalize(lightDir),normal);
-	
-	float specular = pow(max(0,dot(R,V)),10);
-	float diffuse = max(0,dot(normal,normalize(lightDir)));
-	gl_FragColor = vec4(mix(objectColor,objectColor*diffuse+vec3(1)*specular,0.9), 1.0);
-}

GrafikaProjekt/pliki/shaders/shader_4_1.vert

@@ -1,17 +0,0 @@
-#version 410 core
-
-layout(location = 0) in vec3 vertexPosition;
-layout(location = 1) in vec2 vertexTexCoord;
-layout(location = 2) in vec3 vertexNormal;
-
-uniform mat4 transformation;
-uniform mat4 modelMatrix;
-out vec3 interpNormal;
-out vec3 fragPos;
-
-void main()
-{
-	gl_Position = transformation * vec4(vertexPosition, 1.0);
-	interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
-	fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
-}

GrafikaProjekt/pliki/shaders/shader_4_sun.frag

@@ -1,17 +0,0 @@
-#version 410 core
-
-uniform vec3 objectColor;
-//uniform vec3 lightDir;
-uniform vec3 lightPos;
-uniform vec3 cameraPos;
-
-in vec3 interpNormal;
-in vec3 fragPos;
-
-void main()
-{
-	vec3 normal = normalize(interpNormal);
-	vec3 V = normalize(cameraPos-fragPos);
-	float coef = max(0,dot(V,normal));
-	gl_FragColor = vec4(mix(objectColor,vec3(1,0.5,0.1),1-coef), 1.0);
-}

GrafikaProjekt/pliki/shaders/shader_4_sun.vert

@@ -1,17 +0,0 @@
-#version 410 core
-
-layout(location = 0) in vec3 vertexPosition;
-layout(location = 1) in vec2 vertexTexCoord;
-layout(location = 2) in vec3 vertexNormal;
-
-uniform mat4 transformation;
-uniform mat4 modelMatrix;
-out vec3 interpNormal;
-out vec3 fragPos;
-
-void main()
-{
-	gl_Position = transformation * vec4(vertexPosition, 1.0);
-	interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
-	fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
-}

GrafikaProjekt/pliki/shaders/shader_color.frag

@@ -8,7 +8,6 @@ in vec3 interpNormal;
 void main()
 {
 	vec3 normal = normalize(interpNormal);
-	float ambient = 0.2;
 	float diffuse = max(dot(normal, -lightDir), 0.0);
-	gl_FragColor = vec4(objectColor * (ambient + (1-ambient) * diffuse), 1.0);
+	gl_FragColor = vec4(objectColor * diffuse, 1.0);
 }

GrafikaProjekt/pliki/shaders/shader_color.vert

@@ -1,8 +1,8 @@
 #version 410 core
 
 layout(location = 0) in vec3 vertexPosition;
-layout(location = 1) in vec2 vertexTexCoord;
+layout(location = 1) in vec3 vertexNormal;
-layout(location = 2) in vec3 vertexNormal;
+layout(location = 2) in vec2 vertexTexCoord;
 
 uniform mat4 modelViewProjectionMatrix;
 uniform mat4 modelMatrix;

GrafikaProjekt/pliki/shaders/shader_red.frag

@@ -1,6 +0,0 @@
-#version 410 core
-
-void main()
-{
-	gl_FragColor = vec4(1.0,0.0,0.0, 1.0);
-}

GrafikaProjekt/pliki/shaders/shader_red.vert

@@ -1,10 +0,0 @@
-#version 410 core
-
-layout(location = 0) in vec3 vertexPosition;
-uniform mat4 modelViewProjectionMatrix;
-
-
-void main()
-{
-	gl_Position = modelViewProjectionMatrix * vec4(vertexPosition, 1.0);
-}

GrafikaProjekt/pliki/shaders/shader_spec_tex.frag

@@ -1,29 +0,0 @@
-#version 410 core
-
-//uniform vec3 objectColor;
-uniform vec3 lightDir;
-//uniform vec3 lightPos;
-uniform vec3 cameraPos;
-uniform sampler2D color_texture;
-uniform sampler2D specular_texture;
-
-
-in vec3 interpNormal;
-in vec3 fragPos;
-in vec2 uvCoord;
-
-void main()
-{
-	//float falloff = pow(length(cameraPos-fragPos),2)*0.01;
-	vec3 color = texture(color_texture,uvCoord).rgb;
-	vec3 spec = texture(specular_texture,uvCoord).rgb;
-	//vec3 lightDir = normalize(lightPos-fragPos);
-	vec3 V = normalize(cameraPos-fragPos);
-	vec3 normal = normalize(interpNormal);
-	vec3 R = reflect(-normalize(lightDir),normal);
-	
-	float specular = pow(max(0,dot(R,V)),10);
-	float diffuse = max(0,dot(normal,normalize(lightDir)));
-	gl_FragColor = vec4(mix(color,color*diffuse+spec*specular,0.7), 1.0);
-	//gl_FragColor = vec4(mix(vec3(0.1,0.1,0.1),mix(color,color*diffuse+spec*specular,0.7),min(1,1/falloff)), 1.0);
-}

GrafikaProjekt/pliki/shaders/shader_spec_tex.vert

@@ -1,19 +0,0 @@
-#version 410 core
-
-layout(location = 0) in vec3 vertexPosition;
-layout(location = 1) in vec3 vertexNormal;
-layout(location = 2) in vec2 vertexTexCoord;
-
-uniform mat4 transformation;
-uniform mat4 modelMatrix;
-out vec3 interpNormal;
-out vec3 fragPos;
-out vec2 uvCoord;
-
-void main()
-{
-	uvCoord = vertexTexCoord;
-	gl_Position = transformation * vec4(vertexPosition, 1.0);
-	interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
-	fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
-}

GrafikaProjekt/pliki/shaders/shader_tex.frag

@@ -11,7 +11,6 @@ void main()
 	vec2 modifiedTexCoord = vec2(interpTexCoord.x, 1.0 - interpTexCoord.y); // Poprawka dla tekstur Ziemi, ktore bez tego wyswietlaja sie 'do gory nogami'
 	vec3 color = texture2D(textureSampler, modifiedTexCoord).rgb;
 	vec3 normal = normalize(interpNormal);
-	float ambient = 0.2;
 	float diffuse = max(dot(normal, -lightDir), 0.0);
-	gl_FragColor = vec4(color * (ambient + (1-ambient) * diffuse), 1.0);
+	gl_FragColor = vec4(color * diffuse, 1.0);
 }

GrafikaProjekt/pliki/shaders/shader_tex.vert

@@ -1,9 +1,9 @@
 #version 410 core
 
 layout(location = 0) in vec3 vertexPosition;
-layout(location = 1) in vec2 vertexTexCoord;
+layout(location = 1) in vec3 vertexNormal;
-layout(location = 2) in vec3 vertexNormal;
 
+layout(location = 2) in vec2 vertexTexCoord;
 uniform mat4 modelViewProjectionMatrix;
 uniform mat4 modelMatrix;
 

GrafikaProjekt/pliki/shaders/shader_tex_2.frag

@@ -1,28 +0,0 @@
-#version 410 core
-
-//uniform vec3 objectColor;
-uniform vec3 lightDir;
-//uniform vec3 lightPos;
-uniform vec3 cameraPos;
-uniform sampler2D color_texture;
-
-
-in vec3 interpNormal;
-in vec3 fragPos;
-in vec2 uvCoord;
-
-void main()
-{
-	//float falloff = pow(length(cameraPos-fragPos),2)*0.01;
-	vec3 color = texture(color_texture,uvCoord).rgb;
-	vec3 spec = vec3(0.7);
-	//vec3 lightDir = normalize(lightPos-fragPos);
-	vec3 V = normalize(cameraPos-fragPos);
-	vec3 normal = normalize(interpNormal);
-	vec3 R = reflect(-normalize(lightDir),normal);
-	
-	float specular = pow(max(0,dot(R,V)),10);
-	float diffuse = max(0,dot(normal,normalize(lightDir)));
-	gl_FragColor = vec4(mix(color,color*diffuse+spec*specular,0.7), 1.0);
-	//gl_FragColor = vec4(mix(vec3(0.1,0.1,0.1),mix(color,color*diffuse+spec*specular,0.7),min(1,1/falloff)), 1.0);
-}

GrafikaProjekt/pliki/shaders/shader_tex_2.vert

@@ -1,19 +0,0 @@
-#version 410 core
-
-layout(location = 0) in vec3 vertexPosition;
-layout(location = 1) in vec3 vertexNormal;
-layout(location = 2) in vec2 vertexTexCoord;
-
-uniform mat4 transformation;
-uniform mat4 modelMatrix;
-out vec3 interpNormal;
-out vec3 fragPos;
-out vec2 uvCoord;
-
-void main()
-{
-	uvCoord = vertexTexCoord;
-	gl_Position = transformation * vec4(vertexPosition, 1.0);
-	interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
-	fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
-}

GrafikaProjekt/pliki/src/Box.cpp

@@ -1,104 +0,0 @@
-
-
-// dane 36 wierzcholkow i kolorow opisujace model pudelka
-const float boxPositions[] = {
-	0.25f, 0.25f, 0.75f, 1.0f,
-	0.25f, -0.25f, 0.75f, 1.0f,
-	-0.25f, 0.25f, 0.75f, 1.0f,
-
-	0.25f, -0.25f, 0.75f, 1.0f,
-	-0.25f, -0.25f, 0.75f, 1.0f,
-	-0.25f, 0.25f, 0.75f, 1.0f,
-
-	0.25f, 0.25f, -0.75f, 1.0f,
-	-0.25f, 0.25f, -0.75f, 1.0f,
-	0.25f, -0.25f, -0.75f, 1.0f,
-
-	0.25f, -0.25f, -0.75f, 1.0f,
-	-0.25f, 0.25f, -0.75f, 1.0f,
-	-0.25f, -0.25f, -0.75f, 1.0f,
-
-	-0.25f, 0.25f, 0.75f, 1.0f,
-	-0.25f, -0.25f, 0.75f, 1.0f,
-	-0.25f, -0.25f, -0.75f, 1.0f,
-
-	-0.25f, 0.25f, 0.75f, 1.0f,
-	-0.25f, -0.25f, -0.75f, 1.0f,
-	-0.25f, 0.25f, -0.75f, 1.0f,
-
-	0.25f, 0.25f, 0.75f, 1.0f,
-	0.25f, -0.25f, -0.75f, 1.0f,
-	0.25f, -0.25f, 0.75f, 1.0f,
-
-	0.25f, 0.25f, 0.75f, 1.0f,
-	0.25f, 0.25f, -0.75f, 1.0f,
-	0.25f, -0.25f, -0.75f, 1.0f,
-
-	0.25f, 0.25f, -0.75f, 1.0f,
-	0.25f, 0.25f, 0.75f, 1.0f,
-	-0.25f, 0.25f, 0.75f, 1.0f,
-
-	0.25f, 0.25f, -0.75f, 1.0f,
-	-0.25f, 0.25f, 0.75f, 1.0f,
-	-0.25f, 0.25f, -0.75f, 1.0f,
-
-	0.25f, -0.25f, -0.75f, 1.0f,
-	-0.25f, -0.25f, 0.75f, 1.0f,
-	0.25f, -0.25f, 0.75f, 1.0f,
-
-	0.25f, -0.25f, -0.75f, 1.0f,
-	-0.25f, -0.25f, -0.75f, 1.0f,
-	-0.25f, -0.25f, 0.75f, 1.0f,
-};
-
-
-const float boxColors[] = {
-	0.0f, 0.0f, 1.0f, 1.0f,
-	0.0f, 0.0f, 1.0f, 1.0f,
-	0.0f, 0.0f, 1.0f, 1.0f,
-
-	0.0f, 0.0f, 1.0f, 1.0f,
-	0.0f, 0.0f, 1.0f, 1.0f,
-	0.0f, 0.0f, 1.0f, 1.0f,
-
-	0.8f, 0.8f, 0.8f, 1.0f,
-	0.8f, 0.8f, 0.8f, 1.0f,
-	0.8f, 0.8f, 0.8f, 1.0f,
-
-	0.8f, 0.8f, 0.8f, 1.0f,
-	0.8f, 0.8f, 0.8f, 1.0f,
-	0.8f, 0.8f, 0.8f, 1.0f,
-
-	0.0f, 1.0f, 0.0f, 1.0f,
-	0.0f, 1.0f, 0.0f, 1.0f,
-	0.0f, 1.0f, 0.0f, 1.0f,
-
-	0.0f, 1.0f, 0.0f, 1.0f,
-	0.0f, 1.0f, 0.0f, 1.0f,
-	0.0f, 1.0f, 0.0f, 1.0f,
-
-	0.5f, 0.5f, 0.0f, 1.0f,
-	0.5f, 0.5f, 0.0f, 1.0f,
-	0.5f, 0.5f, 0.0f, 1.0f,
-
-	0.5f, 0.5f, 0.0f, 1.0f,
-	0.5f, 0.5f, 0.0f, 1.0f,
-	0.5f, 0.5f, 0.0f, 1.0f,
-
-	1.0f, 0.0f, 0.0f, 1.0f,
-	1.0f, 0.0f, 0.0f, 1.0f,
-	1.0f, 0.0f, 0.0f, 1.0f,
-
-	1.0f, 0.0f, 0.0f, 1.0f,
-	1.0f, 0.0f, 0.0f, 1.0f,
-	1.0f, 0.0f, 0.0f, 1.0f,
-
-	0.0f, 1.0f, 1.0f, 1.0f,
-	0.0f, 1.0f, 1.0f, 1.0f,
-	0.0f, 1.0f, 1.0f, 1.0f,
-
-	0.0f, 1.0f, 1.0f, 1.0f,
-	0.0f, 1.0f, 1.0f, 1.0f,
-	0.0f, 1.0f, 1.0f, 1.0f,
-
-};

GrafikaProjekt/pliki/src/Camera.cpp

@@ -30,3 +30,11 @@ glm::mat4 Core::createViewMatrix( glm::vec3 position, glm::vec3 forward, glm::ve
 
 	return cameraRotation * cameraTranslation;
 }
+
+glm::mat4 Core::createViewMatrixQuat(glm::vec3 position, glm::quat rotation)
+{
+	glm::mat4 cameraTranslation;
+	cameraTranslation[3] = glm::vec4(-position, 1.0f);
+
+	return glm::mat4_cast(rotation) * cameraTranslation;
+}

GrafikaProjekt/pliki/src/Camera.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "glm.hpp"
+#include "ext.hpp"
 
 namespace Core
 {
@@ -11,4 +12,6 @@ namespace Core
 	// up - wektor "w gore" kamery (jednostkowy)
 	// up i forward musza byc ortogonalne!
 	glm::mat4 createViewMatrix(glm::vec3 position, glm::vec3 forward, glm::vec3 up);
+
+	glm::mat4 createViewMatrixQuat(glm::vec3 position, glm::quat rotation);
 }

GrafikaProjekt/pliki/src/Physics.cpp

@@ -1,31 +0,0 @@
-#include "Physics.h"
-
-#define PX_RELEASE(x)	if(x)	{ x->release(); x = NULL; }
-
-Physics::Physics(float gravity)
-{
-    foundation = PxCreateFoundation(PX_PHYSICS_VERSION, allocator, errorCallback);
-
-    physics = PxCreatePhysics(PX_PHYSICS_VERSION, *foundation, PxTolerancesScale(), true);
-
-    PxSceneDesc sceneDesc(physics->getTolerancesScale());
-    sceneDesc.gravity = PxVec3(0.0f, -gravity, 0.0f);
-    dispatcher = PxDefaultCpuDispatcherCreate(2);
-    sceneDesc.cpuDispatcher = dispatcher;
-    sceneDesc.filterShader = PxDefaultSimulationFilterShader;
-    scene = physics->createScene(sceneDesc);
-}
-
-Physics::~Physics()
-{
-    PX_RELEASE(scene);
-    PX_RELEASE(dispatcher);
-    PX_RELEASE(physics);
-    PX_RELEASE(foundation);
-}
-
-void Physics::step(float dt)
-{
-    scene->simulate(dt);
-    scene->fetchResults(true);
-}

GrafikaProjekt/pliki/src/Physics.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "PxPhysicsAPI.h"
-using namespace physx;
-
-class Physics
-{
-public:
-    Physics(float gravity);
-    virtual ~Physics();
-    PxPhysics*              physics = nullptr;
-    PxScene*				scene = nullptr;
-
-    void step(float dt);
-
-private:
-    PxDefaultAllocator		allocator;
-    PxDefaultErrorCallback	errorCallback;
-    PxFoundation*			foundation = nullptr;
-    PxDefaultCpuDispatcher*	dispatcher = nullptr;
-};

GrafikaProjekt/pliki/src/Render_Utils.cpp

@@ -4,8 +4,9 @@
 
 #include "glew.h"
 #include "freeglut.h"
-
+#include <assimp/Importer.hpp>
-
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
 
 
 void Core::RenderContext::initFromOBJ(obj::Model& model)
@@ -18,21 +19,16 @@ void Core::RenderContext::initFromOBJ(obj::Model& model)
     unsigned int vertexTexBufferSize = sizeof(float) * model.texCoord.size();
 
     size = model.faces["default"].size();
-    unsigned int vertexElementBufferSize = sizeof(unsigned int) * size;
+    unsigned int vertexElementBufferSize = sizeof(unsigned short) * size;
 
 
-    std::vector<unsigned int> indices;
-    for (unsigned short index : model.faces["default"]) {
-        indices.push_back(index);
-    }
-
     glGenVertexArrays(1, &vertexArray);
     glBindVertexArray(vertexArray);
 
 
     glGenBuffers(1, &vertexIndexBuffer);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, vertexElementBufferSize, &indices[0], GL_STATIC_DRAW);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, vertexElementBufferSize, &model.faces["default"][0], GL_STATIC_DRAW);
 
     glGenBuffers(1, &vertexBuffer);
     glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
@@ -54,7 +50,8 @@ void Core::RenderContext::initFromOBJ(obj::Model& model)
     glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)(vertexNormalBufferSize + vertexDataBufferSize));
 }
 
-void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh){
+
+void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh) {
     vertexArray = 0;
     vertexBuffer = 0;
     vertexIndexBuffer = 0;
@@ -64,7 +61,7 @@ void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh){
     //tex coord must be converted to 2d vecs
     for (unsigned int i = 0; i < mesh->mNumVertices; i++)
     {
-        if (mesh->mTextureCoords[0]!=nullptr) {
+        if (mesh->mTextureCoords[0] != nullptr) {
             textureCoord.push_back(mesh->mTextureCoords[0][i].x);
             textureCoord.push_back(mesh->mTextureCoords[0][i].y);
         }
@@ -130,20 +127,6 @@ void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh){
 
 }
 
-void Core::RenderContext::render()
-{
-
-    glBindVertexArray(this->vertexArray);
-    glDrawElements(
-        GL_TRIANGLES,      // mode
-        this->size,    // count
-        GL_UNSIGNED_INT,   // type
-        (void*)0           // element array buffer offset
-    );
-    glBindVertexArray(0);
-}
-
-
 void Core::DrawVertexArray(const float * vertexArray, int numVertices, int elementSize )
 {
 	glVertexAttribPointer(0, elementSize, GL_FLOAT, false, 0, vertexArray);
@@ -172,69 +155,15 @@ void Core::DrawVertexArray( const VertexData & data )
 	glDrawArrays(GL_TRIANGLES, 0, data.NumVertices);
 }
 
-void Core::DiffuseMaterial::init_data() {
+void Core::DrawContext(Core::RenderContext& context)
-    glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
-    Core::SetActiveTexture(texture, "color_texture", program, 0);
-}
-
-void Core::DiffuseSpecularMaterial::init_data() {
-    glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
-    Core::SetActiveTexture(texture, "color_texture", program, 0);
-    Core::SetActiveTexture(textureSpecular, "specular_texture", program, 1);
-}
-
-
-
-void Core::RayContext::render()
 {
 
-    glBindVertexArray(vertexArray);
+	glBindVertexArray(context.vertexArray);
-    glDrawArrays(
+	glDrawElements(
-        GL_LINES,// mode
+		GL_TRIANGLES,      // mode
-        0,     //start
+		context.size,    // count
-        3 * 7 * 2     // count
+		GL_UNSIGNED_INT,   // type
-        );
+		(void*)0           // element array buffer offset
-    glBindVertexArray(0);
+	);
-}
+	glBindVertexArray(0);
-
-
-void Core::initRay(RayContext& rayContext) {
-    rayContext.size = 2;
-    glGenVertexArrays(1, &rayContext.vertexArray);
-    glBindVertexArray(rayContext.vertexArray);
-
-    glGenBuffers(1, &rayContext.vertexBuffer);
-    glBindBuffer(GL_ARRAY_BUFFER, rayContext.vertexBuffer);
-
-    glBufferData(GL_ARRAY_BUFFER, 3 * 7 * 2 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
-
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)(0));
-    glBindVertexArray(0);
-}
-void Core::updateRayPos(RayContext& rayContext,std::vector<glm::vec3> ray) {
-    glBindVertexArray(rayContext.vertexArray);
-    std::vector<glm::vec3> keyPoints;
-    float offset = 4.f;
-    float scale = 0.2f;
-    float rayEnd = 50.f;
-    keyPoints.push_back(ray[0] + ray[1] * offset);
-    keyPoints.push_back(ray[0] + ray[1] * rayEnd);
-
-    keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, 1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, 1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, -1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, -1.f, 0.f));
-
-    keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, 1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
-    keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, 1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
-    keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, -1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
-    keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, -1.f, 0.f));
-    keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
-    glBindBuffer(GL_ARRAY_BUFFER, rayContext.vertexBuffer);
-    glBufferSubData(GL_ARRAY_BUFFER, 0, keyPoints.size()*3 * sizeof(float), &keyPoints[0]);
-    glBindVertexArray(0);
 }

GrafikaProjekt/pliki/src/Render_Utils.h

@@ -1,63 +1,25 @@
 #pragma once
 #include "glm.hpp"
-#include "ext.hpp"
 #include "glew.h"
 #include "objload.h"
 #include <assimp/Importer.hpp>
 #include <assimp/scene.h>
 #include <assimp/postprocess.h>
-#include "Texture.h"
 
 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
 
 namespace Core
 {
-	static inline glm::mat4 mat4_cast(const aiMatrix4x4& m) { return glm::transpose(glm::make_mat4(&m.a1)); }
-
-	struct  Material {
-		GLuint program;
-		virtual void init_data() = 0;
-	};
-
-	struct DiffuseMaterial : Core::Material {
-		GLuint texture;
-		glm::vec3 lightDir;
-		void init_data();
-
-	};
-
-	struct DiffuseSpecularMaterial : Core::Material {
-		GLuint texture;
-		GLuint textureSpecular;
-		glm::vec3 lightDir;
-		void init_data();
-
-	};
-
 	struct RenderContext
     {
-
 		GLuint vertexArray;
 		GLuint vertexBuffer;
 		GLuint vertexIndexBuffer;
-		Material* material;
 		int size = 0;
 
         void initFromOBJ(obj::Model& model);
 
 		void initFromAssimpMesh(aiMesh* mesh);
-
-		void render();
-	};
-	struct RayContext : RenderContext {
-
-		void render();
-	};
-
-	struct Node {
-		std::vector<RenderContext> renderContexts;
-		glm::mat4 matrix;
-		int parent;
 	};
 
 	// vertexArray - jednowymiarowa tablica zawierajaca wartosci opisujace pozycje kolejnych wierzcholkow w jednym ciagu (x1, y1, z1, w1, x2, y2, z2, w2, ...)
@@ -106,12 +68,5 @@ namespace Core
 	*/
 	void DrawVertexArray(const VertexData & data);
 
-
+	void DrawContext(RenderContext& context);
-
-	void initRay(RayContext& rayContext);
-
-	void updateRayPos(RayContext& rayContext, std::vector<glm::vec3> keyPoints);
-
-	//void DrawContext(Core::RayContext& rayContext);
-
 }

GrafikaProjekt/pliki/src/SOIL/SOIL.h

@@ -0,0 +1,433 @@
+/**
+	@mainpage SOIL
+
+	Jonathan Dummer
+	2007-07-26-10.36
+
+	Simple OpenGL Image Library
+
+	A tiny c library for uploading images as
+	textures into OpenGL.  Also saving and
+	loading of images is supported.
+
+	I'm using Sean's Tool Box image loader as a base:
+	http://www.nothings.org/
+
+	I'm upgrading it to load TGA and DDS files, and a direct
+	path for loading DDS files straight into OpenGL textures,
+	when applicable.
+
+	Image Formats:
+	- BMP		load & save
+	- TGA		load & save
+	- DDS		load & save
+	- PNG		load
+	- JPG		load
+
+	OpenGL Texture Features:
+	- resample to power-of-two sizes
+	- MIPmap generation
+	- compressed texture S3TC formats (if supported)
+	- can pre-multiply alpha for you, for better compositing
+	- can flip image about the y-axis (except pre-compressed DDS files)
+
+	Thanks to:
+	* Sean Barret - for the awesome stb_image
+	* Dan Venkitachalam - for finding some non-compliant DDS files, and patching some explicit casts
+	* everybody at gamedev.net
+**/
+
+#ifndef HEADER_SIMPLE_OPENGL_IMAGE_LIBRARY
+#define HEADER_SIMPLE_OPENGL_IMAGE_LIBRARY
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+	The format of images that may be loaded (force_channels).
+	SOIL_LOAD_AUTO leaves the image in whatever format it was found.
+	SOIL_LOAD_L forces the image to load as Luminous (greyscale)
+	SOIL_LOAD_LA forces the image to load as Luminous with Alpha
+	SOIL_LOAD_RGB forces the image to load as Red Green Blue
+	SOIL_LOAD_RGBA forces the image to load as Red Green Blue Alpha
+**/
+enum
+{
+	SOIL_LOAD_AUTO = 0,
+	SOIL_LOAD_L = 1,
+	SOIL_LOAD_LA = 2,
+	SOIL_LOAD_RGB = 3,
+	SOIL_LOAD_RGBA = 4
+};
+
+/**
+	Passed in as reuse_texture_ID, will cause SOIL to
+	register a new texture ID using glGenTextures().
+	If the value passed into reuse_texture_ID > 0 then
+	SOIL will just re-use that texture ID (great for
+	reloading image assets in-game!)
+**/
+enum
+{
+	SOIL_CREATE_NEW_ID = 0
+};
+
+/**
+	flags you can pass into SOIL_load_OGL_texture()
+	and SOIL_create_OGL_texture().
+	(note that if SOIL_FLAG_DDS_LOAD_DIRECT is used
+	the rest of the flags with the exception of
+	SOIL_FLAG_TEXTURE_REPEATS will be ignored while
+	loading already-compressed DDS files.)
+
+	SOIL_FLAG_POWER_OF_TWO: force the image to be POT
+	SOIL_FLAG_MIPMAPS: generate mipmaps for the texture
+	SOIL_FLAG_TEXTURE_REPEATS: otherwise will clamp
+	SOIL_FLAG_MULTIPLY_ALPHA: for using (GL_ONE,GL_ONE_MINUS_SRC_ALPHA) blending
+	SOIL_FLAG_INVERT_Y: flip the image vertically
+	SOIL_FLAG_COMPRESS_TO_DXT: if the card can display them, will convert RGB to DXT1, RGBA to DXT5
+	SOIL_FLAG_DDS_LOAD_DIRECT: will load DDS files directly without _ANY_ additional processing
+	SOIL_FLAG_NTSC_SAFE_RGB: clamps RGB components to the range [16,235]
+	SOIL_FLAG_CoCg_Y: Google YCoCg; RGB=>CoYCg, RGBA=>CoCgAY
+	SOIL_FLAG_TEXTURE_RECTANGE: uses ARB_texture_rectangle ; pixel indexed & no repeat or MIPmaps or cubemaps
+**/
+enum
+{
+	SOIL_FLAG_POWER_OF_TWO = 1,
+	SOIL_FLAG_MIPMAPS = 2,
+	SOIL_FLAG_TEXTURE_REPEATS = 4,
+	SOIL_FLAG_MULTIPLY_ALPHA = 8,
+	SOIL_FLAG_INVERT_Y = 16,
+	SOIL_FLAG_COMPRESS_TO_DXT = 32,
+	SOIL_FLAG_DDS_LOAD_DIRECT = 64,
+	SOIL_FLAG_NTSC_SAFE_RGB = 128,
+	SOIL_FLAG_CoCg_Y = 256,
+	SOIL_FLAG_TEXTURE_RECTANGLE = 512
+};
+
+/**
+	The types of images that may be saved.
+	(TGA supports uncompressed RGB / RGBA)
+	(BMP supports uncompressed RGB)
+	(DDS supports DXT1 and DXT5)
+**/
+enum
+{
+	SOIL_SAVE_TYPE_TGA = 0,
+	SOIL_SAVE_TYPE_BMP = 1,
+	SOIL_SAVE_TYPE_DDS = 2
+};
+
+/**
+	Defines the order of faces in a DDS cubemap.
+	I recommend that you use the same order in single
+	image cubemap files, so they will be interchangeable
+	with DDS cubemaps when using SOIL.
+**/
+#define SOIL_DDS_CUBEMAP_FACE_ORDER "EWUDNS"
+
+/**
+	The types of internal fake HDR representations
+
+	SOIL_HDR_RGBE:		RGB * pow( 2.0, A - 128.0 )
+	SOIL_HDR_RGBdivA:	RGB / A
+	SOIL_HDR_RGBdivA2:	RGB / (A*A)
+**/
+enum
+{
+	SOIL_HDR_RGBE = 0,
+	SOIL_HDR_RGBdivA = 1,
+	SOIL_HDR_RGBdivA2 = 2
+};
+
+/**
+	Loads an image from disk into an OpenGL texture.
+	\param filename the name of the file to upload as a texture
+	\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_texture
+	(
+		const char *filename,
+		int force_channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Loads 6 images from disk into an OpenGL cubemap texture.
+	\param x_pos_file the name of the file to upload as the +x cube face
+	\param x_neg_file the name of the file to upload as the -x cube face
+	\param y_pos_file the name of the file to upload as the +y cube face
+	\param y_neg_file the name of the file to upload as the -y cube face
+	\param z_pos_file the name of the file to upload as the +z cube face
+	\param z_neg_file the name of the file to upload as the -z cube face
+	\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_cubemap
+	(
+		const char *x_pos_file,
+		const char *x_neg_file,
+		const char *y_pos_file,
+		const char *y_neg_file,
+		const char *z_pos_file,
+		const char *z_neg_file,
+		int force_channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Loads 1 image from disk and splits it into an OpenGL cubemap texture.
+	\param filename the name of the file to upload as a texture
+	\param face_order the order of the faces in the file, any combination of NSWEUD, for North, South, Up, etc.
+	\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_single_cubemap
+	(
+		const char *filename,
+		const char face_order[6],
+		int force_channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Loads an HDR image from disk into an OpenGL texture.
+	\param filename the name of the file to upload as a texture
+	\param fake_HDR_format SOIL_HDR_RGBE, SOIL_HDR_RGBdivA, SOIL_HDR_RGBdivA2
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_HDR_texture
+	(
+		const char *filename,
+		int fake_HDR_format,
+		int rescale_to_max,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Loads an image from RAM into an OpenGL texture.
+	\param buffer the image data in RAM just as if it were still in a file
+	\param buffer_length the size of the buffer in bytes
+	\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_texture_from_memory
+	(
+		const unsigned char *const buffer,
+		int buffer_length,
+		int force_channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Loads 6 images from memory into an OpenGL cubemap texture.
+	\param x_pos_buffer the image data in RAM to upload as the +x cube face
+	\param x_pos_buffer_length the size of the above buffer
+	\param x_neg_buffer the image data in RAM to upload as the +x cube face
+	\param x_neg_buffer_length the size of the above buffer
+	\param y_pos_buffer the image data in RAM to upload as the +x cube face
+	\param y_pos_buffer_length the size of the above buffer
+	\param y_neg_buffer the image data in RAM to upload as the +x cube face
+	\param y_neg_buffer_length the size of the above buffer
+	\param z_pos_buffer the image data in RAM to upload as the +x cube face
+	\param z_pos_buffer_length the size of the above buffer
+	\param z_neg_buffer the image data in RAM to upload as the +x cube face
+	\param z_neg_buffer_length the size of the above buffer
+	\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_cubemap_from_memory
+	(
+		const unsigned char *const x_pos_buffer,
+		int x_pos_buffer_length,
+		const unsigned char *const x_neg_buffer,
+		int x_neg_buffer_length,
+		const unsigned char *const y_pos_buffer,
+		int y_pos_buffer_length,
+		const unsigned char *const y_neg_buffer,
+		int y_neg_buffer_length,
+		const unsigned char *const z_pos_buffer,
+		int z_pos_buffer_length,
+		const unsigned char *const z_neg_buffer,
+		int z_neg_buffer_length,
+		int force_channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Loads 1 image from RAM and splits it into an OpenGL cubemap texture.
+	\param buffer the image data in RAM just as if it were still in a file
+	\param buffer_length the size of the buffer in bytes
+	\param face_order the order of the faces in the file, any combination of NSWEUD, for North, South, Up, etc.
+	\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_load_OGL_single_cubemap_from_memory
+	(
+		const unsigned char *const buffer,
+		int buffer_length,
+		const char face_order[6],
+		int force_channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Creates a 2D OpenGL texture from raw image data.  Note that the raw data is
+	_NOT_ freed after the upload (so the user can load various versions).
+	\param data the raw data to be uploaded as an OpenGL texture
+	\param width the width of the image in pixels
+	\param height the height of the image in pixels
+	\param channels the number of channels: 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_create_OGL_texture
+	(
+		const unsigned char *const data,
+		int width, int height, int channels,
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Creates an OpenGL cubemap texture by splitting up 1 image into 6 parts.
+	\param data the raw data to be uploaded as an OpenGL texture
+	\param width the width of the image in pixels
+	\param height the height of the image in pixels
+	\param channels the number of channels: 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
+	\param face_order the order of the faces in the file, and combination of NSWEUD, for North, South, Up, etc.
+	\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
+	\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
+	\return 0-failed, otherwise returns the OpenGL texture handle
+**/
+unsigned int
+	SOIL_create_OGL_single_cubemap
+	(
+		const unsigned char *const data,
+		int width, int height, int channels,
+		const char face_order[6],
+		unsigned int reuse_texture_ID,
+		unsigned int flags
+	);
+
+/**
+	Captures the OpenGL window (RGB) and saves it to disk
+	\return 0 if it failed, otherwise returns 1
+**/
+int
+	SOIL_save_screenshot
+	(
+		const char *filename,
+		int image_type,
+		int x, int y,
+		int width, int height
+	);
+
+/**
+	Loads an image from disk into an array of unsigned chars.
+	Note that *channels return the original channel count of the
+	image.  If force_channels was other than SOIL_LOAD_AUTO,
+	the resulting image has force_channels, but *channels may be
+	different (if the original image had a different channel
+	count).
+	\return 0 if failed, otherwise returns 1
+**/
+unsigned char*
+	SOIL_load_image
+	(
+		const char *filename,
+		int *width, int *height, int *channels,
+		int force_channels
+	);
+
+/**
+	Loads an image from memory into an array of unsigned chars.
+	Note that *channels return the original channel count of the
+	image.  If force_channels was other than SOIL_LOAD_AUTO,
+	the resulting image has force_channels, but *channels may be
+	different (if the original image had a different channel
+	count).
+	\return 0 if failed, otherwise returns 1
+**/
+unsigned char*
+	SOIL_load_image_from_memory
+	(
+		const unsigned char *const buffer,
+		int buffer_length,
+		int *width, int *height, int *channels,
+		int force_channels
+	);
+
+/**
+	Saves an image from an array of unsigned chars (RGBA) to disk
+	\return 0 if failed, otherwise returns 1
+**/
+int
+	SOIL_save_image
+	(
+		const char *filename,
+		int image_type,
+		int width, int height, int channels,
+		const unsigned char *const data
+	);
+
+/**
+	Frees the image data (note, this is just C's "free()"...this function is
+	present mostly so C++ programmers don't forget to use "free()" and call
+	"delete []" instead [8^)
+**/
+void
+	SOIL_free_image_data
+	(
+		unsigned char *img_data
+	);
+
+/**
+	This function resturn a pointer to a string describing the last thing
+	that happened inside SOIL.  It can be used to determine why an image
+	failed to load.
+**/
+const char*
+	SOIL_last_result
+	(
+		void
+	);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HEADER_SIMPLE_OPENGL_IMAGE_LIBRARY	*/

GrafikaProjekt/pliki/src/SOIL/image_DXT.c

@@ -0,0 +1,632 @@
+/*
+	Jonathan Dummer
+	2007-07-31-10.32
+
+	simple DXT compression / decompression code
+
+	public domain
+*/
+
+#include "image_DXT.h"
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*	set this =1 if you want to use the covarince matrix method...
+	which is better than my method of using standard deviations
+	overall, except on the infintesimal chance that the power
+	method fails for finding the largest eigenvector	*/
+#define USE_COV_MAT	1
+
+/********* Function Prototypes *********/
+/*
+	Takes a 4x4 block of pixels and compresses it into 8 bytes
+	in DXT1 format (color only, no alpha).  Speed is valued
+	over prettyness, at least for now.
+*/
+void compress_DDS_color_block(
+				int channels,
+				const unsigned char *const uncompressed,
+				unsigned char compressed[8] );
+/*
+	Takes a 4x4 block of pixels and compresses the alpha
+	component it into 8 bytes for use in DXT5 DDS files.
+	Speed is valued over prettyness, at least for now.
+*/
+void compress_DDS_alpha_block(
+				const unsigned char *const uncompressed,
+				unsigned char compressed[8] );
+
+/********* Actual Exposed Functions *********/
+int
+	save_image_as_DDS
+	(
+		const char *filename,
+		int width, int height, int channels,
+		const unsigned char *const data
+	)
+{
+	/*	variables	*/
+	FILE *fout;
+	unsigned char *DDS_data;
+	DDS_header header;
+	int DDS_size;
+	/*	error check	*/
+	if( (NULL == filename) ||
+		(width < 1) || (height < 1) ||
+		(channels < 1) || (channels > 4) ||
+		(data == NULL ) )
+	{
+		return 0;
+	}
+	/*	Convert the image	*/
+	if( (channels & 1) == 1 )
+	{
+		/*	no alpha, just use DXT1	*/
+		DDS_data = convert_image_to_DXT1( data, width, height, channels, &DDS_size );
+	} else
+	{
+		/*	has alpha, so use DXT5	*/
+		DDS_data = convert_image_to_DXT5( data, width, height, channels, &DDS_size );
+	}
+	/*	save it	*/
+	memset( &header, 0, sizeof( DDS_header ) );
+	header.dwMagic = ('D' << 0) | ('D' << 8) | ('S' << 16) | (' ' << 24);
+	header.dwSize = 124;
+	header.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_LINEARSIZE;
+	header.dwWidth = width;
+	header.dwHeight = height;
+	header.dwPitchOrLinearSize = DDS_size;
+	header.sPixelFormat.dwSize = 32;
+	header.sPixelFormat.dwFlags = DDPF_FOURCC;
+	if( (channels & 1) == 1 )
+	{
+		header.sPixelFormat.dwFourCC = ('D' << 0) | ('X' << 8) | ('T' << 16) | ('1' << 24);
+	} else
+	{
+		header.sPixelFormat.dwFourCC = ('D' << 0) | ('X' << 8) | ('T' << 16) | ('5' << 24);
+	}
+	header.sCaps.dwCaps1 = DDSCAPS_TEXTURE;
+	/*	write it out	*/
+	fout = fopen( filename, "wb");
+	fwrite( &header, sizeof( DDS_header ), 1, fout );
+	fwrite( DDS_data, 1, DDS_size, fout );
+	fclose( fout );
+	/*	done	*/
+	free( DDS_data );
+	return 1;
+}
+
+unsigned char* convert_image_to_DXT1(
+		const unsigned char *const uncompressed,
+		int width, int height, int channels,
+		int *out_size )
+{
+	unsigned char *compressed;
+	int i, j, x, y;
+	unsigned char ublock[16*3];
+	unsigned char cblock[8];
+	int index = 0, chan_step = 1;
+	int block_count = 0;
+	/*	error check	*/
+	*out_size = 0;
+	if( (width < 1) || (height < 1) ||
+		(NULL == uncompressed) ||
+		(channels < 1) || (channels > 4) )
+	{
+		return NULL;
+	}
+	/*	for channels == 1 or 2, I do not step forward for R,G,B values	*/
+	if( channels < 3 )
+	{
+		chan_step = 0;
+	}
+	/*	get the RAM for the compressed image
+		(8 bytes per 4x4 pixel block)	*/
+	*out_size = ((width+3) >> 2) * ((height+3) >> 2) * 8;
+	compressed = (unsigned char*)malloc( *out_size );
+	/*	go through each block	*/
+	for( j = 0; j < height; j += 4 )
+	{
+		for( i = 0; i < width; i += 4 )
+		{
+			/*	copy this block into a new one	*/
+			int idx = 0;
+			int mx = 4, my = 4;
+			if( j+4 >= height )
+			{
+				my = height - j;
+			}
+			if( i+4 >= width )
+			{
+				mx = width - i;
+			}
+			for( y = 0; y < my; ++y )
+			{
+				for( x = 0; x < mx; ++x )
+				{
+					ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels];
+					ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step];
+					ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step+chan_step];
+				}
+				for( x = mx; x < 4; ++x )
+				{
+					ublock[idx++] = ublock[0];
+					ublock[idx++] = ublock[1];
+					ublock[idx++] = ublock[2];
+				}
+			}
+			for( y = my; y < 4; ++y )
+			{
+				for( x = 0; x < 4; ++x )
+				{
+					ublock[idx++] = ublock[0];
+					ublock[idx++] = ublock[1];
+					ublock[idx++] = ublock[2];
+				}
+			}
+			/*	compress the block	*/
+			++block_count;
+			compress_DDS_color_block( 3, ublock, cblock );
+			/*	copy the data from the block into the main block	*/
+			for( x = 0; x < 8; ++x )
+			{
+				compressed[index++] = cblock[x];
+			}
+		}
+	}
+	return compressed;
+}
+
+unsigned char* convert_image_to_DXT5(
+		const unsigned char *const uncompressed,
+		int width, int height, int channels,
+		int *out_size )
+{
+	unsigned char *compressed;
+	int i, j, x, y;
+	unsigned char ublock[16*4];
+	unsigned char cblock[8];
+	int index = 0, chan_step = 1;
+	int block_count = 0, has_alpha;
+	/*	error check	*/
+	*out_size = 0;
+	if( (width < 1) || (height < 1) ||
+		(NULL == uncompressed) ||
+		(channels < 1) || ( channels > 4) )
+	{
+		return NULL;
+	}
+	/*	for channels == 1 or 2, I do not step forward for R,G,B vales	*/
+	if( channels < 3 )
+	{
+		chan_step = 0;
+	}
+	/*	# channels = 1 or 3 have no alpha, 2 & 4 do have alpha	*/
+	has_alpha = 1 - (channels & 1);
+	/*	get the RAM for the compressed image
+		(16 bytes per 4x4 pixel block)	*/
+	*out_size = ((width+3) >> 2) * ((height+3) >> 2) * 16;
+	compressed = (unsigned char*)malloc( *out_size );
+	/*	go through each block	*/
+	for( j = 0; j < height; j += 4 )
+	{
+		for( i = 0; i < width; i += 4 )
+		{
+			/*	local variables, and my block counter	*/
+			int idx = 0;
+			int mx = 4, my = 4;
+			if( j+4 >= height )
+			{
+				my = height - j;
+			}
+			if( i+4 >= width )
+			{
+				mx = width - i;
+			}
+			for( y = 0; y < my; ++y )
+			{
+				for( x = 0; x < mx; ++x )
+				{
+					ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels];
+					ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step];
+					ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step+chan_step];
+					ublock[idx++] =
+						has_alpha * uncompressed[(j+y)*width*channels+(i+x)*channels+channels-1]
+						+ (1-has_alpha)*255;
+				}
+				for( x = mx; x < 4; ++x )
+				{
+					ublock[idx++] = ublock[0];
+					ublock[idx++] = ublock[1];
+					ublock[idx++] = ublock[2];
+					ublock[idx++] = ublock[3];
+				}
+			}
+			for( y = my; y < 4; ++y )
+			{
+				for( x = 0; x < 4; ++x )
+				{
+					ublock[idx++] = ublock[0];
+					ublock[idx++] = ublock[1];
+					ublock[idx++] = ublock[2];
+					ublock[idx++] = ublock[3];
+				}
+			}
+			/*	now compress the alpha block	*/
+			compress_DDS_alpha_block( ublock, cblock );
+			/*	copy the data from the compressed alpha block into the main buffer	*/
+			for( x = 0; x < 8; ++x )
+			{
+				compressed[index++] = cblock[x];
+			}
+			/*	then compress the color block	*/
+			++block_count;
+			compress_DDS_color_block( 4, ublock, cblock );
+			/*	copy the data from the compressed color block into the main buffer	*/
+			for( x = 0; x < 8; ++x )
+			{
+				compressed[index++] = cblock[x];
+			}
+		}
+	}
+	return compressed;
+}
+
+/********* Helper Functions *********/
+int convert_bit_range( int c, int from_bits, int to_bits )
+{
+	int b = (1 << (from_bits - 1)) + c * ((1 << to_bits) - 1);
+	return (b + (b >> from_bits)) >> from_bits;
+}
+
+int rgb_to_565( int r, int g, int b )
+{
+	return
+		(convert_bit_range( r, 8, 5 ) << 11) |
+		(convert_bit_range( g, 8, 6 ) << 05) |
+		(convert_bit_range( b, 8, 5 ) << 00);
+}
+
+void rgb_888_from_565( unsigned int c, int *r, int *g, int *b )
+{
+	*r = convert_bit_range( (c >> 11) & 31, 5, 8 );
+	*g = convert_bit_range( (c >> 05) & 63, 6, 8 );
+	*b = convert_bit_range( (c >> 00) & 31, 5, 8 );
+}
+
+void compute_color_line_STDEV(
+		const unsigned char *const uncompressed,
+		int channels,
+		float point[3], float direction[3] )
+{
+	const float inv_16 = 1.0f / 16.0f;
+	int i;
+	float sum_r = 0.0f, sum_g = 0.0f, sum_b = 0.0f;
+	float sum_rr = 0.0f, sum_gg = 0.0f, sum_bb = 0.0f;
+	float sum_rg = 0.0f, sum_rb = 0.0f, sum_gb = 0.0f;
+	/*	calculate all data needed for the covariance matrix
+		( to compare with _rygdxt code)	*/
+	for( i = 0; i < 16*channels; i += channels )
+	{
+		sum_r += uncompressed[i+0];
+		sum_rr += uncompressed[i+0] * uncompressed[i+0];
+		sum_g += uncompressed[i+1];
+		sum_gg += uncompressed[i+1] * uncompressed[i+1];
+		sum_b += uncompressed[i+2];
+		sum_bb += uncompressed[i+2] * uncompressed[i+2];
+		sum_rg += uncompressed[i+0] * uncompressed[i+1];
+		sum_rb += uncompressed[i+0] * uncompressed[i+2];
+		sum_gb += uncompressed[i+1] * uncompressed[i+2];
+	}
+	/*	convert the sums to averages	*/
+	sum_r *= inv_16;
+	sum_g *= inv_16;
+	sum_b *= inv_16;
+	/*	and convert the squares to the squares of the value - avg_value	*/
+	sum_rr -= 16.0f * sum_r * sum_r;
+	sum_gg -= 16.0f * sum_g * sum_g;
+	sum_bb -= 16.0f * sum_b * sum_b;
+	sum_rg -= 16.0f * sum_r * sum_g;
+	sum_rb -= 16.0f * sum_r * sum_b;
+	sum_gb -= 16.0f * sum_g * sum_b;
+	/*	the point on the color line is the average	*/
+	point[0] = sum_r;
+	point[1] = sum_g;
+	point[2] = sum_b;
+	#if USE_COV_MAT
+	/*
+		The following idea was from ryg.
+		(https://mollyrocket.com/forums/viewtopic.php?t=392)
+		The method worked great (less RMSE than mine) most of
+		the time, but had some issues handling some simple
+		boundary cases, like full green next to full red,
+		which would generate a covariance matrix like this:
+
+		| 1  -1  0 |
+		| -1  1  0 |
+		| 0   0  0 |
+
+		For a given starting vector, the power method can
+		generate all zeros!  So no starting with {1,1,1}
+		as I was doing!  This kind of error is still a
+		slight posibillity, but will be very rare.
+	*/
+	/*	use the covariance matrix directly
+		(1st iteration, don't use all 1.0 values!)	*/
+	sum_r = 1.0f;
+	sum_g = 2.718281828f;
+	sum_b = 3.141592654f;
+	direction[0] = sum_r*sum_rr + sum_g*sum_rg + sum_b*sum_rb;
+	direction[1] = sum_r*sum_rg + sum_g*sum_gg + sum_b*sum_gb;
+	direction[2] = sum_r*sum_rb + sum_g*sum_gb + sum_b*sum_bb;
+	/*	2nd iteration, use results from the 1st guy	*/
+	sum_r = direction[0];
+	sum_g = direction[1];
+	sum_b = direction[2];
+	direction[0] = sum_r*sum_rr + sum_g*sum_rg + sum_b*sum_rb;
+	direction[1] = sum_r*sum_rg + sum_g*sum_gg + sum_b*sum_gb;
+	direction[2] = sum_r*sum_rb + sum_g*sum_gb + sum_b*sum_bb;
+	/*	3rd iteration, use results from the 2nd guy	*/
+	sum_r = direction[0];
+	sum_g = direction[1];
+	sum_b = direction[2];
+	direction[0] = sum_r*sum_rr + sum_g*sum_rg + sum_b*sum_rb;
+	direction[1] = sum_r*sum_rg + sum_g*sum_gg + sum_b*sum_gb;
+	direction[2] = sum_r*sum_rb + sum_g*sum_gb + sum_b*sum_bb;
+	#else
+	/*	use my standard deviation method
+		(very robust, a tiny bit slower and less accurate)	*/
+	direction[0] = sqrt( sum_rr );
+	direction[1] = sqrt( sum_gg );
+	direction[2] = sqrt( sum_bb );
+	/*	which has a greater component	*/
+	if( sum_gg > sum_rr )
+	{
+		/*	green has greater component, so base the other signs off of green	*/
+		if( sum_rg < 0.0f )
+		{
+			direction[0] = -direction[0];
+		}
+		if( sum_gb < 0.0f )
+		{
+			direction[2] = -direction[2];
+		}
+	} else
+	{
+		/*	red has a greater component	*/
+		if( sum_rg < 0.0f )
+		{
+			direction[1] = -direction[1];
+		}
+		if( sum_rb < 0.0f )
+		{
+			direction[2] = -direction[2];
+		}
+	}
+	#endif
+}
+
+void LSE_master_colors_max_min(
+		int *cmax, int *cmin,
+		int channels,
+		const unsigned char *const uncompressed )
+{
+	int i, j;
+	/*	the master colors	*/
+	int c0[3], c1[3];
+	/*	used for fitting the line	*/
+	float sum_x[] = { 0.0f, 0.0f, 0.0f };
+	float sum_x2[] = { 0.0f, 0.0f, 0.0f };
+	float dot_max = 1.0f, dot_min = -1.0f;
+	float vec_len2 = 0.0f;
+	float dot;
+	/*	error check	*/
+	if( (channels < 3) || (channels > 4) )
+	{
+		return;
+	}
+	compute_color_line_STDEV( uncompressed, channels, sum_x, sum_x2 );
+	vec_len2 = 1.0f / ( 0.00001f +
+			sum_x2[0]*sum_x2[0] + sum_x2[1]*sum_x2[1] + sum_x2[2]*sum_x2[2] );
+	/*	finding the max and min vector values	*/
+	dot_max =
+			(
+				sum_x2[0] * uncompressed[0] +
+				sum_x2[1] * uncompressed[1] +
+				sum_x2[2] * uncompressed[2]
+			);
+	dot_min = dot_max;
+	for( i = 1; i < 16; ++i )
+	{
+		dot =
+			(
+				sum_x2[0] * uncompressed[i*channels+0] +
+				sum_x2[1] * uncompressed[i*channels+1] +
+				sum_x2[2] * uncompressed[i*channels+2]
+			);
+		if( dot < dot_min )
+		{
+			dot_min = dot;
+		} else if( dot > dot_max )
+		{
+			dot_max = dot;
+		}
+	}
+	/*	and the offset (from the average location)	*/
+	dot = sum_x2[0]*sum_x[0] + sum_x2[1]*sum_x[1] + sum_x2[2]*sum_x[2];
+	dot_min -= dot;
+	dot_max -= dot;
+	/*	post multiply by the scaling factor	*/
+	dot_min *= vec_len2;
+	dot_max *= vec_len2;
+	/*	OK, build the master colors	*/
+	for( i = 0; i < 3; ++i )
+	{
+		/*	color 0	*/
+		c0[i] = (int)(0.5f + sum_x[i] + dot_max * sum_x2[i]);
+		if( c0[i] < 0 )
+		{
+			c0[i] = 0;
+		} else if( c0[i] > 255 )
+		{
+			c0[i] = 255;
+		}
+		/*	color 1	*/
+		c1[i] = (int)(0.5f + sum_x[i] + dot_min * sum_x2[i]);
+		if( c1[i] < 0 )
+		{
+			c1[i] = 0;
+		} else if( c1[i] > 255 )
+		{
+			c1[i] = 255;
+		}
+	}
+	/*	down_sample (with rounding?)	*/
+	i = rgb_to_565( c0[0], c0[1], c0[2] );
+	j = rgb_to_565( c1[0], c1[1], c1[2] );
+	if( i > j )
+	{
+		*cmax = i;
+		*cmin = j;
+	} else
+	{
+		*cmax = j;
+		*cmin = i;
+	}
+}
+
+void
+	compress_DDS_color_block
+	(
+		int channels,
+		const unsigned char *const uncompressed,
+		unsigned char compressed[8]
+	)
+{
+	/*	variables	*/
+	int i;
+	int next_bit;
+	int enc_c0, enc_c1;
+	int c0[4], c1[4];
+	float color_line[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+	float vec_len2 = 0.0f, dot_offset = 0.0f;
+	/*	stupid order	*/
+	int swizzle4[] = { 0, 2, 3, 1 };
+	/*	get the master colors	*/
+	LSE_master_colors_max_min( &enc_c0, &enc_c1, channels, uncompressed );
+	/*	store the 565 color 0 and color 1	*/
+	compressed[0] = (enc_c0 >> 0) & 255;
+	compressed[1] = (enc_c0 >> 8) & 255;
+	compressed[2] = (enc_c1 >> 0) & 255;
+	compressed[3] = (enc_c1 >> 8) & 255;
+	/*	zero out the compressed data	*/
+	compressed[4] = 0;
+	compressed[5] = 0;
+	compressed[6] = 0;
+	compressed[7] = 0;
+	/*	reconstitute the master color vectors	*/
+	rgb_888_from_565( enc_c0, &c0[0], &c0[1], &c0[2] );
+	rgb_888_from_565( enc_c1, &c1[0], &c1[1], &c1[2] );
+	/*	the new vector	*/
+	vec_len2 = 0.0f;
+	for( i = 0; i < 3; ++i )
+	{
+		color_line[i] = (float)(c1[i] - c0[i]);
+		vec_len2 += color_line[i] * color_line[i];
+	}
+	if( vec_len2 > 0.0f )
+	{
+		vec_len2 = 1.0f / vec_len2;
+	}
+	/*	pre-proform the scaling	*/
+	color_line[0] *= vec_len2;
+	color_line[1] *= vec_len2;
+	color_line[2] *= vec_len2;
+	/*	compute the offset (constant) portion of the dot product	*/
+	dot_offset = color_line[0]*c0[0] + color_line[1]*c0[1] + color_line[2]*c0[2];
+	/*	store the rest of the bits	*/
+	next_bit = 8*4;
+	for( i = 0; i < 16; ++i )
+	{
+		/*	find the dot product of this color, to place it on the line
+			(should be [-1,1])	*/
+		int next_value = 0;
+		float dot_product =
+			color_line[0] * uncompressed[i*channels+0] +
+			color_line[1] * uncompressed[i*channels+1] +
+			color_line[2] * uncompressed[i*channels+2] -
+			dot_offset;
+		/*	map to [0,3]	*/
+		next_value = (int)( dot_product * 3.0f + 0.5f );
+		if( next_value > 3 )
+		{
+			next_value = 3;
+		} else if( next_value < 0 )
+		{
+			next_value = 0;
+		}
+		/*	OK, store this value	*/
+		compressed[next_bit >> 3] |= swizzle4[ next_value ] << (next_bit & 7);
+		next_bit += 2;
+	}
+	/*	done compressing to DXT1	*/
+}
+
+void
+	compress_DDS_alpha_block
+	(
+		const unsigned char *const uncompressed,
+		unsigned char compressed[8]
+	)
+{
+	/*	variables	*/
+	int i;
+	int next_bit;
+	int a0, a1;
+	float scale_me;
+	/*	stupid order	*/
+	int swizzle8[] = { 1, 7, 6, 5, 4, 3, 2, 0 };
+	/*	get the alpha limits (a0 > a1)	*/
+	a0 = a1 = uncompressed[3];
+	for( i = 4+3; i < 16*4; i += 4 )
+	{
+		if( uncompressed[i] > a0 )
+		{
+			a0 = uncompressed[i];
+		} else if( uncompressed[i] < a1 )
+		{
+			a1 = uncompressed[i];
+		}
+	}
+	/*	store those limits, and zero the rest of the compressed dataset	*/
+	compressed[0] = a0;
+	compressed[1] = a1;
+	/*	zero out the compressed data	*/
+	compressed[2] = 0;
+	compressed[3] = 0;
+	compressed[4] = 0;
+	compressed[5] = 0;
+	compressed[6] = 0;
+	compressed[7] = 0;
+	/*	store the all of the alpha values	*/
+	next_bit = 8*2;
+	scale_me = 7.9999f / (a0 - a1);
+	for( i = 3; i < 16*4; i += 4 )
+	{
+		/*	convert this alpha value to a 3 bit number	*/
+		int svalue;
+		int value = (int)((uncompressed[i] - a1) * scale_me);
+		svalue = swizzle8[ value&7 ];
+		/*	OK, store this value, start with the 1st byte	*/
+		compressed[next_bit >> 3] |= svalue << (next_bit & 7);
+		if( (next_bit & 7) > 5 )
+		{
+			/*	spans 2 bytes, fill in the start of the 2nd byte	*/
+			compressed[1 + (next_bit >> 3)] |= svalue >> (8 - (next_bit & 7) );
+		}
+		next_bit += 3;
+	}
+	/*	done compressing to DXT1	*/
+}

GrafikaProjekt/pliki/src/SOIL/image_DXT.h

@@ -0,0 +1,123 @@
+/*
+	Jonathan Dummer
+	2007-07-31-10.32
+
+	simple DXT compression / decompression code
+
+	public domain
+*/
+
+#ifndef HEADER_IMAGE_DXT
+#define HEADER_IMAGE_DXT
+
+/**
+	Converts an image from an array of unsigned chars (RGB or RGBA) to
+	DXT1 or DXT5, then saves the converted image to disk.
+	\return 0 if failed, otherwise returns 1
+**/
+int
+save_image_as_DDS
+(
+    const char *filename,
+    int width, int height, int channels,
+    const unsigned char *const data
+);
+
+/**
+	take an image and convert it to DXT1 (no alpha)
+**/
+unsigned char*
+convert_image_to_DXT1
+(
+    const unsigned char *const uncompressed,
+    int width, int height, int channels,
+    int *out_size
+);
+
+/**
+	take an image and convert it to DXT5 (with alpha)
+**/
+unsigned char*
+convert_image_to_DXT5
+(
+    const unsigned char *const uncompressed,
+    int width, int height, int channels,
+    int *out_size
+);
+
+/**	A bunch of DirectDraw Surface structures and flags **/
+typedef struct
+{
+    unsigned int    dwMagic;
+    unsigned int    dwSize;
+    unsigned int    dwFlags;
+    unsigned int    dwHeight;
+    unsigned int    dwWidth;
+    unsigned int    dwPitchOrLinearSize;
+    unsigned int    dwDepth;
+    unsigned int    dwMipMapCount;
+    unsigned int    dwReserved1[ 11 ];
+
+    /*  DDPIXELFORMAT	*/
+    struct
+    {
+        unsigned int    dwSize;
+        unsigned int    dwFlags;
+        unsigned int    dwFourCC;
+        unsigned int    dwRGBBitCount;
+        unsigned int    dwRBitMask;
+        unsigned int    dwGBitMask;
+        unsigned int    dwBBitMask;
+        unsigned int    dwAlphaBitMask;
+    }
+    sPixelFormat;
+
+    /*  DDCAPS2	*/
+    struct
+    {
+        unsigned int    dwCaps1;
+        unsigned int    dwCaps2;
+        unsigned int    dwDDSX;
+        unsigned int    dwReserved;
+    }
+    sCaps;
+    unsigned int    dwReserved2;
+}
+DDS_header ;
+
+/*	the following constants were copied directly off the MSDN website	*/
+
+/*	The dwFlags member of the original DDSURFACEDESC2 structure
+	can be set to one or more of the following values.	*/
+#define DDSD_CAPS	0x00000001
+#define DDSD_HEIGHT	0x00000002
+#define DDSD_WIDTH	0x00000004
+#define DDSD_PITCH	0x00000008
+#define DDSD_PIXELFORMAT	0x00001000
+#define DDSD_MIPMAPCOUNT	0x00020000
+#define DDSD_LINEARSIZE	0x00080000
+#define DDSD_DEPTH	0x00800000
+
+/*	DirectDraw Pixel Format	*/
+#define DDPF_ALPHAPIXELS	0x00000001
+#define DDPF_FOURCC	0x00000004
+#define DDPF_RGB	0x00000040
+
+/*	The dwCaps1 member of the DDSCAPS2 structure can be
+	set to one or more of the following values.	*/
+#define DDSCAPS_COMPLEX	0x00000008
+#define DDSCAPS_TEXTURE	0x00001000
+#define DDSCAPS_MIPMAP	0x00400000
+
+/*	The dwCaps2 member of the DDSCAPS2 structure can be
+	set to one or more of the following values.		*/
+#define DDSCAPS2_CUBEMAP	0x00000200
+#define DDSCAPS2_CUBEMAP_POSITIVEX	0x00000400
+#define DDSCAPS2_CUBEMAP_NEGATIVEX	0x00000800
+#define DDSCAPS2_CUBEMAP_POSITIVEY	0x00001000
+#define DDSCAPS2_CUBEMAP_NEGATIVEY	0x00002000
+#define DDSCAPS2_CUBEMAP_POSITIVEZ	0x00004000
+#define DDSCAPS2_CUBEMAP_NEGATIVEZ	0x00008000
+#define DDSCAPS2_VOLUME	0x00200000
+
+#endif /* HEADER_IMAGE_DXT	*/

GrafikaProjekt/pliki/src/SOIL/image_helper.c

@@ -0,0 +1,435 @@
+/*
+    Jonathan Dummer
+
+    image helper functions
+
+    MIT license
+*/
+
+#include "image_helper.h"
+#include <stdlib.h>
+#include <math.h>
+
+/*	Upscaling the image uses simple bilinear interpolation	*/
+int
+	up_scale_image
+	(
+		const unsigned char* const orig,
+		int width, int height, int channels,
+		unsigned char* resampled,
+		int resampled_width, int resampled_height
+	)
+{
+	float dx, dy;
+	int x, y, c;
+
+    /* error(s) check	*/
+    if ( 	(width < 1) || (height < 1) ||
+            (resampled_width < 2) || (resampled_height < 2) ||
+            (channels < 1) ||
+            (NULL == orig) || (NULL == resampled) )
+    {
+        /*	signify badness	*/
+        return 0;
+    }
+    /*
+		for each given pixel in the new map, find the exact location
+		from the original map which would contribute to this guy
+	*/
+    dx = (width - 1.0f) / (resampled_width - 1.0f);
+    dy = (height - 1.0f) / (resampled_height - 1.0f);
+    for ( y = 0; y < resampled_height; ++y )
+    {
+    	/* find the base y index and fractional offset from that	*/
+    	float sampley = y * dy;
+    	int inty = (int)sampley;
+    	/*	if( inty < 0 ) { inty = 0; } else	*/
+		if( inty > height - 2 ) { inty = height - 2; }
+		sampley -= inty;
+        for ( x = 0; x < resampled_width; ++x )
+        {
+			float samplex = x * dx;
+			int intx = (int)samplex;
+			int base_index;
+			/* find the base x index and fractional offset from that	*/
+			/*	if( intx < 0 ) { intx = 0; } else	*/
+			if( intx > width - 2 ) { intx = width - 2; }
+			samplex -= intx;
+			/*	base index into the original image	*/
+			base_index = (inty * width + intx) * channels;
+            for ( c = 0; c < channels; ++c )
+            {
+            	/*	do the sampling	*/
+				float value = 0.5f;
+				value += orig[base_index]
+							*(1.0f-samplex)*(1.0f-sampley);
+				value += orig[base_index+channels]
+							*(samplex)*(1.0f-sampley);
+				value += orig[base_index+width*channels]
+							*(1.0f-samplex)*(sampley);
+				value += orig[base_index+width*channels+channels]
+							*(samplex)*(sampley);
+				/*	move to the next channel	*/
+				++base_index;
+            	/*	save the new value	*/
+            	resampled[y*resampled_width*channels+x*channels+c] =
+						(unsigned char)(value);
+            }
+        }
+    }
+    /*	done	*/
+    return 1;
+}
+
+int
+	mipmap_image
+	(
+		const unsigned char* const orig,
+		int width, int height, int channels,
+		unsigned char* resampled,
+		int block_size_x, int block_size_y
+	)
+{
+	int mip_width, mip_height;
+	int i, j, c;
+
+	/*	error check	*/
+	if( (width < 1) || (height < 1) ||
+		(channels < 1) || (orig == NULL) ||
+		(resampled == NULL) ||
+		(block_size_x < 1) || (block_size_y < 1) )
+	{
+		/*	nothing to do	*/
+		return 0;
+	}
+	mip_width = width / block_size_x;
+	mip_height = height / block_size_y;
+	if( mip_width < 1 )
+	{
+		mip_width = 1;
+	}
+	if( mip_height < 1 )
+	{
+		mip_height = 1;
+	}
+	for( j = 0; j < mip_height; ++j )
+	{
+		for( i = 0; i < mip_width; ++i )
+		{
+			for( c = 0; c < channels; ++c )
+			{
+				const int index = (j*block_size_y)*width*channels + (i*block_size_x)*channels + c;
+				int sum_value;
+				int u,v;
+				int u_block = block_size_x;
+				int v_block = block_size_y;
+				int block_area;
+				/*	do a bit of checking so we don't over-run the boundaries
+					(necessary for non-square textures!)	*/
+				if( block_size_x * (i+1) > width )
+				{
+					u_block = width - i*block_size_y;
+				}
+				if( block_size_y * (j+1) > height )
+				{
+					v_block = height - j*block_size_y;
+				}
+				block_area = u_block*v_block;
+				/*	for this pixel, see what the average
+					of all the values in the block are.
+					note: start the sum at the rounding value, not at 0	*/
+				sum_value = block_area >> 1;
+				for( v = 0; v < v_block; ++v )
+				for( u = 0; u < u_block; ++u )
+				{
+					sum_value += orig[index + v*width*channels + u*channels];
+				}
+				resampled[j*mip_width*channels + i*channels + c] = sum_value / block_area;
+			}
+		}
+	}
+	return 1;
+}
+
+int
+	scale_image_RGB_to_NTSC_safe
+	(
+		unsigned char* orig,
+		int width, int height, int channels
+	)
+{
+	const float scale_lo = 16.0f - 0.499f;
+	const float scale_hi = 235.0f + 0.499f;
+	int i, j;
+	int nc = channels;
+	unsigned char scale_LUT[256];
+	/*	error check	*/
+	if( (width < 1) || (height < 1) ||
+		(channels < 1) || (orig == NULL) )
+	{
+		/*	nothing to do	*/
+		return 0;
+	}
+	/*	set up the scaling Look Up Table	*/
+	for( i = 0; i < 256; ++i )
+	{
+		scale_LUT[i] = (unsigned char)((scale_hi - scale_lo) * i / 255.0f + scale_lo);
+	}
+	/*	for channels = 2 or 4, ignore the alpha component	*/
+	nc -= 1 - (channels & 1);
+	/*	OK, go through the image and scale any non-alpha components	*/
+	for( i = 0; i < width*height*channels; i += channels )
+	{
+		for( j = 0; j < nc; ++j )
+		{
+			orig[i+j] = scale_LUT[orig[i+j]];
+		}
+	}
+	return 1;
+}
+
+unsigned char clamp_byte( int x ) { return ( (x) < 0 ? (0) : ( (x) > 255 ? 255 : (x) ) ); }
+
+/*
+	This function takes the RGB components of the image
+	and converts them into YCoCg.  3 components will be
+	re-ordered to CoYCg (for optimum DXT1 compression),
+	while 4 components will be ordered CoCgAY (for DXT5
+	compression).
+*/
+int
+	convert_RGB_to_YCoCg
+	(
+		unsigned char* orig,
+		int width, int height, int channels
+	)
+{
+	int i;
+	/*	error check	*/
+	if( (width < 1) || (height < 1) ||
+		(channels < 3) || (channels > 4) ||
+		(orig == NULL) )
+	{
+		/*	nothing to do	*/
+		return -1;
+	}
+	/*	do the conversion	*/
+	if( channels == 3 )
+	{
+		for( i = 0; i < width*height*3; i += 3 )
+		{
+			int r = orig[i+0];
+			int g = (orig[i+1] + 1) >> 1;
+			int b = orig[i+2];
+			int tmp = (2 + r + b) >> 2;
+			/*	Co	*/
+			orig[i+0] = clamp_byte( 128 + ((r - b + 1) >> 1) );
+			/*	Y	*/
+			orig[i+1] = clamp_byte( g + tmp );
+			/*	Cg	*/
+			orig[i+2] = clamp_byte( 128 + g - tmp );
+		}
+	} else
+	{
+		for( i = 0; i < width*height*4; i += 4 )
+		{
+			int r = orig[i+0];
+			int g = (orig[i+1] + 1) >> 1;
+			int b = orig[i+2];
+			unsigned char a = orig[i+3];
+			int tmp = (2 + r + b) >> 2;
+			/*	Co	*/
+			orig[i+0] = clamp_byte( 128 + ((r - b + 1) >> 1) );
+			/*	Cg	*/
+			orig[i+1] = clamp_byte( 128 + g - tmp );
+			/*	Alpha	*/
+			orig[i+2] = a;
+			/*	Y	*/
+			orig[i+3] = clamp_byte( g + tmp );
+		}
+	}
+	/*	done	*/
+	return 0;
+}
+
+/*
+	This function takes the YCoCg components of the image
+	and converts them into RGB.  See above.
+*/
+int
+	convert_YCoCg_to_RGB
+	(
+		unsigned char* orig,
+		int width, int height, int channels
+	)
+{
+	int i;
+	/*	error check	*/
+	if( (width < 1) || (height < 1) ||
+		(channels < 3) || (channels > 4) ||
+		(orig == NULL) )
+	{
+		/*	nothing to do	*/
+		return -1;
+	}
+	/*	do the conversion	*/
+	if( channels == 3 )
+	{
+		for( i = 0; i < width*height*3; i += 3 )
+		{
+			int co = orig[i+0] - 128;
+			int y  = orig[i+1];
+			int cg = orig[i+2] - 128;
+			/*	R	*/
+			orig[i+0] = clamp_byte( y + co - cg );
+			/*	G	*/
+			orig[i+1] = clamp_byte( y + cg );
+			/*	B	*/
+			orig[i+2] = clamp_byte( y - co - cg );
+		}
+	} else
+	{
+		for( i = 0; i < width*height*4; i += 4 )
+		{
+			int co = orig[i+0] - 128;
+			int cg = orig[i+1] - 128;
+			unsigned char a  = orig[i+2];
+			int y  = orig[i+3];
+			/*	R	*/
+			orig[i+0] = clamp_byte( y + co - cg );
+			/*	G	*/
+			orig[i+1] = clamp_byte( y + cg );
+			/*	B	*/
+			orig[i+2] = clamp_byte( y - co - cg );
+			/*	A	*/
+			orig[i+3] = a;
+		}
+	}
+	/*	done	*/
+	return 0;
+}
+
+float
+find_max_RGBE
+(
+	unsigned char *image,
+    int width, int height
+)
+{
+	float max_val = 0.0f;
+	unsigned char *img = image;
+	int i, j;
+	for( i = width * height; i > 0; --i )
+	{
+		/* float scale = powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
+		float scale = ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
+		for( j = 0; j < 3; ++j )
+		{
+			if( img[j] * scale > max_val )
+			{
+				max_val = img[j] * scale;
+			}
+		}
+		/* next pixel */
+		img += 4;
+	}
+	return max_val;
+}
+
+int
+RGBE_to_RGBdivA
+(
+    unsigned char *image,
+    int width, int height,
+    int rescale_to_max
+)
+{
+	/* local variables */
+	int i, iv;
+	unsigned char *img = image;
+	float scale = 1.0f;
+	/* error check */
+	if( (!image) || (width < 1) || (height < 1) )
+	{
+		return 0;
+	}
+	/* convert (note: no negative numbers, but 0.0 is possible) */
+	if( rescale_to_max )
+	{
+		scale = 255.0f / find_max_RGBE( image, width, height );
+	}
+	for( i = width * height; i > 0; --i )
+	{
+		/* decode this pixel, and find the max */
+		float r,g,b,e, m;
+		/* e = scale * powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
+		e = scale * ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
+		r = e * img[0];
+		g = e * img[1];
+		b = e * img[2];
+		m = (r > g) ? r : g;
+		m = (b > m) ? b : m;
+		/* and encode it into RGBdivA */
+		iv = (m != 0.0f) ? (int)(255.0f / m) : 1.0f;
+		iv = (iv < 1) ? 1 : iv;
+		img[3] = (iv > 255) ? 255 : iv;
+		iv = (int)(img[3] * r + 0.5f);
+		img[0] = (iv > 255) ? 255 : iv;
+		iv = (int)(img[3] * g + 0.5f);
+		img[1] = (iv > 255) ? 255 : iv;
+		iv = (int)(img[3] * b + 0.5f);
+		img[2] = (iv > 255) ? 255 : iv;
+		/* and on to the next pixel */
+		img += 4;
+	}
+	return 1;
+}
+
+int
+RGBE_to_RGBdivA2
+(
+    unsigned char *image,
+    int width, int height,
+    int rescale_to_max
+)
+{
+	/* local variables */
+	int i, iv;
+	unsigned char *img = image;
+	float scale = 1.0f;
+	/* error check */
+	if( (!image) || (width < 1) || (height < 1) )
+	{
+		return 0;
+	}
+	/* convert (note: no negative numbers, but 0.0 is possible) */
+	if( rescale_to_max )
+	{
+		scale = 255.0f * 255.0f / find_max_RGBE( image, width, height );
+	}
+	for( i = width * height; i > 0; --i )
+	{
+		/* decode this pixel, and find the max */
+		float r,g,b,e, m;
+		/* e = scale * powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
+		e = scale * ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
+		r = e * img[0];
+		g = e * img[1];
+		b = e * img[2];
+		m = (r > g) ? r : g;
+		m = (b > m) ? b : m;
+		/* and encode it into RGBdivA */
+		iv = (m != 0.0f) ? (int)sqrtf( 255.0f * 255.0f / m ) : 1.0f;
+		iv = (iv < 1) ? 1 : iv;
+		img[3] = (iv > 255) ? 255 : iv;
+		iv = (int)(img[3] * img[3] * r / 255.0f + 0.5f);
+		img[0] = (iv > 255) ? 255 : iv;
+		iv = (int)(img[3] * img[3] * g / 255.0f + 0.5f);
+		img[1] = (iv > 255) ? 255 : iv;
+		iv = (int)(img[3] * img[3] * b / 255.0f + 0.5f);
+		img[2] = (iv > 255) ? 255 : iv;
+		/* and on to the next pixel */
+		img += 4;
+	}
+	return 1;
+}

GrafikaProjekt/pliki/src/SOIL/image_helper.h

@@ -0,0 +1,115 @@
+/*
+    Jonathan Dummer
+
+    Image helper functions
+
+    MIT license
+*/
+
+#ifndef HEADER_IMAGE_HELPER
+#define HEADER_IMAGE_HELPER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+	This function upscales an image.
+	Not to be used to create MIPmaps,
+	but to make it square,
+	or to make it a power-of-two sized.
+**/
+int
+	up_scale_image
+	(
+		const unsigned char* const orig,
+		int width, int height, int channels,
+		unsigned char* resampled,
+		int resampled_width, int resampled_height
+	);
+
+/**
+	This function downscales an image.
+	Used for creating MIPmaps,
+	the incoming image should be a
+	power-of-two sized.
+**/
+int
+	mipmap_image
+	(
+		const unsigned char* const orig,
+		int width, int height, int channels,
+		unsigned char* resampled,
+		int block_size_x, int block_size_y
+	);
+
+/**
+	This function takes the RGB components of the image
+	and scales each channel from [0,255] to [16,235].
+	This makes the colors "Safe" for display on NTSC
+	displays.  Note that this is _NOT_ a good idea for
+	loading images like normal- or height-maps!
+**/
+int
+	scale_image_RGB_to_NTSC_safe
+	(
+		unsigned char* orig,
+		int width, int height, int channels
+	);
+
+/**
+	This function takes the RGB components of the image
+	and converts them into YCoCg.  3 components will be
+	re-ordered to CoYCg (for optimum DXT1 compression),
+	while 4 components will be ordered CoCgAY (for DXT5
+	compression).
+**/
+int
+	convert_RGB_to_YCoCg
+	(
+		unsigned char* orig,
+		int width, int height, int channels
+	);
+
+/**
+	This function takes the YCoCg components of the image
+	and converts them into RGB.  See above.
+**/
+int
+	convert_YCoCg_to_RGB
+	(
+		unsigned char* orig,
+		int width, int height, int channels
+	);
+
+/**
+	Converts an HDR image from an array
+	of unsigned chars (RGBE) to RGBdivA
+	\return 0 if failed, otherwise returns 1
+**/
+int
+	RGBE_to_RGBdivA
+	(
+		unsigned char *image,
+		int width, int height,
+		int rescale_to_max
+	);
+
+/**
+	Converts an HDR image from an array
+	of unsigned chars (RGBE) to RGBdivA2
+	\return 0 if failed, otherwise returns 1
+**/
+int
+	RGBE_to_RGBdivA2
+	(
+		unsigned char *image,
+		int width, int height,
+		int rescale_to_max
+	);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HEADER_IMAGE_HELPER	*/

GrafikaProjekt/pliki/src/SOIL/stb_image_aug.h

@@ -0,0 +1,354 @@
+/* stbi-1.16 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
+                      when you control the images you're loading
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline (no JPEG progressive, no oddball channel decimations)
+      PNG non-interlaced
+      BMP non-1bpp, non-RLE
+      TGA (not sure what subset, if a subset)
+      PSD (composited view only, no extra channels)
+      HDR (radiance rgbE format)
+      writes BMP,TGA (define STBI_NO_WRITE to remove code)
+      decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
+      supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
+        
+   TODO:
+      stbi_info_*
+  
+   history:
+      1.16   major bugfix - convert_format converted one too many pixels
+      1.15   initialize some fields for thread safety
+      1.14   fix threadsafe conversion bug; header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13   threadsafe
+      1.12   const qualifiers in the API
+      1.11   Support installable IDCT, colorspace conversion routines
+      1.10   Fixes for 64-bit (don't use "unsigned long")
+             optimized upsampling by Fabian "ryg" Giesen
+      1.09   Fix format-conversion for PSD code (bad global variables!)
+      1.08   Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07   attempt to fix C++ warning/errors again
+      1.06   attempt to fix C++ warning/errors again
+      1.05   fix TGA loading to return correct *comp and use good luminance calc
+      1.04   default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03   bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02   support for (subset of) HDR files, float interface for preferred access to them
+      1.01   fix bug: possible bug in handling right-side up bmps... not sure
+             fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all
+      1.00   interface to zlib that skips zlib header
+      0.99   correct handling of alpha in palette
+      0.98   TGA loader by lonesock; dynamically add loaders (untested)
+      0.97   jpeg errors on too large a file; also catch another malloc failure
+      0.96   fix detection of invalid v value - particleman@mollyrocket forum
+      0.95   during header scan, seek to markers in case of padding
+      0.94   STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93   handle jpegtran output; verbose errors
+      0.92   read 4,8,16,24,32-bit BMP files of several formats
+      0.91   output 24-bit Windows 3.0 BMP files
+      0.90   fix a few more warnings; bump version number to approach 1.0
+      0.61   bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60   fix compiling as c++
+      0.59   fix warnings: merge Dave Moore's -Wall fixes
+      0.58   fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57   fix bug: jpg last huffman symbol before marker was >9 bits but less
+                      than 16 available
+      0.56   fix bug: zlib uncompressed mode len vs. nlen
+      0.55   fix bug: restart_interval not initialized to 0
+      0.54   allow NULL for 'int *comp'
+      0.53   fix bug in png 3->4; speedup png decoding
+      0.52   png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51   obey req_comp requests, 1-component jpegs return as 1-component,
+             on 'test' only check type, not whether we support this variant
+*/
+
+#ifndef HEADER_STB_IMAGE_AUGMENTED
+#define HEADER_STB_IMAGE_AUGMENTED
+
+////   begin header file  ////////////////////////////////////////////////////
+//
+// Limitations:
+//    - no progressive/interlaced support (jpeg, png)
+//    - 8-bit samples only (jpeg, png)
+//    - not threadsafe
+//    - channel subsampling of at most 2 in each dimension (jpeg)
+//    - no delayed line count (jpeg) -- IJG doesn't support either
+//
+// Basic usage (see HDR discussion below):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ... 
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x       -- outputs image width in pixels
+//    int *y       -- outputs image height in pixels
+//    int *comp    -- outputs # of image components in image file
+//    int req_comp -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
+// If req_comp is non-zero, *comp has the number of components that _would_
+// have been output otherwise. E.g. if you set req_comp to 4, you will always
+// get RGBA output, but you can check *comp to easily see if it's opaque.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
+// can be queried for an extremely brief, end-user unfriendly explanation
+// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
+// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG and BMP images are automatically depalettized.
+//
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image now supports loading HDR images in general, and currently
+// the Radiance .HDR file format, although the support is provided
+// generically. You can still load any file through the existing interface;
+// if you attempt to load an HDR file, it will be automatically remapped to
+// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+// 
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for req_comp
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4,
+};
+
+typedef unsigned char stbi_uc;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// WRITING API
+
+#if !defined(STBI_NO_WRITE) && !defined(STBI_NO_STDIO)
+// write a BMP/TGA file given tightly packed 'comp' channels (no padding, nor bmp-stride-padding)
+// (you must include the appropriate extension in the filename).
+// returns TRUE on success, FALSE if couldn't open file, error writing file
+extern int      stbi_write_bmp       (char const *filename,     int x, int y, int comp, void *data);
+extern int      stbi_write_tga       (char const *filename,     int x, int y, int comp, void *data);
+#endif
+
+// PRIMARY API - works on images of any type
+
+// load image by filename, open file, or memory buffer
+#ifndef STBI_NO_STDIO
+extern stbi_uc *stbi_load            (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
+#endif
+extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+
+#ifndef STBI_NO_HDR
+#ifndef STBI_NO_STDIO
+extern float *stbi_loadf            (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern float *stbi_loadf_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+extern void   stbi_hdr_to_ldr_gamma(float gamma);
+extern void   stbi_hdr_to_ldr_scale(float scale);
+
+extern void   stbi_ldr_to_hdr_gamma(float gamma);
+extern void   stbi_ldr_to_hdr_scale(float scale);
+
+#endif // STBI_NO_HDR
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+extern char    *stbi_failure_reason  (void); 
+
+// free the loaded image -- this is just free()
+extern void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+extern int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+extern int      stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+extern int      stbi_info            (char const *filename,     int *x, int *y, int *comp);
+extern int      stbi_is_hdr          (char const *filename);
+extern int      stbi_is_hdr_from_file(FILE *f);
+#endif
+
+// ZLIB client - used by PNG, available for other purposes
+
+extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+extern int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+extern int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+// TYPE-SPECIFIC ACCESS
+
+// is it a jpeg?
+extern int      stbi_jpeg_test_memory     (stbi_uc const *buffer, int len);
+extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+extern int      stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+
+#ifndef STBI_NO_STDIO
+extern stbi_uc *stbi_jpeg_load            (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern int      stbi_jpeg_test_file       (FILE *f);
+extern stbi_uc *stbi_jpeg_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+
+extern int      stbi_jpeg_info            (char const *filename,     int *x, int *y, int *comp);
+extern int      stbi_jpeg_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
+#endif
+
+// is it a png?
+extern int      stbi_png_test_memory      (stbi_uc const *buffer, int len);
+extern stbi_uc *stbi_png_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+extern int      stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+
+#ifndef STBI_NO_STDIO
+extern stbi_uc *stbi_png_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern int      stbi_png_info             (char const *filename,     int *x, int *y, int *comp);
+extern int      stbi_png_test_file        (FILE *f);
+extern stbi_uc *stbi_png_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+extern int      stbi_png_info_from_file   (FILE *f,                  int *x, int *y, int *comp);
+#endif
+
+// is it a bmp?
+extern int      stbi_bmp_test_memory      (stbi_uc const *buffer, int len);
+
+extern stbi_uc *stbi_bmp_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+#ifndef STBI_NO_STDIO
+extern int      stbi_bmp_test_file        (FILE *f);
+extern stbi_uc *stbi_bmp_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+// is it a tga?
+extern int      stbi_tga_test_memory      (stbi_uc const *buffer, int len);
+
+extern stbi_uc *stbi_tga_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+#ifndef STBI_NO_STDIO
+extern int      stbi_tga_test_file        (FILE *f);
+extern stbi_uc *stbi_tga_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+// is it a psd?
+extern int      stbi_psd_test_memory      (stbi_uc const *buffer, int len);
+
+extern stbi_uc *stbi_psd_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+#ifndef STBI_NO_STDIO
+extern int      stbi_psd_test_file        (FILE *f);
+extern stbi_uc *stbi_psd_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+// is it an hdr?
+extern int      stbi_hdr_test_memory      (stbi_uc const *buffer, int len);
+
+extern float *  stbi_hdr_load             (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern float *  stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_hdr_load_rgbe        (char const *filename,           int *x, int *y, int *comp, int req_comp);
+extern float *  stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+#ifndef STBI_NO_STDIO
+extern int      stbi_hdr_test_file        (FILE *f);
+extern float *  stbi_hdr_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_hdr_load_rgbe_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+// define new loaders
+typedef struct
+{
+   int       (*test_memory)(stbi_uc const *buffer, int len);
+   stbi_uc * (*load_from_memory)(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+   #ifndef STBI_NO_STDIO
+   int       (*test_file)(FILE *f);
+   stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp);
+   #endif
+} stbi_loader;
+
+// register a loader by filling out the above structure (you must defined ALL functions)
+// returns 1 if added or already added, 0 if not added (too many loaders)
+// NOT THREADSAFE
+extern int stbi_register_loader(stbi_loader *loader);
+
+// define faster low-level operations (typically SIMD support)
+#if STBI_SIMD
+typedef void (*stbi_idct_8x8)(uint8 *out, int out_stride, short data[64], unsigned short *dequantize);
+// compute an integer IDCT on "input"
+//     input[x] = data[x] * dequantize[x]
+//     write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
+//                             CLAMP results to 0..255
+typedef void (*stbi_YCbCr_to_RGB_run)(uint8 *output, uint8 const *y, uint8 const *cb, uint8 const *cr, int count, int step);
+// compute a conversion from YCbCr to RGB
+//     'count' pixels
+//     write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
+//     y: Y input channel
+//     cb: Cb input channel; scale/biased to be 0..255
+//     cr: Cr input channel; scale/biased to be 0..255
+
+extern void stbi_install_idct(stbi_idct_8x8 func);
+extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
+#endif // STBI_SIMD
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H

GrafikaProjekt/pliki/src/SOIL/stbi_DDS_aug.h

@@ -0,0 +1,21 @@
+/*
+	adding DDS loading support to stbi
+*/
+
+#ifndef HEADER_STB_IMAGE_DDS_AUGMENTATION
+#define HEADER_STB_IMAGE_DDS_AUGMENTATION
+
+//	is it a DDS file?
+extern int      stbi_dds_test_memory      (stbi_uc const *buffer, int len);
+
+extern stbi_uc *stbi_dds_load             (char *filename,           int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+#ifndef STBI_NO_STDIO
+extern int      stbi_dds_test_file        (FILE *f);
+extern stbi_uc *stbi_dds_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // HEADER_STB_IMAGE_DDS_AUGMENTATION

GrafikaProjekt/pliki/src/SOIL/stbi_DDS_aug_c.h

@@ -0,0 +1,511 @@
+
+///	DDS file support, does decoding, _not_ direct uploading
+///	(use SOIL for that ;-)
+
+///	A bunch of DirectDraw Surface structures and flags
+typedef struct {
+    unsigned int    dwMagic;
+    unsigned int    dwSize;
+    unsigned int    dwFlags;
+    unsigned int    dwHeight;
+    unsigned int    dwWidth;
+    unsigned int    dwPitchOrLinearSize;
+    unsigned int    dwDepth;
+    unsigned int    dwMipMapCount;
+    unsigned int    dwReserved1[ 11 ];
+
+    //  DDPIXELFORMAT
+    struct {
+      unsigned int    dwSize;
+      unsigned int    dwFlags;
+      unsigned int    dwFourCC;
+      unsigned int    dwRGBBitCount;
+      unsigned int    dwRBitMask;
+      unsigned int    dwGBitMask;
+      unsigned int    dwBBitMask;
+      unsigned int    dwAlphaBitMask;
+    }               sPixelFormat;
+
+    //  DDCAPS2
+    struct {
+      unsigned int    dwCaps1;
+      unsigned int    dwCaps2;
+      unsigned int    dwDDSX;
+      unsigned int    dwReserved;
+    }               sCaps;
+    unsigned int    dwReserved2;
+} DDS_header ;
+
+//	the following constants were copied directly off the MSDN website
+
+//	The dwFlags member of the original DDSURFACEDESC2 structure
+//	can be set to one or more of the following values.
+#define DDSD_CAPS	0x00000001
+#define DDSD_HEIGHT	0x00000002
+#define DDSD_WIDTH	0x00000004
+#define DDSD_PITCH	0x00000008
+#define DDSD_PIXELFORMAT	0x00001000
+#define DDSD_MIPMAPCOUNT	0x00020000
+#define DDSD_LINEARSIZE	0x00080000
+#define DDSD_DEPTH	0x00800000
+
+//	DirectDraw Pixel Format
+#define DDPF_ALPHAPIXELS	0x00000001
+#define DDPF_FOURCC	0x00000004
+#define DDPF_RGB	0x00000040
+
+//	The dwCaps1 member of the DDSCAPS2 structure can be
+//	set to one or more of the following values.
+#define DDSCAPS_COMPLEX	0x00000008
+#define DDSCAPS_TEXTURE	0x00001000
+#define DDSCAPS_MIPMAP	0x00400000
+
+//	The dwCaps2 member of the DDSCAPS2 structure can be
+//	set to one or more of the following values.
+#define DDSCAPS2_CUBEMAP	0x00000200
+#define DDSCAPS2_CUBEMAP_POSITIVEX	0x00000400
+#define DDSCAPS2_CUBEMAP_NEGATIVEX	0x00000800
+#define DDSCAPS2_CUBEMAP_POSITIVEY	0x00001000
+#define DDSCAPS2_CUBEMAP_NEGATIVEY	0x00002000
+#define DDSCAPS2_CUBEMAP_POSITIVEZ	0x00004000
+#define DDSCAPS2_CUBEMAP_NEGATIVEZ	0x00008000
+#define DDSCAPS2_VOLUME	0x00200000
+
+static int dds_test(stbi *s)
+{
+	//	check the magic number
+	if (get8(s) != 'D') return 0;
+	if (get8(s) != 'D') return 0;
+	if (get8(s) != 'S') return 0;
+	if (get8(s) != ' ') return 0;
+	//	check header size
+	if (get32le(s) != 124) return 0;
+	return 1;
+}
+#ifndef STBI_NO_STDIO
+int      stbi_dds_test_file        (FILE *f)
+{
+   stbi s;
+   int r,n = ftell(f);
+   start_file(&s,f);
+   r = dds_test(&s);
+   fseek(f,n,SEEK_SET);
+   return r;
+}
+#endif
+
+int      stbi_dds_test_memory      (stbi_uc const *buffer, int len)
+{
+   stbi s;
+   start_mem(&s,buffer, len);
+   return dds_test(&s);
+}
+
+//	helper functions
+int stbi_convert_bit_range( int c, int from_bits, int to_bits )
+{
+	int b = (1 << (from_bits - 1)) + c * ((1 << to_bits) - 1);
+	return (b + (b >> from_bits)) >> from_bits;
+}
+void stbi_rgb_888_from_565( unsigned int c, int *r, int *g, int *b )
+{
+	*r = stbi_convert_bit_range( (c >> 11) & 31, 5, 8 );
+	*g = stbi_convert_bit_range( (c >> 05) & 63, 6, 8 );
+	*b = stbi_convert_bit_range( (c >> 00) & 31, 5, 8 );
+}
+void stbi_decode_DXT1_block(
+			unsigned char uncompressed[16*4],
+			unsigned char compressed[8] )
+{
+	int next_bit = 4*8;
+	int i, r, g, b;
+	int c0, c1;
+	unsigned char decode_colors[4*4];
+	//	find the 2 primary colors
+	c0 = compressed[0] + (compressed[1] << 8);
+	c1 = compressed[2] + (compressed[3] << 8);
+	stbi_rgb_888_from_565( c0, &r, &g, &b );
+	decode_colors[0] = r;
+	decode_colors[1] = g;
+	decode_colors[2] = b;
+	decode_colors[3] = 255;
+	stbi_rgb_888_from_565( c1, &r, &g, &b );
+	decode_colors[4] = r;
+	decode_colors[5] = g;
+	decode_colors[6] = b;
+	decode_colors[7] = 255;
+	if( c0 > c1 )
+	{
+		//	no alpha, 2 interpolated colors
+		decode_colors[8] = (2*decode_colors[0] + decode_colors[4]) / 3;
+		decode_colors[9] = (2*decode_colors[1] + decode_colors[5]) / 3;
+		decode_colors[10] = (2*decode_colors[2] + decode_colors[6]) / 3;
+		decode_colors[11] = 255;
+		decode_colors[12] = (decode_colors[0] + 2*decode_colors[4]) / 3;
+		decode_colors[13] = (decode_colors[1] + 2*decode_colors[5]) / 3;
+		decode_colors[14] = (decode_colors[2] + 2*decode_colors[6]) / 3;
+		decode_colors[15] = 255;
+	} else
+	{
+		//	1 interpolated color, alpha
+		decode_colors[8] = (decode_colors[0] + decode_colors[4]) / 2;
+		decode_colors[9] = (decode_colors[1] + decode_colors[5]) / 2;
+		decode_colors[10] = (decode_colors[2] + decode_colors[6]) / 2;
+		decode_colors[11] = 255;
+		decode_colors[12] = 0;
+		decode_colors[13] = 0;
+		decode_colors[14] = 0;
+		decode_colors[15] = 0;
+	}
+	//	decode the block
+	for( i = 0; i < 16*4; i += 4 )
+	{
+		int idx = ((compressed[next_bit>>3] >> (next_bit & 7)) & 3) * 4;
+		next_bit += 2;
+		uncompressed[i+0] = decode_colors[idx+0];
+		uncompressed[i+1] = decode_colors[idx+1];
+		uncompressed[i+2] = decode_colors[idx+2];
+		uncompressed[i+3] = decode_colors[idx+3];
+	}
+	//	done
+}
+void stbi_decode_DXT23_alpha_block(
+			unsigned char uncompressed[16*4],
+			unsigned char compressed[8] )
+{
+	int i, next_bit = 0;
+	//	each alpha value gets 4 bits
+	for( i = 3; i < 16*4; i += 4 )
+	{
+		uncompressed[i] = stbi_convert_bit_range(
+				(compressed[next_bit>>3] >> (next_bit&7)) & 15,
+				4, 8 );
+		next_bit += 4;
+	}
+}
+void stbi_decode_DXT45_alpha_block(
+			unsigned char uncompressed[16*4],
+			unsigned char compressed[8] )
+{
+	int i, next_bit = 8*2;
+	unsigned char decode_alpha[8];
+	//	each alpha value gets 3 bits, and the 1st 2 bytes are the range
+	decode_alpha[0] = compressed[0];
+	decode_alpha[1] = compressed[1];
+	if( decode_alpha[0] > decode_alpha[1] )
+	{
+		//	6 step intermediate
+		decode_alpha[2] = (6*decode_alpha[0] + 1*decode_alpha[1]) / 7;
+		decode_alpha[3] = (5*decode_alpha[0] + 2*decode_alpha[1]) / 7;
+		decode_alpha[4] = (4*decode_alpha[0] + 3*decode_alpha[1]) / 7;
+		decode_alpha[5] = (3*decode_alpha[0] + 4*decode_alpha[1]) / 7;
+		decode_alpha[6] = (2*decode_alpha[0] + 5*decode_alpha[1]) / 7;
+		decode_alpha[7] = (1*decode_alpha[0] + 6*decode_alpha[1]) / 7;
+	} else
+	{
+		//	4 step intermediate, pluss full and none
+		decode_alpha[2] = (4*decode_alpha[0] + 1*decode_alpha[1]) / 5;
+		decode_alpha[3] = (3*decode_alpha[0] + 2*decode_alpha[1]) / 5;
+		decode_alpha[4] = (2*decode_alpha[0] + 3*decode_alpha[1]) / 5;
+		decode_alpha[5] = (1*decode_alpha[0] + 4*decode_alpha[1]) / 5;
+		decode_alpha[6] = 0;
+		decode_alpha[7] = 255;
+	}
+	for( i = 3; i < 16*4; i += 4 )
+	{
+		int idx = 0, bit;
+		bit = (compressed[next_bit>>3] >> (next_bit&7)) & 1;
+		idx += bit << 0;
+		++next_bit;
+		bit = (compressed[next_bit>>3] >> (next_bit&7)) & 1;
+		idx += bit << 1;
+		++next_bit;
+		bit = (compressed[next_bit>>3] >> (next_bit&7)) & 1;
+		idx += bit << 2;
+		++next_bit;
+		uncompressed[i] = decode_alpha[idx & 7];
+	}
+	//	done
+}
+void stbi_decode_DXT_color_block(
+			unsigned char uncompressed[16*4],
+			unsigned char compressed[8] )
+{
+	int next_bit = 4*8;
+	int i, r, g, b;
+	int c0, c1;
+	unsigned char decode_colors[4*3];
+	//	find the 2 primary colors
+	c0 = compressed[0] + (compressed[1] << 8);
+	c1 = compressed[2] + (compressed[3] << 8);
+	stbi_rgb_888_from_565( c0, &r, &g, &b );
+	decode_colors[0] = r;
+	decode_colors[1] = g;
+	decode_colors[2] = b;
+	stbi_rgb_888_from_565( c1, &r, &g, &b );
+	decode_colors[3] = r;
+	decode_colors[4] = g;
+	decode_colors[5] = b;
+	//	Like DXT1, but no choicees:
+	//	no alpha, 2 interpolated colors
+	decode_colors[6] = (2*decode_colors[0] + decode_colors[3]) / 3;
+	decode_colors[7] = (2*decode_colors[1] + decode_colors[4]) / 3;
+	decode_colors[8] = (2*decode_colors[2] + decode_colors[5]) / 3;
+	decode_colors[9] = (decode_colors[0] + 2*decode_colors[3]) / 3;
+	decode_colors[10] = (decode_colors[1] + 2*decode_colors[4]) / 3;
+	decode_colors[11] = (decode_colors[2] + 2*decode_colors[5]) / 3;
+	//	decode the block
+	for( i = 0; i < 16*4; i += 4 )
+	{
+		int idx = ((compressed[next_bit>>3] >> (next_bit & 7)) & 3) * 3;
+		next_bit += 2;
+		uncompressed[i+0] = decode_colors[idx+0];
+		uncompressed[i+1] = decode_colors[idx+1];
+		uncompressed[i+2] = decode_colors[idx+2];
+	}
+	//	done
+}
+static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+	//	all variables go up front
+	stbi_uc *dds_data = NULL;
+	stbi_uc block[16*4];
+	stbi_uc compressed[8];
+	int flags, DXT_family;
+	int has_alpha, has_mipmap;
+	int is_compressed, cubemap_faces;
+	int block_pitch, num_blocks;
+	DDS_header header;
+	int i, sz, cf;
+	//	load the header
+	if( sizeof( DDS_header ) != 128 )
+	{
+		return NULL;
+	}
+	getn( s, (stbi_uc*)(&header), 128 );
+	//	and do some checking
+	if( header.dwMagic != (('D' << 0) | ('D' << 8) | ('S' << 16) | (' ' << 24)) ) return NULL;
+	if( header.dwSize != 124 ) return NULL;
+	flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+	if( (header.dwFlags & flags) != flags ) return NULL;
+	/*	According to the MSDN spec, the dwFlags should contain
+		DDSD_LINEARSIZE if it's compressed, or DDSD_PITCH if
+		uncompressed.  Some DDS writers do not conform to the
+		spec, so I need to make my reader more tolerant	*/
+	if( header.sPixelFormat.dwSize != 32 ) return NULL;
+	flags = DDPF_FOURCC | DDPF_RGB;
+	if( (header.sPixelFormat.dwFlags & flags) == 0 ) return NULL;
+	if( (header.sCaps.dwCaps1 & DDSCAPS_TEXTURE) == 0 ) return NULL;
+	//	get the image data
+	s->img_x = header.dwWidth;
+	s->img_y = header.dwHeight;
+	s->img_n = 4;
+	is_compressed = (header.sPixelFormat.dwFlags & DDPF_FOURCC) / DDPF_FOURCC;
+	has_alpha = (header.sPixelFormat.dwFlags & DDPF_ALPHAPIXELS) / DDPF_ALPHAPIXELS;
+	has_mipmap = (header.sCaps.dwCaps1 & DDSCAPS_MIPMAP) && (header.dwMipMapCount > 1);
+	cubemap_faces = (header.sCaps.dwCaps2 & DDSCAPS2_CUBEMAP) / DDSCAPS2_CUBEMAP;
+	/*	I need cubemaps to have square faces	*/
+	cubemap_faces &= (s->img_x == s->img_y);
+	cubemap_faces *= 5;
+	cubemap_faces += 1;
+	block_pitch = (s->img_x+3) >> 2;
+	num_blocks = block_pitch * ((s->img_y+3) >> 2);
+	/*	let the user know what's going on	*/
+	*x = s->img_x;
+	*y = s->img_y;
+	*comp = s->img_n;
+	/*	is this uncompressed?	*/
+	if( is_compressed )
+	{
+		/*	compressed	*/
+		//	note: header.sPixelFormat.dwFourCC is something like (('D'<<0)|('X'<<8)|('T'<<16)|('1'<<24))
+		DXT_family = 1 + (header.sPixelFormat.dwFourCC >> 24) - '1';
+		if( (DXT_family < 1) || (DXT_family > 5) ) return NULL;
+		/*	check the expected size...oops, nevermind...
+			those non-compliant writers leave
+			dwPitchOrLinearSize == 0	*/
+		//	passed all the tests, get the RAM for decoding
+		sz = (s->img_x)*(s->img_y)*4*cubemap_faces;
+		dds_data = (unsigned char*)malloc( sz );
+		/*	do this once for each face	*/
+		for( cf = 0; cf < cubemap_faces; ++ cf )
+		{
+			//	now read and decode all the blocks
+			for( i = 0; i < num_blocks; ++i )
+			{
+				//	where are we?
+				int bx, by, bw=4, bh=4;
+				int ref_x = 4 * (i % block_pitch);
+				int ref_y = 4 * (i / block_pitch);
+				//	get the next block's worth of compressed data, and decompress it
+				if( DXT_family == 1 )
+				{
+					//	DXT1
+					getn( s, compressed, 8 );
+					stbi_decode_DXT1_block( block, compressed );
+				} else if( DXT_family < 4 )
+				{
+					//	DXT2/3
+					getn( s, compressed, 8 );
+					stbi_decode_DXT23_alpha_block ( block, compressed );
+					getn( s, compressed, 8 );
+					stbi_decode_DXT_color_block ( block, compressed );
+				} else
+				{
+					//	DXT4/5
+					getn( s, compressed, 8 );
+					stbi_decode_DXT45_alpha_block ( block, compressed );
+					getn( s, compressed, 8 );
+					stbi_decode_DXT_color_block ( block, compressed );
+				}
+				//	is this a partial block?
+				if( ref_x + 4 > s->img_x )
+				{
+					bw = s->img_x - ref_x;
+				}
+				if( ref_y + 4 > s->img_y )
+				{
+					bh = s->img_y - ref_y;
+				}
+				//	now drop our decompressed data into the buffer
+				for( by = 0; by < bh; ++by )
+				{
+					int idx = 4*((ref_y+by+cf*s->img_x)*s->img_x + ref_x);
+					for( bx = 0; bx < bw*4; ++bx )
+					{
+
+						dds_data[idx+bx] = block[by*16+bx];
+					}
+				}
+			}
+			/*	done reading and decoding the main image...
+				skip MIPmaps if present	*/
+			if( has_mipmap )
+			{
+				int block_size = 16;
+				if( DXT_family == 1 )
+				{
+					block_size = 8;
+				}
+				for( i = 1; i < header.dwMipMapCount; ++i )
+				{
+					int mx = s->img_x >> (i + 2);
+					int my = s->img_y >> (i + 2);
+					if( mx < 1 )
+					{
+						mx = 1;
+					}
+					if( my < 1 )
+					{
+						my = 1;
+					}
+					skip( s, mx*my*block_size );
+				}
+			}
+		}/* per cubemap face */
+	} else
+	{
+		/*	uncompressed	*/
+		DXT_family = 0;
+		s->img_n = 3;
+		if( has_alpha )
+		{
+			s->img_n = 4;
+		}
+		*comp = s->img_n;
+		sz = s->img_x*s->img_y*s->img_n*cubemap_faces;
+		dds_data = (unsigned char*)malloc( sz );
+		/*	do this once for each face	*/
+		for( cf = 0; cf < cubemap_faces; ++ cf )
+		{
+			/*	read the main image for this face	*/
+			getn( s, &dds_data[cf*s->img_x*s->img_y*s->img_n], s->img_x*s->img_y*s->img_n );
+			/*	done reading and decoding the main image...
+				skip MIPmaps if present	*/
+			if( has_mipmap )
+			{
+				for( i = 1; i < header.dwMipMapCount; ++i )
+				{
+					int mx = s->img_x >> i;
+					int my = s->img_y >> i;
+					if( mx < 1 )
+					{
+						mx = 1;
+					}
+					if( my < 1 )
+					{
+						my = 1;
+					}
+					skip( s, mx*my*s->img_n );
+				}
+			}
+		}
+		/*	data was BGR, I need it RGB	*/
+		for( i = 0; i < sz; i += s->img_n )
+		{
+			unsigned char temp = dds_data[i];
+			dds_data[i] = dds_data[i+2];
+			dds_data[i+2] = temp;
+		}
+	}
+	/*	finished decompressing into RGBA,
+		adjust the y size if we have a cubemap
+		note: sz is already up to date	*/
+	s->img_y *= cubemap_faces;
+	*y = s->img_y;
+	//	did the user want something else, or
+	//	see if all the alpha values are 255 (i.e. no transparency)
+	has_alpha = 0;
+	if( s->img_n == 4)
+	{
+		for( i = 3; (i < sz) && (has_alpha == 0); i += 4 )
+		{
+			has_alpha |= (dds_data[i] < 255);
+		}
+	}
+	if( (req_comp <= 4) && (req_comp >= 1) )
+	{
+		//	user has some requirements, meet them
+		if( req_comp != s->img_n )
+		{
+			dds_data = convert_format( dds_data, s->img_n, req_comp, s->img_x, s->img_y );
+			*comp = s->img_n;
+		}
+	} else
+	{
+		//	user had no requirements, only drop to RGB is no alpha
+		if( (has_alpha == 0) && (s->img_n == 4) )
+		{
+			dds_data = convert_format( dds_data, 4, 3, s->img_x, s->img_y );
+			*comp = 3;
+		}
+	}
+	//	OK, done
+	return dds_data;
+}
+
+#ifndef STBI_NO_STDIO
+stbi_uc *stbi_dds_load_from_file   (FILE *f,                  int *x, int *y, int *comp, int req_comp)
+{
+	stbi s;
+   start_file(&s,f);
+   return dds_load(&s,x,y,comp,req_comp);
+}
+
+stbi_uc *stbi_dds_load             (char *filename,           int *x, int *y, int *comp, int req_comp)
+{
+   stbi_uc *data;
+   FILE *f = fopen(filename, "rb");
+   if (!f) return NULL;
+   data = stbi_dds_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return data;
+}
+#endif
+
+stbi_uc *stbi_dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+	stbi s;
+   start_mem(&s,buffer, len);
+   return dds_load(&s,x,y,comp,req_comp);
+}

GrafikaProjekt/pliki/src/Texture.cpp

@@ -3,50 +3,29 @@
 #include <fstream> 
 #include <iterator>
 #include <vector>
-#include "picopng.h"
+#include "SOIL/SOIL.h"
-#include "stb_image.h"
 
 typedef unsigned char byte;
 
-
+GLuint Core::LoadTexture( const char * filepath )
-GLuint Core::LoadTexture(const char* filename)
 {
-    //std::string path = std::string(filename);
+	GLuint id;
+	glGenTextures(1, &id);
+	glBindTexture(GL_TEXTURE_2D, id);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
-    unsigned int textureID;
+	int w, h;
-    glGenTextures(1, &textureID);
+	unsigned char* image = SOIL_load_image(filepath, &w, &h, 0, SOIL_LOAD_RGBA);
 	
-    int width, height, nrComponents;
-    stbi_set_flip_vertically_on_load(true);
-    unsigned char* data = stbi_load(filename, &width, &height, &nrComponents, 0);
-    if (data)
-    {
-        GLenum format;
-        if (nrComponents == 1)
-            format = GL_RED;
-        else if (nrComponents == 3)
-            format = GL_RGB;
-        else if (nrComponents == 4)
-            format = GL_RGBA;
 
-        glBindTexture(GL_TEXTURE_2D, textureID);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
-        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
+	glGenerateMipmap(GL_TEXTURE_2D);
-        glGenerateMipmap(GL_TEXTURE_2D);
+	SOIL_free_image_data(image);
 
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	return id;
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-        stbi_image_free(data);
-    }
-    else
-    {
-        std::cout << "Texture failed to load at path: " << filename << std::endl;
-        stbi_image_free(data);
-    }
-
-    return textureID;
 }
 
 void Core::SetActiveTexture(GLuint textureID, const char * shaderVariableName, GLuint programID, int textureUnit)

GrafikaProjekt/pliki/src/Texture.h

@@ -2,8 +2,6 @@
  
 #include "glew.h"
 #include "freeglut.h"
-#include <string>
-#include <iostream>
 
 namespace Core
 {

GrafikaProjekt/pliki/src/main.cpp

@@ -1,100 +1,45 @@
-#define STB_IMAGE_IMPLEMENTATION
-
 #include "glew.h"
 #include "freeglut.h"
 #include "glm.hpp"
-#include "gtx/matrix_decompose.hpp"
 #include "ext.hpp"
 #include <iostream>
 #include <cmath>
-#include <ctime>
+#include <vector>
 
 #include "Shader_Loader.h"
 #include "Render_Utils.h"
 #include "Camera.h"
-
-
-#include "Box.cpp"
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-//#include <assimp/pbrmaterial.h>
-
-#include "stb_image.h"
 #include "Texture.h"
 
-//obliczyc kwateriony nastepnie interpolowac.
+GLuint programColor;
-
-
-std::vector<glm::vec3> keyPoints({
-glm::vec3(-711.745f, 89.9272f, -626.537f),
-//glm::vec3(-711.745f, 91.9272f, -606.537f),
-glm::vec3(-687.635f, 100.428f, -503.943f),
-//glm::vec3(-721.365f, 103.613f, -598.223f),
-glm::vec3(-667.635f, 128.428f, -433.943f),
-glm::vec3(-547.654f, 180.445f, -401.846f),
-glm::vec3(-365.357f, 261.268f, -304.93f),
-glm::vec3(-346.51f, 146.605f, -85.3702f),
-glm::vec3(-461.105f, 120.275f, 115.596f),
-glm::vec3(-507.395f, 76.497f, 338.408f),
-glm::vec3(-181.343f, 58.7994f, 403.918f),
-glm::vec3(-148.073f, 72.7797f, 522.283f),
-glm::vec3(-76.8437f, 85.1488f, 524.396f),
-glm::vec3(-30.0008f, 81.3007f, 367.907f),
-glm::vec3(20.808f, 117.73f, 109.607f),
-glm::vec3(8.72873f, 135.983f, -130.435f),
-glm::vec3(8.72873f, 115.983f, -132.435f),
-glm::vec3(8.72873f, 104.983f, -132.435f),
-glm::vec3(8.72873f, 100.983f, -132.435f),
-	});
-
-std::vector<glm::quat> keyRotation;
-
-int index = 0;
-bool FOLLOW_CAR = false;
-
-GLuint program;
-GLuint programTextureSpecular;
 GLuint programTexture;
-GLuint programSun;
+
 Core::Shader_Loader shaderLoader;
 
+Core::RenderContext shipContext;
+Core::RenderContext sphereContext;
 
-
+glm::vec3 cameraPos = glm::vec3(0, 0, 5);
-Core::RenderContext armContext;
+glm::vec3 cameraDir; // Wektor "do przodu" kamery
-
+glm::vec3 cameraSide; // Wektor "w bok" kamery
-
-std::vector<Core::RenderContext> armContexts;
-
-std::vector<Core::Node> city;
-
-std::vector<Core::Node> car;
-
-
 float cameraAngle = 0;
-glm::vec3 cameraSide;
+
-glm::vec3 cameraDir;
+int lastMouseX, lastMouseY, mouseX, mouseY;
-glm::vec3 cameraPos = keyPoints[0] + glm::vec3(0, 10, -5);
 
 glm::mat4 cameraMatrix, perspectiveMatrix;
 
+glm::vec3 lightDir = glm::normalize(glm::vec3(1.0f, -0.9f, -1.0f));
 
+glm::quat rotation = glm::quat(1, 0, 0, 0);
 
-float old_x, old_y = -1;
+GLuint textureAsteroid;
-float delta_x, delta_y = 0;
-glm::quat rotationCamera = glm::quat(1, 0, 0, 0);
-//glm::quat rotation_y;
-//glm::quat rotation_x;// = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 1, 0));
-glm::quat rotation_y = glm::normalize(glm::angleAxis(209 * 0.03f, glm::vec3(1, 0, 0)));
-glm::quat rotation_x = glm::normalize(glm::angleAxis(307 * 0.03f, glm::vec3(0, 1, 0)));
-float dy = 0;
-float dx = 0;
 
 void keyboard(unsigned char key, int x, int y)
 {
-	float angleSpeed = 0.5f;
+	
-	float moveSpeed = 2.f;
+	float angleSpeed = 0.1f;
-	switch (key)
+	float moveSpeed = 0.1f;
+	switch(key)
 	{
 	case 'z': cameraAngle -= angleSpeed; break;
 	case 'x': cameraAngle += angleSpeed; break;
@@ -102,306 +47,107 @@ void keyboard(unsigned char key, int x, int y)
 	case 's': cameraPos -= cameraDir * moveSpeed; break;
 	case 'd': cameraPos += cameraSide * moveSpeed; break;
 	case 'a': cameraPos -= cameraSide * moveSpeed; break;
-	case '0': cameraPos = keyPoints[0] + glm::vec3(0, 3, 0); index = 0; break;
-	case 'e': index = (index + 1) % keyPoints.size(); cameraPos = keyPoints[index] + glm::vec3(-3, 20, -3);  break;
-	case 'q': index = (keyPoints.size() + index - 1) % keyPoints.size(); cameraPos = keyPoints[index] + glm::vec3(-3, 20, -3);  break;
-	case '1': FOLLOW_CAR = !FOLLOW_CAR;  break;
-	case 'r': cameraPos = glm::vec3(0,0,1); break;
 	}
 }
 
-glm::vec3 lightDir = glm::normalize(glm::vec3(1, 1, 1));
-
-
 void mouse(int x, int y)
 {
-	if (old_x >= 0) {
+	mouseX = lastMouseX - x;
-		delta_x = x - old_x;
+	mouseY = lastMouseY - y;
-		delta_y = y - old_y;
+	lastMouseX = x;
-	}
+	lastMouseY = y;
-	old_x = x;
-	old_y = y;
 }
 
-
 glm::mat4 createCameraMatrix()
 {
-	auto rot_y = glm::angleAxis(delta_y * 0.03f, glm::vec3(1, 0, 0));
+	rotation = glm::normalize(rotation * glm::angleAxis((float)(mouseX * 0.01), cameraDir) * glm::angleAxis((float)(mouseY * 0.01), cameraSide));
-	auto rot_x = glm::angleAxis(delta_x * 0.03f, glm::vec3(0, 1, 0));
+	mouseX = mouseY = 0;
-
+	cameraDir = glm::inverse(rotation) * glm::vec3(0, 0, -1);
-	dy += delta_y;
+	cameraSide = glm::inverse(rotation) * glm::vec3(-1, 0, 0);
-	dx += delta_x;
+	return Core::createViewMatrixQuat(cameraPos, rotation);
-	delta_x = 0;
-	delta_y = 0;
-
-	rotation_x = glm::normalize(rot_x * rotation_x);
-	rotation_y = glm::normalize(rot_y * rotation_y);
-
-	rotationCamera = glm::normalize(rotation_y * rotation_x);
-
-	auto inverse_rot = glm::inverse(rotationCamera);
-
-	cameraDir = inverse_rot * glm::vec3(0, 0, -1);
-	glm::vec3 up = glm::vec3(0, 1, 0);
-	cameraSide = inverse_rot * glm::vec3(1, 0, 0);
-
-	glm::mat4 cameraTranslation;
-	cameraTranslation[3] = glm::vec4(-cameraPos, 1.0f);
-
-	return glm::mat4_cast(rotationCamera) * cameraTranslation;
-}
-glm::mat4 animationMatrix(float time) {
-	float speed = 1.;
-	time = time * speed;
-	std::vector<float> distances;
-	float timeStep = 0;
-	for (int i = 0; i < keyPoints.size() - 1; i++) {
-		timeStep += (keyPoints[i] - keyPoints[i + 1]).length();
-		distances.push_back((keyPoints[i] - keyPoints[i + 1]).length());
-	}
-	time = fmod(time, timeStep);
-
-	//index of first keyPoint
-	int index = 0;
-
-	while (distances[index] <= time) {
-		time = time - distances[index];
-		index += 1;
-	}
-
-	//t coefitient between 0 and 1 for interpolation
-	float t = time / distances[index];
-
-	int size = keyPoints.size()-1;
-	//replace with catmul rom	
-	glm::vec3 pos = (keyPoints[std::max(0, index)] * t + keyPoints[std::min(size, index + 1)] * (1 - t));
-	
-
-	//implement corect animation
-	auto animationRotation = glm::quat(1,0,0,0);
-
-	glm::mat4 result = glm::translate(pos) * glm::mat4_cast(animationRotation);
-
-
-	return result;
-
 }
 
-
+void drawObjectColor(Core::RenderContext context, glm::mat4 modelMatrix, glm::vec3 color)
-void drawObject(GLuint program, Core::RenderContext context, glm::mat4 modelMatrix)
 {
+	GLuint program = programColor;
+
+	glUseProgram(program);
+
+	glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z);
+	glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
+
 	glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
-
+	glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
-
 	glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
-	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transformation);
+
-	context.render();
+	Core::DrawContext(context);
+
+	glUseProgram(0);
 }
 
-void renderRecursive(std::vector<Core::Node>& nodes) {
+void drawObjectTexture(Core::RenderContext context, glm::mat4 modelMatrix, GLuint textureId)
-	for (auto node : nodes) {
+{
-		if (node.renderContexts.size() == 0) {
+	GLuint program = programTexture;
-			continue;
-		}
 
-		glm::mat4 transformation = node.matrix;//glm::mat4();
+	glUseProgram(program);
-		auto currentNode = node;
-		while (currentNode.parent != -1) {
-			transformation *= currentNode.matrix;
-			currentNode = nodes[currentNode.parent];
-		}
-		// dodaj odwolania do nadrzednych zmiennych
-		for (auto context : node.renderContexts) {
-			auto program = context.material->program;
-			glUseProgram(program);
-			glUniform3f(glGetUniformLocation(program, "cameraPos"), cameraPos.x, cameraPos.y, cameraPos.z);
-			context.material->init_data();
-			drawObject(program, context, transformation);
-		}
-	}
 
+	glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
+	Core::SetActiveTexture(textureId, "textureSampler", program, 0);
+
+	glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
+	glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
+	glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
+
+	Core::DrawContext(context);
+
+	glUseProgram(0);
 }
-
-glm::mat4 followCarCamera(float time) {
-	glm::quat rotation_y = glm::normalize(glm::angleAxis(209 * 0.03f, glm::vec3(1, 0, 0)));
-	glm::quat rotation_x = glm::normalize(glm::angleAxis(3.14f, glm::vec3(0, 1, 0)));
-	auto pos = glm::vec3(2, 3, 8);
-	cameraPos = animationMatrix(time) * glm::vec4(pos, 1);
-	auto transformation = animationMatrix(time);
-	glm::vec3 scale;
-	glm::quat rrotation;
-	glm::vec3 translation;
-	glm::vec3 skew;
-	glm::vec4 perspective;
-	glm::decompose(transformation, scale, rrotation, translation, skew, perspective);
-
-	return glm::translate(-pos) * glm::mat4_cast(rotation_y * rotation_x) * glm::inverse(transformation);
-
-}
-
 void renderScene()
 {
-	// Aktualizacja macierzy widoku i rzutowania. Macierze sa przechowywane w zmiennych globalnych, bo uzywa ich funkcja drawObject.
+	// Aktualizacja macierzy widoku i rzutowania
-	// (Bardziej elegancko byloby przekazac je jako argumenty do funkcji, ale robimy tak dla uproszczenia kodu.
-	//  Jest to mozliwe dzieki temu, ze macierze widoku i rzutowania sa takie same dla wszystkich obiektow!)
 	cameraMatrix = createCameraMatrix();
-	perspectiveMatrix = Core::createPerspectiveMatrix(0.1, 2000);
+	perspectiveMatrix = Core::createPerspectiveMatrix();
-	float time = glutGet(GLUT_ELAPSED_TIME) / 1000.f;
 
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	glClearColor(0.0f, 0.03f, 0.1f, 1.0f);
+	glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
 
+	glm::mat4 shipInitialTransformation = glm::translate(glm::vec3(0,-0.25f,0)) * glm::rotate(glm::radians(180.0f), glm::vec3(0,1,0)) * glm::scale(glm::vec3(0.25f));
+	glm::mat4 shipModelMatrix = glm::translate(cameraPos + cameraDir * 0.5f) * glm::mat4_cast(glm::inverse(rotation)) * shipInitialTransformation;
+	drawObjectColor(shipContext, shipModelMatrix, glm::vec3(0.6f));
 
+	drawObjectTexture(sphereContext, glm::translate(glm::vec3(0,0,0)), textureAsteroid);
 
-
-
-	if (FOLLOW_CAR) {
-		cameraMatrix = followCarCamera(time);
-	}
-
-	renderRecursive(city);
-	for (int i = 0; i < 30; i++) {
-		if (time > -10) {
-			car[0].matrix = animationMatrix(time + 15);;
-			renderRecursive(car);
-			time -= 3;
-		}
-	}
-	glUseProgram(0);
 	glutSwapBuffers();
 }
 
+void loadModelToContext(std::string path, Core::RenderContext& context)
+{
+	Assimp::Importer import;
+	const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_CalcTangentSpace);
 
-
+	if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
-
-Core::Material* loadDiffuseMaterial(aiMaterial* material) {
-	aiString colorPath;
-	// use for loading textures
-
-	material->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), colorPath);
-	if (colorPath == aiString("")) {
-		return nullptr;
-	}
-	Core::DiffuseMaterial* result = new Core::DiffuseMaterial();
-	result->texture = Core::LoadTexture(colorPath.C_Str());
-	result->program = programTexture;
-	result->lightDir = lightDir;
-
-	return result;
-}
-
-
-Core::Material* loadDiffuseSpecularMaterial(aiMaterial* material) {
-	aiString colorPath;
-	// use for loading textures
-
-	material->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), colorPath);
-	Core::DiffuseSpecularMaterial* result = new Core::DiffuseSpecularMaterial();
-	result->texture = Core::LoadTexture(colorPath.C_Str());
-
-
-	aiString specularPath;
-	material->Get(AI_MATKEY_TEXTURE(aiTextureType_SPECULAR, 0), specularPath);
-	result->textureSpecular = Core::LoadTexture(specularPath.C_Str());
-	result->lightDir = lightDir;
-	result->program = programTextureSpecular;
-
-	return result;
-}
-
-
-void loadRecusive(const aiScene* scene, aiNode* node, std::vector<Core::Node>& nodes, std::vector<Core::Material*> materialsVector, int parentIndex) {
-	int index = nodes.size();
-	nodes.push_back(Core::Node());
-	nodes[index].parent = parentIndex;
-	nodes[index].matrix = Core::mat4_cast(node->mTransformation);
-	for (int i = 0; i < node->mNumMeshes; i++) {
-		Core::RenderContext context;
-		context.initFromAssimpMesh(scene->mMeshes[node->mMeshes[i]]);
-		context.material = materialsVector[scene->mMeshes[node->mMeshes[i]]->mMaterialIndex];
-		nodes[index].renderContexts.push_back(context);
-	}
-	for (int i = 0; i < node->mNumChildren; i++) {
-		loadRecusive(scene, node->mChildren[i], nodes, materialsVector, index);
-	}
-}
-void loadRecusive(const aiScene* scene, std::vector<Core::Node>& nodes, std::vector<Core::Material*> materialsVector) {
-
-	loadRecusive(scene, scene->mRootNode, nodes, materialsVector, -1);
-}
-
-void initModels() {
-	Assimp::Importer importer;
-	//replace to get more buildings, unrecomdnded
-	//const aiScene* scene = importer.ReadFile("models/blade-runner-style-cityscapes.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
-	const aiScene* scene = importer.ReadFile("models/city_small.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
-	// check for errors
-	if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
 	{
-		std::cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << std::endl;
+		std::cout << "ERROR::ASSIMP::" << import.GetErrorString() << std::endl;
 		return;
 	}
-
+	context.initFromAssimpMesh(scene->mMeshes[0]);
-
-
-	std::vector<Core::Material*> materialsVector;
-
-	for (int i = 0; i < scene->mNumMaterials; i++) {
-		materialsVector.push_back(loadDiffuseSpecularMaterial(scene->mMaterials[i]));
-	}
-	loadRecusive(scene, city, materialsVector);
-
-
-	scene = importer.ReadFile("models/flying_car.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
-
-
-	// check for errors
-	if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
-	{
-		std::cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << std::endl;
-		return;
-	}
-	materialsVector.clear();
-
-	for (int i = 0; i < scene->mNumMaterials; i++) {
-		materialsVector.push_back(loadDiffuseMaterial(scene->mMaterials[i]));
-	}
-	loadRecusive(scene, car, materialsVector);
-
-
-	//Recovering points from fbx
-	//const aiScene* points = importer.ReadFile("models/path.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
-
-	//auto root = points->mRootNode;
-
-	//for (int i = 0; i < root->mNumChildren; i++) {
-	//	auto node = root->mChildren[i];
-	//	std::cout << "glm::vec3(" << node->mTransformation.a4 << "f, " << node->mTransformation.b4 << "f, " << node->mTransformation.c4 << "f), " << std::endl;
-	//	//std::cout << node->mName.C_Str() << std::endl;
-	//}
-}
-
-void initKeyRoation() {
 }
 
 void init()
 {
-
+	srand(time(0));
 	glEnable(GL_DEPTH_TEST);
-	program = shaderLoader.CreateProgram("shaders/shader_4_1.vert", "shaders/shader_4_1.frag");
+	programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag");
-	programTextureSpecular = shaderLoader.CreateProgram("shaders/shader_spec_tex.vert", "shaders/shader_spec_tex.frag");
+	programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag");
-	programTexture = shaderLoader.CreateProgram("shaders/shader_tex_2.vert", "shaders/shader_tex_2.frag");
+	loadModelToContext("models/spaceship.obj", shipContext);
-	programSun = shaderLoader.CreateProgram("shaders/shader_4_sun.vert", "shaders/shader_4_sun.frag");
+	loadModelToContext("models/sphere.obj", sphereContext);
-
+	textureAsteroid = Core::LoadTexture("textures/asteroid.png");
-	initModels();
-
-	initKeyRoation();
-
 }
 
 void shutdown()
 {
-	shaderLoader.DeleteProgram(program);
+	shaderLoader.DeleteProgram(programColor);
+	shaderLoader.DeleteProgram(programTexture);
 }
 
 void idle()
@@ -409,19 +155,18 @@ void idle()
 	glutPostRedisplay();
 }
 
-int main(int argc, char** argv)
+int main(int argc, char ** argv)
 {
 	glutInit(&argc, argv);
-	glutSetOption(GLUT_MULTISAMPLE, 4);
+	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
-	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE);
+	glutInitWindowPosition(200, 200);
-	glutInitWindowPosition(200, 300);
+	glutInitWindowSize(600, 600);
-	glutInitWindowSize(800, 800);
 	glutCreateWindow("OpenGL Pierwszy Program");
 	glewInit();
 
 	init();
-	glutPassiveMotionFunc(mouse);
 	glutKeyboardFunc(keyboard);
+	glutPassiveMotionFunc(mouse);
 	glutDisplayFunc(renderScene);
 	glutIdleFunc(idle);
 

GrafikaProjekt/pliki/src/main_10_1.cpp

@@ -1,399 +0,0 @@
-#define STB_IMAGE_IMPLEMENTATION
-#define GLM_FORCE_SWIZZLE
-#define SHOW_RAY    
-#include "stb_image.h"
-
-
-#include "glew.h"
-#include "freeglut.h"
-#include "glm.hpp"
-#include "ext.hpp"
-#include <iostream>
-#include <cmath>
-#include <vector>
-
-#include "Shader_Loader.h"
-#include "Render_Utils.h"
-#include "Camera.h"
-#include "Texture.h"
-#include "Physics.h"
-
-
-bool DRAGING_ON = false;
-
-Core::Shader_Loader shaderLoader;
-GLuint programColor;
-GLuint programTexture, programRed;
-
-obj::Model planeModel, boxModel, sphereModel;
-Core::RenderContext planeContext, boxContext, sphereContext;
-Core::RayContext rayContext;
-GLuint boxTexture, groundTexture;
-
-glm::vec3 cameraPos = glm::vec3(0, 5, 20);
-glm::vec3 cameraDir;
-glm::vec3 cameraSide;
-float cameraAngle = 0;
-glm::mat4 cameraMatrix, perspectiveMatrix;
-
-glm::vec3 lightDir = glm::normalize(glm::vec3(0.5, -1, -0.5));
-
-
-// Initalization of physical scene (PhysX)
-Physics pxScene(9.8 /* gravity (m/s^2) */);
-
-// fixed timestep for stable and deterministic simulation
-const double physicsStepTime = 1.f / 60.f;
-double physicsTimeToProcess = 0;
-
-// physical objects
-PxRigidStatic *planeBody = nullptr;
-PxMaterial *planeMaterial = nullptr;
-std::vector<PxRigidDynamic*> boxBodies;
-PxMaterial *boxMaterial = nullptr;
-PxRigidDynamic *sphereBody = nullptr;
-PxMaterial *sphereMaterial = nullptr;
-
-struct GrabbedObject {
-    PxRigidDynamic* actor;
-    float distance;
-    PxVec3 newPos;
-    bool update = false;
-} grabbedObject;
-
-// renderable objects (description of a single renderable instance)
-struct Renderable {
-    Core::RenderContext *context;
-    glm::mat4 modelMatrix;
-    GLuint textureId;
-};
-std::vector<Renderable*> renderables;
-
-PxVec3 vec3ToPxVec(glm::vec3 vector) {
-    return PxVec3(vector.x, vector.y, vector.z);
-}
-glm::vec3 PxVecTovec3(PxVec3 vector) {
-    return glm::vec3(vector.x, vector.y, vector.z);
-}
-
-// number of rows and columns of boxes the wall consists of
-const int BOX_NUMBER = 10;
-
-void initRenderables()
-{
-    // load models
-    planeModel = obj::loadModelFromFile("models/plane.obj");
-    boxModel = obj::loadModelFromFile("models/box.obj");
-    sphereModel = obj::loadModelFromFile("models/sphere.obj");
-
-    planeContext.initFromOBJ(planeModel);
-    boxContext.initFromOBJ(boxModel);
-    sphereContext.initFromOBJ(sphereModel);
-
-
-    // load textures
-    groundTexture = Core::LoadTexture("textures/sand.jpg");
-    boxTexture = Core::LoadTexture("textures/a.jpg");
-
-    // create ground
-    Renderable *ground = new Renderable();
-    ground->context = &planeContext;
-    ground->textureId = groundTexture;
-    renderables.emplace_back(ground);
-
-    for (int i = 0; i < BOX_NUMBER; i++){
-				// create box
-				Renderable* box = new Renderable();
-				box->context = &boxContext;
-				box->textureId = boxTexture;
-				renderables.emplace_back(box);
-			
-    }
-
-}
-
-void initPhysicsScene()
-{
-    //-----------------------------------------------------------
-    // TASKS
-    //-----------------------------------------------------------
-    // IMPORTANT:
-    //   * to create objects use:     pxScene.physics
-    //   * to manage the scene use:   pxScene.scene
-
-	planeBody = pxScene.physics->createRigidStatic(PxTransformFromPlaneEquation(PxPlane(0, 1, 0, 0)));
-	planeMaterial = pxScene.physics->createMaterial(0.5, 0.3, 0.5);
-	PxShape* planeShape = pxScene.physics->createShape(PxPlaneGeometry(), *planeMaterial);
-	planeBody->attachShape(*planeShape);
-	planeShape->release();
-	planeBody->userData = (void*)renderables[0];
-	pxScene.scene->addActor(*planeBody);
-	boxMaterial = pxScene.physics->createMaterial(0.9, 0.5, 0.4);
-
-	for (int i = 0; i < BOX_NUMBER; i++) {
-        auto pos = glm::linearRand(glm::vec2(-8.f, -8.f), glm::vec2(8.f, 8.f));
-		auto x = pxScene.physics->createRigidDynamic(PxTransform(pos.x,3, pos.y));
-		boxBodies.push_back(x);
-		PxShape* boxShape = pxScene.physics->createShape(PxBoxGeometry(1, 1, 1), *boxMaterial);
-		x->attachShape(*boxShape);
-		boxShape->release();
-		x->userData = (void*)renderables[i + 1];
-		pxScene.scene->addActor(*x);
-	}
-
-}
-
-void updateTransforms()
-{
-    // Here we retrieve the current transforms of the objects from the physical simulation.
-    auto actorFlags = PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC;
-    PxU32 nbActors = pxScene.scene->getNbActors(actorFlags);
-    if (nbActors)
-    {
-        std::vector<PxRigidActor*> actors(nbActors);
-        pxScene.scene->getActors(actorFlags, (PxActor**)&actors[0], nbActors);
-        for (auto actor : actors)
-        {
-            // We use the userData of the objects to set up the model matrices
-            // of proper renderables.
-            if (!actor->userData) continue;
-            Renderable *renderable = (Renderable*)actor->userData;
-
-            // get world matrix of the object (actor)
-            PxMat44 transform = actor->getGlobalPose();
-            auto &c0 = transform.column0;
-            auto &c1 = transform.column1;
-            auto &c2 = transform.column2;
-            auto &c3 = transform.column3;
-
-            // set up the model matrix used for the rendering
-            renderable->modelMatrix = glm::mat4(
-                c0.x, c0.y, c0.z, c0.w,
-                c1.x, c1.y, c1.z, c1.w,
-                c2.x, c2.y, c2.z, c2.w,
-                c3.x, c3.y, c3.z, c3.w);
-        }
-    }
-}
-std::vector<glm::vec3> calculate_ray(float x, float y) {
-    glm::vec2 screen_space_pos(x, y);
-    std::vector<glm::vec3> result;
-
-    //here ray should be calculated
-
-    result.push_back(cameraPos);
-    result.push_back(cameraDir);
-    return result;
-}
-
-void keyboard(unsigned char key, int x, int y)
-{
-    float angleSpeed = 0.1f;
-    float moveSpeed = 0.1f;
-    switch (key)
-    {
-		case 'z': cameraAngle -= angleSpeed; break;
-		case 'x': cameraAngle += angleSpeed; break;
-		case 'w': cameraPos += cameraDir * moveSpeed; break;
-		case 's': cameraPos -= cameraDir * moveSpeed; break;
-		case 'd': cameraPos += cameraSide * moveSpeed; break;
-		case 'a': cameraPos -= cameraSide * moveSpeed; break;
-    }
-
-
-    int size_x = glutGet(GLUT_WINDOW_WIDTH);
-    int size_y = glutGet(GLUT_WINDOW_HEIGHT);
-    std::vector<glm::vec3> ray = calculate_ray((x / float(size_x) - 0.5) * 2, -((y / float(size_y)) - 0.5) * 2);
-    grabbedObject.newPos = vec3ToPxVec(ray[1]) * grabbedObject.distance + vec3ToPxVec(ray[0]);
-}
-
-
-void mouse(int x, int y)
-{
-
-    int size_x = glutGet(GLUT_WINDOW_WIDTH);
-    int size_y = glutGet(GLUT_WINDOW_HEIGHT);
-    std::vector<glm::vec3> ray = calculate_ray((x / float(size_x) - 0.5) * 2, -((y / float(size_y)) - 0.5) * 2);
-    Core::updateRayPos(rayContext, ray);
-    grabbedObject.newPos = vec3ToPxVec(ray[1]) * grabbedObject.distance + vec3ToPxVec(ray[0]);
-
-}
-void click_mouse(int button, int state, int x, int y) {
-    if ((GLUT_LEFT_BUTTON == button && state == GLUT_DOWN)) {
-
-        int size_x = glutGet(GLUT_WINDOW_WIDTH);
-        int size_y = glutGet(GLUT_WINDOW_HEIGHT);
-        std::vector<glm::vec3> ray = calculate_ray((x / float(size_x) - 0.5) * 2, -((y / float(size_y)) - 0.5) * 2);
-        Core::updateRayPos(rayContext, ray);
-
-        //here raycast should be done
-
-        //check if there is a hit
-        if (false) {
-
-            //check if it is rigid dynamic
-            if (false) {
-            }
-        }
-        else {
-            std::cout << "no hit\n";
-        }
-    }
-
-    if (GLUT_LEFT_BUTTON == button && state == GLUT_UP) {
-        DRAGING_ON = false;
-        grabbedObject.update = false;
-    }
-
-}
-
-
-
-glm::mat4 createCameraMatrix()
-{
-    cameraDir = glm::normalize(glm::vec3(cosf(cameraAngle - glm::radians(90.0f)), 0, sinf(cameraAngle - glm::radians(90.0f))));
-    glm::vec3 up = glm::vec3(0, 1, 0);
-    cameraSide = glm::cross(cameraDir, up);
-
-    return Core::createViewMatrix(cameraPos, cameraDir, up);
-}
-
-void drawObjectColor(Core::RenderContext* context, glm::mat4 modelMatrix, glm::vec3 color)
-{
-    GLuint program = programColor;
-
-    glUseProgram(program);
-
-    glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z);
-    glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
-
-    glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
-    glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
-    glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
-
-    context->render();
-
-    glUseProgram(0);
-}
-
-void drawRay(Core::RayContext& context) {
-    glUseProgram(programRed);
-
-    glm::mat4 transformation = perspectiveMatrix * cameraMatrix;
-    glUniformMatrix4fv(glGetUniformLocation(programRed, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
-    context.render();
-    glUseProgram(0);
-}
-
-void drawObjectTexture(Core::RenderContext * context, glm::mat4 modelMatrix, GLuint textureId)
-{
-    GLuint program = programTexture;
-
-    glUseProgram(program);
-
-    glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
-    Core::SetActiveTexture(textureId, "textureSampler", program, 0);
-
-    glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
-    glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
-    glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
-
-    context->render();
-    glUseProgram(0);
-}
-
-void renderScene()
-{
-    
-    if (grabbedObject.update) {
-        // Here should be grab object update
-    }
-
-    double time = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
-    static double prevTime = time;
-    double dtime = time - prevTime;
-    prevTime = time;
-
-    // Update physics
-    if (dtime < 1.f) {
-        physicsTimeToProcess += dtime;
-        while (physicsTimeToProcess > 0) {
-            // here we perform the physics simulation step
-            pxScene.step(physicsStepTime);
-            physicsTimeToProcess -= physicsStepTime;
-        }
-    }
-
-
-    // Update of camera and perspective matrices
-    cameraMatrix = createCameraMatrix();
-    perspectiveMatrix = Core::createPerspectiveMatrix();
-
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
-
-    // update transforms from physics simulation
-    updateTransforms();
-
-    // render models
-    for (Renderable* renderable : renderables) {
-        drawObjectTexture(renderable->context, renderable->modelMatrix, renderable->textureId);
-    }
-    #ifdef SHOW_RAY
-        drawRay(rayContext);
-    #endif // SHOW_RAY
-
-
-    glutSwapBuffers();
-}
-
-void init()
-{
-    srand(time(0));
-    glEnable(GL_DEPTH_TEST);
-    programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag");
-    programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag");
-    programRed = shaderLoader.CreateProgram("shaders/shader_red.vert", "shaders/shader_red.frag");
-
-
-    Core::initRay(rayContext);
-    auto ray = calculate_ray(0.5f,0.5f);
-    //Core::updateRayPos(rayContext, ray);
-
-    initRenderables();
-    initPhysicsScene();
-}
-
-void shutdown()
-{
-    shaderLoader.DeleteProgram(programColor);
-    shaderLoader.DeleteProgram(programTexture);
-}
-
-void idle()
-{
-    glutPostRedisplay();
-}
-
-int main(int argc, char ** argv)
-{
-    glutInit(&argc, argv);
-    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
-    glutInitWindowPosition(200, 200);
-    glutInitWindowSize(600, 600);
-    glutCreateWindow("OpenGL + PhysX");
-    glewInit();
-
-    init();
-    glutKeyboardFunc(keyboard);
-    glutMotionFunc(mouse);
-    glutMouseFunc(click_mouse);
-    glutDisplayFunc(renderScene);
-    glutIdleFunc(idle);
-
-    glutMainLoop();
-
-    shutdown();
-
-    return 0;
-}

GrafikaProjekt/pliki/src/mesh.h

@@ -1,140 +0,0 @@
-
-
-#ifndef MESH_H
-#define MESH_H
-
-#include "glew.h"
-#include "freeglut.h"
-#include "glm.hpp"
-#include "ext.hpp"
-#include <iostream>
-#include <cmath>
-
-#include <string>
-#include <vector>
-using namespace std;
-
-struct Vertex {
-    // position
-    glm::vec3 Position;
-    // normal
-    glm::vec3 Normal;
-    // texCoords
-    glm::vec2 TexCoords;
-    // tangent
-    glm::vec3 Tangent;
-    // bitangent
-    glm::vec3 Bitangent;
-};
-
-struct Texture {
-    unsigned int id;
-    string type;
-    string path;
-};
-
-class Mesh {
-public:
-    // mesh Data
-    vector<Vertex>       vertices;
-    vector<unsigned int> indices;
-    vector<Texture>      textures;
-    glm::mat4            matrix;
-    unsigned int VAO;
-
-    // constructor
-    Mesh(vector<Vertex> vertices, vector<unsigned int> indices, vector<Texture> textures,glm::mat4 matrix)
-    {
-        this->vertices = vertices;
-        this->indices = indices;
-        this->textures = textures;
-        this->matrix = matrix;
-
-        // now that we have all the required data, set the vertex buffers and its attribute pointers.
-        setupMesh();
-    }
-
-    // render the mesh
-    void Draw(GLuint program)
-    {
-        // bind appropriate textures
-        unsigned int diffuseNr = 1;
-        unsigned int specularNr = 1;
-        unsigned int normalNr = 1;
-        unsigned int heightNr = 1;
-        for (unsigned int i = 0; i < textures.size(); i++)
-        {
-            glActiveTexture(GL_TEXTURE0 + i); // active proper texture unit before binding
-            // retrieve texture number (the N in diffuse_textureN)
-            string number;
-            string name = textures[i].type;
-            if (name == "texture_diffuse")
-                number = std::to_string(diffuseNr++);
-            else if (name == "texture_specular")
-                number = std::to_string(specularNr++); // transfer unsigned int to stream
-            else if (name == "texture_normal")
-                number = std::to_string(normalNr++); // transfer unsigned int to stream
-            else if (name == "texture_height")
-                number = std::to_string(heightNr++); // transfer unsigned int to stream
-
-            // now set the sampler to the correct texture unit
-            glUniform1i(glGetUniformLocation(program, (name + number).c_str()), i);
-            // and finally bind the texture
-            glBindTexture(GL_TEXTURE_2D, textures[i].id);
-        }
-
-        glUniformMatrix4fv(glGetUniformLocation(program, "model"), 1, GL_FALSE, (float*)&matrix);
-        // draw mesh
-        glBindVertexArray(VAO); 
-        glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
-        glBindVertexArray(0);
-
-        // always good practice to set everything back to defaults once configured.
-        glActiveTexture(GL_TEXTURE0);
-    }
-
-private:
-    // render data 
-    unsigned int VBO, EBO;
-
-    // initializes all the buffer objects/arrays
-    void setupMesh()
-    {
-        // create buffers/arrays
-        glGenVertexArrays(1, &VAO);
-        glGenBuffers(1, &VBO);
-        glGenBuffers(1, &EBO);
-
-        glBindVertexArray(VAO);
-        // load data into vertex buffers
-        glBindBuffer(GL_ARRAY_BUFFER, VBO);
-        // A great thing about structs is that their memory layout is sequential for all its items.
-        // The effect is that we can simply pass a pointer to the struct and it translates perfectly to a glm::vec3/2 array which
-        // again translates to 3/2 floats which translates to a byte array.
-        glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
-
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
-
-        // set the vertex attribute pointers
-        // vertex Positions
-        glEnableVertexAttribArray(0);
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
-        // vertex normals
-        glEnableVertexAttribArray(1);
-        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
-        // vertex texture coords
-        glEnableVertexAttribArray(2);
-        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
-        // vertex tangent
-        glEnableVertexAttribArray(3);
-        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
-        // vertex bitangent
-        glEnableVertexAttribArray(4);
-        glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Bitangent));
-
-        glBindVertexArray(0);
-    }
-};
-#endif
-

GrafikaProjekt/pliki/src/model.h

@@ -1,250 +0,0 @@
-#pragma once
-
-
-
-
-#include "glew.h"
-#include "freeglut.h"
-#include "glm.hpp"
-#include "ext.hpp"
-#include <iostream>
-#include <cmath>
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-
-#include "stb_image.h"
-#include "mesh.h"
-
-#include <string>
-#include <fstream>
-#include <sstream>
-#include <iostream>
-#include <map>
-#include <vector>
-using namespace std;
-
-
-unsigned int TextureFromFile(const char* path, const string& directory, bool gamma = false);
-
-class Model
-{
-public:
-    // model data 
-    vector<Texture> textures_loaded;	// stores all the textures loaded so far, optimization to make sure textures aren't loaded more than once.
-    vector<Mesh>    meshes;
-    string directory;
-    bool gammaCorrection;
-
-    // constructor, expects a filepath to a 3D model.
-    Model(string const& path, bool gamma = false) : gammaCorrection(gamma)
-    {
-        loadModel(path);
-    }
-
-    // draws the model, and thus all its meshes
-    void Draw(GLuint shader)
-    {
-        for (unsigned int i = 0; i < meshes.size(); i++)
-            meshes[i].Draw(shader);
-    }
-
-private:
-    // loads a model with supported ASSIMP extensions from file and stores the resulting meshes in the meshes vector.
-    void loadModel(string const& path)
-    {
-        // read file via ASSIMP
-        Assimp::Importer importer;
-        const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace);
-        // check for errors
-        if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
-        {
-            cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << endl;
-            return;
-        }
-        // retrieve the directory path of the filepath
-        directory = path.substr(0, path.find_last_of('/'));
-
-        // process ASSIMP's root node recursively
-        processNode(scene->mRootNode, scene,glm::mat4());
-    }
-
-    // processes a node in a recursive fashion. Processes each individual mesh located at the node and repeats this process on its children nodes (if any).
-    void processNode(aiNode* node, const aiScene* scene,glm::mat4 matrix)
-    {
-        glm::mat4 outMatrix = matrix * mat4_cast(node->mTransformation);
-        // process each mesh located at the current node
-        for (unsigned int i = 0; i < node->mNumMeshes; i++)
-        {
-            // the node object only contains indices to index the actual objects in the scene. 
-            // the scene contains all the data, node is just to keep stuff organized (like relations between nodes).
-            aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
-            meshes.push_back(processMesh(mesh, scene, outMatrix));
-        }
-        // after we've processed all of the meshes (if any) we then recursively process each of the children nodes
-        for (unsigned int i = 0; i < node->mNumChildren; i++)
-        {
-            processNode(node->mChildren[i], scene, outMatrix);
-        }
-
-    }
-
-    Mesh processMesh(aiMesh* mesh, const aiScene* scene, glm::mat4 matrix)
-    {
-        // data to fill
-        vector<Vertex> vertices;
-        vector<unsigned int> indices;
-        vector<Texture> textures;
-
-        // walk through each of the mesh's vertices
-        for (unsigned int i = 0; i < mesh->mNumVertices; i++)
-        {
-            Vertex vertex;
-            glm::vec3 vector; // we declare a placeholder vector since assimp uses its own vector class that doesn't directly convert to glm's vec3 class so we transfer the data to this placeholder glm::vec3 first.
-            // positions
-            vector.x = mesh->mVertices[i].x;
-            vector.y = mesh->mVertices[i].y;
-            vector.z = mesh->mVertices[i].z;
-            vertex.Position = vector;
-            // normals
-            if (mesh->HasNormals())
-            {
-                vector.x = mesh->mNormals[i].x;
-                vector.y = mesh->mNormals[i].y;
-                vector.z = mesh->mNormals[i].z;
-                vertex.Normal = vector;
-            }
-            // texture coordinates
-            if (mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
-            {
-                glm::vec2 vec;
-                // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't 
-                // use models where a vertex can have multiple texture coordinates so we always take the first set (0).
-                vec.x = mesh->mTextureCoords[0][i].x;
-                vec.y = mesh->mTextureCoords[0][i].y;
-                vertex.TexCoords = vec;
-                // tangent
-                vector.x = mesh->mTangents[i].x;
-                vector.y = mesh->mTangents[i].y;
-                vector.z = mesh->mTangents[i].z;
-                vertex.Tangent = vector;
-                // bitangent
-                vector.x = mesh->mBitangents[i].x;
-                vector.y = mesh->mBitangents[i].y;
-                vector.z = mesh->mBitangents[i].z;
-                vertex.Bitangent = vector;
-            }
-            else
-                vertex.TexCoords = glm::vec2(0.0f, 0.0f);
-
-            vertices.push_back(vertex);
-        }
-        // now wak through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices.
-        for (unsigned int i = 0; i < mesh->mNumFaces; i++)
-        {
-            aiFace face = mesh->mFaces[i];
-            // retrieve all indices of the face and store them in the indices vector
-            for (unsigned int j = 0; j < face.mNumIndices; j++)
-                indices.push_back(face.mIndices[j]);
-        }
-        // process materials
-        aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
-        // we assume a convention for sampler names in the shaders. Each diffuse texture should be named
-        // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. 
-        // Same applies to other texture as the following list summarizes:
-        // diffuse: texture_diffuseN
-        // specular: texture_specularN
-        // normal: texture_normalN
-
-        // 1. diffuse maps
-        vector<Texture> diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
-        textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
-        // 2. specular maps
-        vector<Texture> specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
-        textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
-        // 3. normal maps
-        std::vector<Texture> normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal");
-        textures.insert(textures.end(), normalMaps.begin(), normalMaps.end());
-        // 4. height maps
-        std::vector<Texture> heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height");
-        textures.insert(textures.end(), heightMaps.begin(), heightMaps.end());
-
-
-        // return a mesh object created from the extracted mesh data
-        return Mesh(vertices, indices, textures, matrix);
-    }
-
-    // checks all material textures of a given type and loads the textures if they're not loaded yet.
-    // the required info is returned as a Texture struct.
-    vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, string typeName)
-    {
-        vector<Texture> textures;
-        for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
-        {
-            aiString str;
-            mat->GetTexture(type, i, &str);
-            // check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
-            bool skip = false;
-            for (unsigned int j = 0; j < textures_loaded.size(); j++)
-            {
-                if (std::strcmp(textures_loaded[j].path.data(), str.C_Str()) == 0)
-                {
-                    textures.push_back(textures_loaded[j]);
-                    skip = true; // a texture with the same filepath has already been loaded, continue to next one. (optimization)
-                    break;
-                }
-            }
-            if (!skip)
-            {   // if texture hasn't been loaded already, load it
-                Texture texture;
-                texture.id = TextureFromFile(str.C_Str(), this->directory);
-                texture.type = typeName;
-                texture.path = str.C_Str();
-                textures.push_back(texture);
-                textures_loaded.push_back(texture);  // store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures.
-            }
-        }
-        return textures;
-    }
-};
-
-
-unsigned int TextureFromFile(const char* path, const string& directory, bool gamma)
-{
-    string filename = string(path);
-    filename = directory + '/' + filename;
-
-    unsigned int textureID;
-    glGenTextures(1, &textureID);
-
-    int width, height, nrComponents;
-    unsigned char* data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0);
-    if (data)
-    {
-        GLenum format;
-        if (nrComponents == 1)
-            format = GL_RED;
-        else if (nrComponents == 3)
-            format = GL_RGB;
-        else if (nrComponents == 4)
-            format = GL_RGBA;
-
-        glBindTexture(GL_TEXTURE_2D, textureID);
-        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
-        glGenerateMipmap(GL_TEXTURE_2D);
-
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-        stbi_image_free(data);
-    }
-    else
-    {
-        std::cout << "Texture failed to load at path: " << path << std::endl;
-        stbi_image_free(data);
-    }
-
-    return textureID;
-}

GrafikaProjekt/scena_podwodna.sln

@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 16.0.31019.35
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scena_podwodna", "pliki\projekt.vcxproj", "{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw6", "pliki\projekt.vcxproj", "{10701B86-9B0B-46A1-85DA-6238CBCC507B}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -11,10 +11,10 @@ Global
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|x86.ActiveCfg = Debug|Win32
+		{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|x86.ActiveCfg = Debug|Win32
-		{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|x86.Build.0 = Debug|Win32
+		{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|x86.Build.0 = Debug|Win32
-		{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|x86.ActiveCfg = Release|Win32
+		{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|x86.ActiveCfg = Release|Win32
-		{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|x86.Build.0 = Release|Win32
+		{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|x86.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE