Add project files.

2024-02-02 11:19:35 +01:00 · 2024-02-02 11:19:35 +01:00 · 8afcc25083
commit 8afcc25083
parent 781738364b
1576 changed files with 248373 additions and 0 deletions
--- a/assimp-vc141-mt.dll
+++ b/assimp-vc141-mt.dll
--- a/assimp-vc141-mtd.dll
+++ b/assimp-vc141-mtd.dll
--- a/1/assimp-vc141-mt.dll
+++ b/1/assimp-vc141-mt.dll
--- a/1/assimp-vc141-mtd.dll
+++ b/1/assimp-vc141-mtd.dll
--- a/1/freeglut.dll
+++ b/1/freeglut.dll
--- a/1/glew32.dll
+++ b/1/glew32.dll
--- a/1/grk-cw1.vcxproj
+++ b/1/grk-cw1.vcxproj
@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Box.cpp" />
+    <ClCompile Include="src\Camera.cpp" />
+    <ClCompile Include="src\main.cpp" />
+    <ClCompile Include="src\Render_Utils.cpp" />
+    <ClCompile Include="src\Shader_Loader.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="src\Camera.h" />
+    <ClInclude Include="src\ex_1_1.hpp" />
+    <ClInclude Include="src\ex_1_2.hpp" />
+    <ClInclude Include="src\ex_1_3.hpp" />
+    <ClInclude Include="src\ex_1_4.hpp" />
+    <ClInclude Include="src\ex_1_5.hpp" />
+    <ClInclude Include="src\ex_1_6.hpp" />
+    <ClInclude Include="src\ex_1_7.hpp" />
+    <ClInclude Include="src\Render_Utils.h" />
+    <ClInclude Include="src\Shader_Loader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="shaders\shader_1_1.frag" />
+    <None Include="shaders\shader_1_1.vert" />
+    <None Include="shaders\shader_1_2.frag" />
+    <None Include="shaders\shader_1_2.vert" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{1B448102-E76C-4347-BDC7-40D02A567DB6}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>grk-cw1</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <LibraryPath>$(SolutionDir)dependencies\freeglut\lib;$(SolutionDir)dependencies\glew-2.0.0\lib\Release\Win32;$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019;$(SolutionDir)dependencies\assimp;$(LibraryPath)</LibraryPath>
+    <IncludePath>$(SolutionDir)dependencies\freeglut\include\GL;$(SolutionDir)dependencies\glew-2.0.0\include\GL;$(SolutionDir)dependencies\glm;$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\include;$(SolutionDir)dependencies\assimp\include;$(IncludePath)</IncludePath>
+    <ExecutablePath>$(ExecutablePath)</ExecutablePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <LibraryPath>$(SolutionDir)dependencies\freeglut\lib;$(SolutionDir)dependencies\glew-2.0.0\lib\Release\Win32;$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019;$(SolutionDir)dependencies\assimp;$(LibraryPath)</LibraryPath>
+    <IncludePath>$(SolutionDir)dependencies\freeglut\include\GL;$(SolutionDir)dependencies\glew-2.0.0\include\GL;$(SolutionDir)dependencies\glm;$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\include;$(SolutionDir)dependencies\assimp\include;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>opengl32.lib;freeglut.lib;glew32.lib;$(SolutionDir)\dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019\glfw3.lib;$(SolutionDir)\dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019\glfw3dll.lib;zlibd.lib;assimp-vc141-mtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>opengl32.lib;freeglut.lib;glew32.lib;$(SolutionDir)\dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019\glfw3.lib;$(SolutionDir)\dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019\glfw3dll.lib;zlibd.lib;assimp-vc141-mtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
--- a/1/grk-cw1.vcxproj.filters
+++ b/1/grk-cw1.vcxproj.filters
@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <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>{1af510f6-5cc2-40d1-adad-b7f6c0b1c2e4}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <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\Camera.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Box.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <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\Camera.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_1.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_2.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_5.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_6.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_3.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_4.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_1_7.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="shaders\shader_1_1.frag">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_1_1.vert">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_1_2.frag">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_1_2.vert">
+      <Filter>Shader Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>
--- a/1/img/stride_offest.jpg
+++ b/1/img/stride_offest.jpg
--- a/1/img/stride_offest_2_2.jpg
+++ b/1/img/stride_offest_2_2.jpg
--- a/1/img/struktura.jpg
+++ b/1/img/struktura.jpg
--- a/1/shaders/shader_1_1.frag
+++ b/1/shaders/shader_1_1.frag
@ -0,0 +1,8 @@
+#version 430 core
+
+out vec4 color;
+
+void main()
+{
+	color = vec4(0.0, 0.6, 0.95, 1.0);
+}
--- a/1/shaders/shader_1_1.vert
+++ b/1/shaders/shader_1_1.vert
@ -0,0 +1,8 @@
+#version 430 core
+
+layout(location = 0) in vec4 vertexPosition;
+
+void main()
+{
+	gl_Position = vertexPosition;
+}
--- a/1/shaders/shader_1_2.frag
+++ b/1/shaders/shader_1_2.frag
@ -0,0 +1,6 @@
+#version 430 core
+out vec4 color;
+void main()
+{
+	color = vec4(0.0, 0.6, 0.95, 1.0);
+}
--- a/1/shaders/shader_1_2.vert
+++ b/1/shaders/shader_1_2.vert
@ -0,0 +1,10 @@
+#version 430 core
+
+layout(location = 0) in vec4 vertexPosition;
+
+uniform mat4 transformation;
+
+void main()
+{
+	gl_Position = transformation * vertexPosition;
+}
--- a/1/shaders/shader_3_1.frag
+++ b/1/shaders/shader_3_1.frag
@ -0,0 +1,10 @@
+#version 430 core
+
+in vec4 color;
+out vec4 out_color;
+
+
+void main()
+{
+	out_color = color;
+}
--- a/1/shaders/shader_3_1.vert
+++ b/1/shaders/shader_3_1.vert
@ -0,0 +1,14 @@
+#version 430 core
+
+layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in vec4 vertexColor;
+
+uniform mat4 transformation;
+
+out vec4 color;
+
+void main()
+{
+	color = vertexColor;
+	gl_Position = transformation * vertexPosition;
+}
--- a/1/shaders/shader_3_2.frag
+++ b/1/shaders/shader_3_2.frag
@ -0,0 +1,11 @@
+#version 430 core
+
+uniform vec3 objectColor;
+in vec3 normal;
+
+out vec4 out_color;
+
+void main()
+{
+	out_color = vec4(normal, 1.	);
+}
--- a/1/shaders/shader_3_2.vert
+++ b/1/shaders/shader_3_2.vert
@ -0,0 +1,14 @@
+#version 430 core
+
+layout(location = 0) in vec3 vertexPosition;
+layout(location = 1) in vec3 vertexNormal;
+layout(location = 2) in vec2 vertexTexCoord;
+
+uniform mat4 transformation;
+out vec3 normal;
+
+void main()
+{
+	normal=vertexNormal;
+	gl_Position = transformation * vec4(vertexPosition, 1.0);
+}
--- a/1/src/Box.cpp
+++ b/1/src/Box.cpp
@ -0,0 +1,104 @@
+
+
+// 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,
+
+};
--- a/1/src/Camera.cpp
+++ b/1/src/Camera.cpp
@ -0,0 +1,31 @@
+#include "Camera.h"
+
+glm::mat4 Core::createPerspectiveMatrix(float zNear, float zFar, float frustumScale)
+{
+	glm::mat4 perspective;
+    perspective[0][0] = 1.f;
+	perspective[1][1] = frustumScale;
+	perspective[2][2] = (zFar + zNear) / (zNear - zFar);
+	perspective[3][2] = (2 * zFar * zNear) / (zNear - zFar);
+	perspective[2][3] = -1;
+	perspective[3][3] = 0;
+
+	return perspective;
+}
+
+glm::mat4 Core::createViewMatrix( glm::vec3 position, glm::vec3 forward, glm::vec3 up )
+{
+	glm::vec3 side = glm::cross(forward, up);
+
+	// Trzeba pamietac o minusie przy ustawianiu osi Z kamery.
+	// Wynika to z tego, ze standardowa macierz perspektywiczna zaklada, ze "z przodu" jest ujemna (a nie dodatnia) czesc osi Z.
+	glm::mat4 cameraRotation;
+	cameraRotation[0][0] = side.x; cameraRotation[1][0] = side.y; cameraRotation[2][0] = side.z;
+	cameraRotation[0][1] = up.x; cameraRotation[1][1] = up.y; cameraRotation[2][1] = up.z;
+	cameraRotation[0][2] = -forward.x; cameraRotation[1][2] = -forward.y; cameraRotation[2][2] = -forward.z;
+
+	glm::mat4 cameraTranslation;
+	cameraTranslation[3] = glm::vec4(-position, 1.0f);
+
+	return cameraRotation * cameraTranslation;
+}
--- a/1/src/Camera.h
+++ b/1/src/Camera.h
@ -0,0 +1,14 @@
+#pragma once
+
+#include "glm.hpp"
+
+namespace Core
+{
+	glm::mat4 createPerspectiveMatrix(float zNear = 0.1f, float zFar = 100.0f, float frustumScale = 1.f);
+
+	// position - pozycja kamery
+	// forward - wektor "do przodu" kamery (jednostkowy)
+	// up - wektor "w gore" kamery (jednostkowy)
+	// up i forward musza byc ortogonalne!
+	glm::mat4 createViewMatrix(glm::vec3 position, glm::vec3 forward, glm::vec3 up);
+}
--- a/1/src/Render_Utils.cpp
+++ b/1/src/Render_Utils.cpp
@ -0,0 +1,76 @@
+#include "Render_Utils.h"
+
+#include "freeglut.h"
+#include <iostream>
+
+void Core::drawVAO(GLuint VAO, int numVertices)
+{
+    glBindVertexArray(VAO);
+
+    glDrawArrays(GL_TRIANGLES, 0, numVertices);
+
+    glBindVertexArray(0);
+}
+
+void Core::drawVAOIndexed(GLuint VAO, int numVertices)
+{
+    glBindVertexArray(VAO);
+
+    glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_INT, 0);
+
+    glBindVertexArray(0);
+}
+
+
+    
+GLuint Core::initVAO(const float* vertexArray, int numVertices, int elementSize) {
+    GLuint VBO, VAO;
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+
+
+    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
+    glBindVertexArray(VAO);
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, numVertices * elementSize * sizeof(float), vertexArray, GL_STATIC_DRAW);
+
+    glVertexAttribPointer(0, elementSize, GL_FLOAT, GL_FALSE, elementSize * sizeof(float), (void*)0);
+    glEnableVertexAttribArray(0);
+
+    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
+    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
+    glBindVertexArray(0);
+    return VAO;
+}
+
+GLuint Core::initVAOIndexed(const float* vertexArray, const unsigned int* indexArray, int numVertices, int elementSize, int numIndexes) {
+    GLuint VBO, VAO, EBO;
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+    glGenBuffers(1, &EBO);
+
+
+    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
+    glBindVertexArray(VAO);
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, numVertices * elementSize * sizeof(float), vertexArray, GL_STATIC_DRAW);
+
+    glVertexAttribPointer(0, elementSize, GL_FLOAT, GL_FALSE, elementSize * sizeof(float), (void*)0);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndexes*sizeof(unsigned int), indexArray, GL_STATIC_DRAW);
+    glEnableVertexAttribArray(0);
+
+    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
+    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
+    glBindVertexArray(0);
+    return VAO;
+}
--- a/1/src/Render_Utils.h
+++ b/1/src/Render_Utils.h
@ -0,0 +1,26 @@
+#pragma once
+#include "glew.h"
+
+namespace Core
+{
+	// VAO - zmienna zawierajaca wskaznik do VAO
+	// numVertices - liczba wierzcholkow do narysowania
+	void drawVAO(GLuint VAO, int numVertices);
+
+	// VAO - zmienna zawierajaca wskaznik do VAO
+	// numIndexes - liczba indeksow do naryowania
+	void drawVAOIndexed(GLuint VAO, int numVertices);
+
+
+	// vertexArray - jednowymiarowa tablica zawierajaca wartosci opisujace pozycje kolejnych wierzcholkow w jednym ciagu (x1, y1, z1, w1, x2, y2, z2, w2, ...)
+	// numVertices - liczba wierzcholkow do narysowania
+	// elementSize - liczba wartosci opisujacych pojedynczy wierzcholek (np. 3 gdy wierzcholek opisany jest trojka (x, y, z))
+	GLuint initVAO(const float* vertexArray, int numVertices, int elementSize);
+
+
+	// indexArray - jednowymiarowa tablica zawierajaca indeksy wierzcholkow kolejnych trojkatow w jednym ciagu (t1_i1, t1_i2, t1_i3, t2_i1, t2_i2, t2_i3, ...)
+	// numIndexes - liczba indeksow w tablicy indexArray
+	GLuint initVAOIndexed(const float* vertexArray, const unsigned int* indexArray, int numVertices, int elementSize, int numIndexes);
+
+	void deleteVAO(GLuint VAO);
+}
--- a/1/src/Shader_Loader.cpp
+++ b/1/src/Shader_Loader.cpp
@ -0,0 +1,102 @@
+#include "Shader_Loader.h" 
+#include<iostream>
+#include<fstream>
+#include<vector>
+
+using namespace Core;
+
+Shader_Loader::Shader_Loader(void){}
+Shader_Loader::~Shader_Loader(void){}
+
+std::string Shader_Loader::ReadShader(char *filename)
+{
+
+	std::string shaderCode;
+	std::ifstream file(filename, std::ios::in);
+
+	if (!file.good())
+	{
+		std::cout << "Can't read file " << filename << std::endl;
+		std::terminate();
+	}
+
+	file.seekg(0, std::ios::end);
+	shaderCode.resize((unsigned int)file.tellg());
+	file.seekg(0, std::ios::beg);
+	file.read(&shaderCode[0], shaderCode.size());
+	file.close();
+	return shaderCode;
+}
+
+GLuint Shader_Loader::CreateShader(GLenum shaderType, std::string
+	source, char* shaderName)
+{
+
+	int compile_result = 0;
+
+	GLuint shader = glCreateShader(shaderType);
+	const char *shader_code_ptr = source.c_str();
+	const int shader_code_size = source.size();
+
+	glShaderSource(shader, 1, &shader_code_ptr, &shader_code_size);
+	glCompileShader(shader);
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_result);
+
+	//sprawdz bledy kompilacji
+	if (compile_result == GL_FALSE)
+	{
+
+		int info_log_length = 0;
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);
+		std::vector<char> shader_log(info_log_length);
+		glGetShaderInfoLog(shader, info_log_length, NULL, &shader_log[0]);
+		std::cout << "ERROR compiling shader: " << shaderName << std::endl << &shader_log[0] << std::endl;
+		return 0;
+	}
+
+	return shader;
+}
+
+GLuint Shader_Loader::CreateProgram(char* vertexShaderFilename,
+	char* fragmentShaderFilename)
+{
+
+	//wczytaj shadery
+	std::string vertex_shader_code = ReadShader(vertexShaderFilename);
+	std::string fragment_shader_code = ReadShader(fragmentShaderFilename);
+
+	GLuint vertex_shader = CreateShader(GL_VERTEX_SHADER, vertex_shader_code, "vertex shader");
+	GLuint fragment_shader = CreateShader(GL_FRAGMENT_SHADER, fragment_shader_code, "fragment shader");
+
+	int link_result = 0;
+	//stworz shader
+	GLuint program = glCreateProgram();
+	glAttachShader(program, vertex_shader);
+	glAttachShader(program, fragment_shader);
+
+	glLinkProgram(program);
+	glGetProgramiv(program, GL_LINK_STATUS, &link_result);
+	//sprawdz bledy linkowania
+	if (link_result == GL_FALSE)
+	{
+
+		int info_log_length = 0;
+		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);
+		std::vector<char> program_log(info_log_length);
+		glGetProgramInfoLog(program, info_log_length, NULL, &program_log[0]);
+		std::cout << "Shader Loader : LINK ERROR" << std::endl << &program_log[0] << std::endl;
+		return 0;
+	}
+
+	glDetachShader(program, vertex_shader);
+	glDetachShader(program, fragment_shader);
+	glDeleteShader(vertex_shader);
+	glDeleteShader(fragment_shader);
+
+	return program;
+}
+
+void Shader_Loader::DeleteProgram( GLuint program )
+{
+	glDeleteProgram(program);
+}
--- a/1/src/Shader_Loader.h
+++ b/1/src/Shader_Loader.h
@ -0,0 +1,29 @@
+#pragma once
+
+#include "glew.h"
+#include "freeglut.h"
+#include <iostream>
+
+namespace Core
+{
+
+	class Shader_Loader
+	{
+	private:
+
+		std::string ReadShader(char *filename);
+		GLuint CreateShader(GLenum shaderType,
+			std::string source,
+			char* shaderName);
+
+	public:
+
+		Shader_Loader(void);
+		~Shader_Loader(void);
+		GLuint CreateProgram(char* VertexShaderFilename,
+			char* FragmentShaderFilename);
+
+		void DeleteProgram(GLuint program);
+
+	};
+}
--- a/1/src/ex_1_1.hpp
+++ b/1/src/ex_1_1.hpp
@ -0,0 +1,51 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+// funkcja renderujaca scene    
+void renderScene(GLFWwindow* window)
+{
+    double time = glfwGetTime();
+    // ZADANIE: Przesledz kod i komentarze
+    // ZADANIE: Zmien kolor tla sceny, przyjmujac zmiennoprzecinkowy standard RGBA
+    glClearColor(0.06f, 0.3f, 0.01*time, -0.01*time);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    
+    // Powinno byc wywolane po kazdej klatce
+    glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+}
+
+void shutdown(GLFWwindow* window)
+{
+}
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}
+//}
--- a/1/src/ex_1_2.hpp
+++ b/1/src/ex_1_2.hpp
@ -0,0 +1,69 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+GLuint program; // Shader ID
+
+GLuint triangleVAO;
+
+Core::Shader_Loader shaderLoader;
+
+void renderScene(GLFWwindow* window)
+{
+    glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    // Aktywowanie shadera
+    glUseProgram(program);
+
+    //wywolaj funkcje Core::drawVAO z render utils z parametrem wejściowym GLuint triangleVAO 
+    Core::drawVAO(triangleVAO, 3);
+    // Wylaczenie shadera
+    glUseProgram(0);
+
+    glfwSwapBuffers(window);
+}
+
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    program = shaderLoader.CreateProgram("shaders/shader_1_1.vert", "shaders/shader_1_1.frag");
+
+    float points[] = { 0.1f, 0.1f, 0, 1,
+                        0.2f, 0.2f, 0, 1,
+                        0.3f, 0.3f, 0, 1};
+    triangleVAO = Core::initVAO(points, 4, 3);
+    //stworz tablice wierzcholkow i zaladuj je do GPU za pomoca funkcji initVAO, wynik zapisz w triangleVAO
+}
+
+void shutdown(GLFWwindow* window)
+{
+    shaderLoader.DeleteProgram(program);
+}
+
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}   
--- a/1/src/ex_1_3.hpp
+++ b/1/src/ex_1_3.hpp
@ -0,0 +1,72 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+GLuint program; // Shader ID
+
+GLuint quadVAO;
+
+Core::Shader_Loader shaderLoader;
+
+
+void renderScene(GLFWwindow* window)
+{
+    glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    // Aktywowanie shadera
+    glUseProgram(program);
+
+    //wywolaj funkcje drawVAOIndexed na quadVAO 
+    Core::drawVAOIndexed(quadVAO, 6);
+    // Wylaczenie shadera
+    glUseProgram(0);
+
+    glfwSwapBuffers(window);
+}
+
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    program = shaderLoader.CreateProgram("shaders/shader_1_1.vert", "shaders/shader_1_1.frag");
+    float points[] = { 0.2f, 0.8f, 0, 1,
+                        0.2f, 0.6f, 0, 1,
+                        0.3f, 0.3f, 0, 1,
+                        0.4f, 0.9f, 0, 1};
+    const unsigned int index[] = { 4, 2, 3,
+                            1, 2, 3 };
+    quadVAO = Core::initVAOIndexed(points, index, 4 , 3, 6);
+    //Stworz czworokat przy uzyciu 4 wierzcholkow i 6 indeksow (typ: const int []) zaladuj go do za pomoca initVAOIndexed do quadVAO
+}
+
+void shutdown(GLFWwindow* window)
+{
+    shaderLoader.DeleteProgram(program);
+}
+
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}
--- a/1/src/ex_1_4.hpp
+++ b/1/src/ex_1_4.hpp
@ -0,0 +1,97 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+#include <gtc/matrix_transform.hpp>
+
+GLuint program; // Shader ID
+
+GLuint quadVAO;
+
+Core::Shader_Loader shaderLoader;
+
+
+void renderScene(GLFWwindow* window)
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+
+	// Zmienna "time" przechowuje czas ktory uplynal od uruchomienia aplikacji
+	float time = glfwGetTime();
+
+	glUseProgram(program);
+
+	// "translation" jest automatycznie zainicjalizowana macierza 4x4
+	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	// ! Macierz translation jest definiowana wierszowo dla poprawy czytelnosci. OpenGL i GLM domyslnie stosuje macierze kolumnowe, dlatego musimy ja transponowac !
+	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	float translateY = 0.5f * sin(time);
+	glm::mat4 translationMatrixData( {
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, translateY,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	});
+	glm::mat4 translationMatrix = glm::transpose(translationMatrixData);
+
+	// ZADANIE: Narysuj ruszajacy sie czworokat
+	//
+	// Uzyj zmiennej "time" do zdefiniowania macierzy translacji w taki sposob, aby czworokat przesuwal sie w gore i w dol ekranu (wartosci wspolrzednej y powinny zmieniac sie pomiedzy -0.5 i 0.5)
+	// Wykorzystaj funkcje sinus: sin(float x)
+
+	// glUniformMatrix4fv przekazuje macierz "translation" do GPU i powiazuje ja w shaderze ze zmienna typu mat4 o nazwie "transformation"
+	// Shader uzywa tej macierzy to transformacji wierzcholkow podczas renderowania
+	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&translationMatrix);
+
+	// Uzyj kodu z poprzednich cwiczen do narysowania czworokata
+	Core::drawVAOIndexed(quadVAO, 6);
+	glUseProgram(0);
+
+    glfwSwapBuffers(window);
+}
+
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    program = shaderLoader.CreateProgram("shaders/shader_1_2.vert", "shaders/shader_1_2.frag");
+	float points[] = { 0.2f, 0.8f, 0, 1,
+						0.2f, 0.6f, 0, 1,
+						0.3f, 0.3f, 0, 1,
+						0.4f, 0.9f, 0, 1 };
+	const unsigned int index[] = { 4, 2, 3,
+							1, 2, 3 };
+	quadVAO = Core::initVAOIndexed(points, index, 4, 3, 6);
+    //Przekopiuj kod do ladowania z poprzedniego zadania
+}
+
+void shutdown(GLFWwindow* window)
+{
+    shaderLoader.DeleteProgram(program);
+}
+
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}
+//}
--- a/1/src/ex_1_5.hpp
+++ b/1/src/ex_1_5.hpp
@ -0,0 +1,104 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+#include <gtc/matrix_transform.hpp>
+
+GLuint program; // Shader ID
+
+GLuint quadVAO;
+
+Core::Shader_Loader shaderLoader;
+
+
+void renderScene(GLFWwindow* window)
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+
+	// Zmienna "time" przechowuje czas ktory uplynal od uruchomienia aplikacji
+	float time = glfwGetTime();
+
+	glUseProgram(program);
+
+	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	// ! Macierz translation jest definiowana wierszowo dla poprawy czytelnosci. OpenGL i GLM domyslnie stosuje macierze kolumnowe, dlatego musimy ja transponowac !
+	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	float translateY = 0.5f * sin(time);
+	glm::mat4 translationMatrixData({
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, translateY,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+		});
+	glm::mat4 translationMatrix = glm::transpose(translationMatrixData);
+	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&translationMatrix);
+	Core::drawVAOIndexed(quadVAO, 6);
+
+	float rotationAngle = glm::radians(time*10);  // Kąt obrotu w stopniach, tutaj 45 stopni
+	float cosTheta = cos(rotationAngle);
+	float sinTheta = sin(rotationAngle);
+
+	glm::mat4 rotationMatrix = glm::mat4(
+		cosTheta, -sinTheta, 0.0f, -0.5f,
+		sinTheta, cosTheta, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+	glm::mat4 rotation = glm::transpose(rotationMatrix);
+	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&rotation);
+	Core::drawVAOIndexed(quadVAO, 6);
+	// ZADANIE: Narysuj dwa czworokaty, jeden ruszajacy sie, drugi obracajacy sie 
+	// Do rysowania ruszajacego sie czworokatu mozesz uzyc kodu z poprzedniego zadania, zmodyfikuj tylko macierz translacji, zeby byly obok siebie, nie jeden na drugim
+	// Uzyj zmiennej "time" do zdefiniowania takiej macierzy rotacji, aby czworokat obracal sie wokol srodka (znajdz odpowiednia macierz 4x4 w internecie)
+	// Kat obrotu podajemy w radianach
+
+	glUseProgram(0);
+
+	glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+	program = shaderLoader.CreateProgram("shaders/shader_1_2.vert", "shaders/shader_1_2.frag");
+	float points[] = { 0.2f, 0.8f, 0, 1,
+						0.2f, 0.6f, 0, 1,
+						0.3f, 0.3f, 0, 1,
+						0.4f, 0.9f, 0, 1 };
+	const unsigned int index[] = { 4, 2, 3,
+							1, 2, 3 };
+	quadVAO = Core::initVAOIndexed(points, index, 4, 3, 6);
+    //Przekopiuj kod do ladowania z poprzedniego zadania
+}
+
+void shutdown(GLFWwindow* window)
+{
+    shaderLoader.DeleteProgram(program);
+}
+
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}
+//}
--- a/1/src/ex_1_6.hpp
+++ b/1/src/ex_1_6.hpp
@ -0,0 +1,103 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+#include <gtc/matrix_transform.hpp>
+#include <ext.hpp>
+GLuint program; // Shader ID
+
+GLuint quadVAO;
+
+Core::Shader_Loader shaderLoader;
+
+
+void renderScene(GLFWwindow* window)
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+
+	// Zmienna "time" przechowuje czas ktory uplynal od uruchomienia aplikacji
+	float time = glfwGetTime();
+
+    glUseProgram(program);
+    
+    // ZADANIE: Wyswietl czworokat, ktory jednoczesnie przesuwa sie i obraca.
+    // 
+    // Uzyj kodu do translacji i rotacji czworokatu z poprzednich zadan
+    // 
+    // Stworz taka macierz transformacji, ktora powoduje ze czworokat przesuwa sie w gore i w dol ekranu, jednoczesnie obracajac sie.
+    // Wyslij stworzona macierz do GPU za pomoca funkcji glUniformMatrix4fv zamiast macierzy "translation" i "rotation" z poprzednich zadan
+    float translateY = 0.5f * sin(time);
+    glm::mat4 translationMatrixData({
+        1.0f, 0.0f, 0.0f, 0.0f,
+        0.0f, 1.0f, 0.0f, translateY,
+        0.0f, 0.0f, 1.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 1.0f
+        });
+    glm::mat4 translationMatrix = glm::transpose(translationMatrixData);
+
+    float rotationAngle = glm::radians(time * 10);  // Kąt obrotu w stopniach, tutaj 45 stopni
+    float cosTheta = cos(rotationAngle);
+    float sinTheta = sin(rotationAngle);
+
+    glm::mat4 rotationMatrix = glm::mat4(
+        cosTheta, -sinTheta, 0.0f, 0.0f,
+        sinTheta, cosTheta, 0.0f, 0.0f,
+        0.0f, 0.0f, 1.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 1.0f
+    );
+    glm::mat4 rotation = glm::transpose(rotationMatrix);
+    glm::mat4 finalMatrix = translationMatrix * rotation;
+    glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&finalMatrix);
+    Core::drawVAOIndexed(quadVAO, 6);
+
+    glUseProgram(0);
+
+    glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    program = shaderLoader.CreateProgram("shaders/shader_1_2.vert", "shaders/shader_1_2.frag");
+
+    //Przekopiuj kod do ladowania z poprzedniego zadania
+}
+
+void shutdown(GLFWwindow* window)
+{
+    shaderLoader.DeleteProgram(program);
+}
+
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+    float points[] = { 0.2f, 0.8f, 0, 1,
+                        0.2f, 0.6f, 0, 1,
+                        0.3f, 0.3f, 0, 1,
+                        0.4f, 0.9f, 0, 1 };
+    const unsigned int index[] = { 4, 2, 3,
+                            1, 2, 3 };
+    quadVAO = Core::initVAOIndexed(points, index, 4, 3, 6);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}
+//}
--- a/1/src/ex_1_7.hpp
+++ b/1/src/ex_1_7.hpp
@ -0,0 +1,140 @@
+#pragma once
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+#include <gtc/matrix_transform.hpp>
+#include <ext.hpp>
+#include <vector>
+GLuint program; // Shader ID
+
+GLuint quadVAO;
+
+Core::Shader_Loader shaderLoader;
+glm::vec3 quadPos = glm::vec3(0.0f, 0.0f, 0.0f);
+std::vector<glm::vec3> quadsPositions;
+float rotationAngle = 0.0f;
+float centerX;
+float centerY;
+float centerZ;
+void renderScene(GLFWwindow* window)
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+
+	// Zmienna "time" przechowuje czas ktory uplynal od uruchomienia aplikacji
+	float time = glfwGetTime();
+
+    glUseProgram(program);
+    
+    // ZADANIE: Wyswietl czworokat, ktory jednoczesnie przesuwa sie i obraca.
+    // 
+    // Uzyj kodu do translacji i rotacji czworokatu z poprzednich zadan
+    // 
+    // Stworz taka macierz transformacji, ktora powoduje ze czworokat przesuwa sie w gore i w dol ekranu, jednoczesnie obracajac sie.
+    // Wyslij stworzona macierz do GPU za pomoca funkcji glUniformMatrix4fv zamiast macierzy "translation" i "rotation" z poprzednich zadan
+
+
+    //glm::mat4 transform = glm::mat4(1.0f);
+    //transform = glm::translate(transform, quadPos);
+    //transform = glm::translate(transform, glm::vec3(0.0f, 0.5f * sin(glfwGetTime()), 0.0f));
+    //transform = glm::translate(transform, glm::vec3(centerX, centerY, centerZ));
+    //glm::mat4 rotationMatrix = glm::rotate(glm::mat4(1.0f), rotationAngle,glm::vec3(0.f, 0.0f, -0.1f));
+   // transform = transform * rotationMatrix;
+   // transform = glm::translate(transform, -glm::vec3(centerX, centerY, centerZ));
+    //glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transform);
+    for (const auto& quadPos : quadsPositions) {
+        glm::mat4 transform = glm::mat4(1.0f);
+        transform = glm::translate(transform, quadPos);
+        glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transform);
+
+        Core::drawVAOIndexed(quadVAO, 6);
+    }
+    Core::drawVAOIndexed(quadVAO, 6);
+    glUseProgram(0);
+
+    glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+void mouseCallback(GLFWwindow* window, double xpos, double ypos) {
+    float ndcX = (2.0f * xpos) / 500.0f - 1.0f;
+    float ndcY = 1.0f - (2.0f * ypos) / 500.0f;
+
+    glm::vec3 quadPos = glm::vec3(ndcX, ndcY, 0.0f);
+
+    quadsPositions.push_back(quadPos);
+}
+void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
+    if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) {
+        double xpos, ypos;
+        glfwGetCursorPos(window, &xpos, &ypos);
+        mouseCallback(window, xpos, ypos);
+    }
+}
+void init(GLFWwindow* window) {
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    program = shaderLoader.CreateProgram("shaders/shader_1_2.vert", "shaders/shader_1_2.frag");
+
+    glfwSetMouseButtonCallback(window, mouse_button_callback);
+
+    float points[] = { 0.2f, 0.8f, 0, 1,
+                        0.2f, 0.6f, 0, 1,
+                        0.3f, 0.3f, 0, 1,
+                        0.4f, 0.9f, 0, 1 };
+    const unsigned int index[] = { 4, 2, 3,
+                            1, 2, 3 };
+    int numVertices = sizeof(points) / sizeof(float) / 4;
+    float sumX = 0.0f, sumY = 0.0f, sumZ = 0.0f;
+    for (int i = 0; i < numVertices; ++i) {
+        int baseIndex = i * 4;
+        sumX += points[baseIndex];
+        sumY += points[baseIndex + 1];
+        sumZ += points[baseIndex + 2];
+    }
+    centerX = sumX / numVertices;
+    centerY = sumY / numVertices;
+    centerZ = sumZ / numVertices;
+    quadVAO = Core::initVAOIndexed(points, index, 4, 3, 6);
+}
+
+void shutdown(GLFWwindow* window)
+{
+    shaderLoader.DeleteProgram(program);
+}
+
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+    if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
+        quadPos = quadPos + glm::vec3(0.0f, 0.001f, 0.0f);
+    if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
+        quadPos = quadPos + glm::vec3(0.0f, -0.001f, 0.0f);
+    if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS)
+        quadPos = quadPos + glm::vec3(0.001f, 0.0f, 0.0f);
+    if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS)
+        quadPos = quadPos + glm::vec3(-0.001f, 0.0f, 0.0f);
+    if (glfwGetKey(window, GLFW_KEY_O) == GLFW_PRESS)
+        rotationAngle = rotationAngle + 0.002f;
+    if (glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS)
+        rotationAngle = rotationAngle - 0.002f;
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+    while (!glfwWindowShouldClose(window))
+    {
+        processInput(window);
+
+        renderScene(window);
+        glfwPollEvents();
+    }
+}
+//}
--- a/1/src/main.cpp
+++ b/1/src/main.cpp
@ -0,0 +1,45 @@
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+#include "ex_1_7.hpp"
+
+
+
+int main(int argc, char ** argv)
+{
+    // inicjalizacja glfw
+    glfwInit();
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    // tworzenie okna za pomocą glfw
+    GLFWwindow* window = glfwCreateWindow(500, 500, "FirstWindow", NULL, NULL);
+    if (window == NULL)
+    {
+        std::cout << "Failed to create GLFW window" << std::endl;
+        glfwTerminate();
+        return -1;
+    }
+    glfwMakeContextCurrent(window);
+
+    // ladowanie OpenGL za pomoca glew
+    glewInit();
+    glViewport(0, 0, 500, 500);
+
+    init(window);
+
+    // uruchomienie glownej petli
+    renderLoop(window);
+
+    shutdown(window);
+    glfwTerminate();
+    return 0;
+}
--- a/1/src/objload.h
+++ b/1/src/objload.h
@ -0,0 +1,291 @@
+/* Copyright (c) 2012, Gerhard Reitmayr
+   All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+#ifndef OBJLOAD_H_
+#define OBJLOAD_H_
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+
+namespace obj {
+
+struct Model {
+    std::vector<float> vertex; //< 3 * N entries
+    std::vector<float> texCoord; //< 2 * N entries
+    std::vector<float> normal; //< 3 * N entries
+    
+    std::map<std::string, std::vector<unsigned short> > faces; //< assume triangels and uniform indexing
+};
+
+struct ObjModel {
+    struct FaceVertex {
+        FaceVertex() : v(-1), t(-1), n(-1) {}
+        int v, t, n;
+        
+        bool operator<( const FaceVertex & other ) const;
+        bool operator==( const FaceVertex & other ) const;
+    };
+    
+    typedef std::pair<std::vector<FaceVertex>, std::vector<unsigned> > FaceList;
+
+    std::vector<float> vertex; //< 3 * N entries
+    std::vector<float> texCoord; //< 2 * N entries
+    std::vector<float> normal; //< 3 * N entries
+
+    std::map<std::string, FaceList > faces;
+};
+
+inline ObjModel parseObjModel( std::istream & in);
+inline void tesselateObjModel( ObjModel & obj);
+inline ObjModel tesselateObjModel( const ObjModel & obj );
+inline Model convertToModel( const ObjModel & obj );
+
+inline Model loadModel( std::istream & in );
+inline Model loadModelFromString( const std::string & in );
+inline Model loadModelFromFile( const std::string & in );
+
+inline std::ostream & operator<<( std::ostream & out, const Model & m );
+inline std::ostream & operator<<( std::ostream & out, const ObjModel::FaceVertex & f);
+
+// ---------------------------- Implementation starts here -----------------------
+
+inline bool ObjModel::FaceVertex::operator<( const ObjModel::FaceVertex & other ) const {
+    return (v < other.v) || (v == other.v && t < other.t ) || (v == other.v && t == other.t && n < other.n);
+}
+
+inline bool ObjModel::FaceVertex::operator==( const ObjModel::FaceVertex & other ) const {
+    return (v == other.v && t == other.t && n == other.n);
+}
+
+template <typename T>
+inline std::istream & operator>>(std::istream & in, std::vector<T> & vec ){
+    T temp;
+    if(in >> temp) 
+        vec.push_back(temp);
+    return in;
+}
+
+template <typename T>
+inline std::istream & operator>>(std::istream & in, std::set<T> & vec ){
+    T temp;
+    if(in >> temp) 
+        vec.insert(temp);
+    return in;
+}
+
+inline std::istream & operator>>( std::istream & in, ObjModel::FaceVertex & f){
+    if(in >> f.v){
+        if(in.peek() == '/'){
+            in.get();
+            in >> f.t;
+            in.clear();
+            if(in.peek() == '/'){
+                in.get();
+                in >> f.n;
+                in.clear();
+            }
+        }
+        in.clear();
+        --f.v;
+        --f.t;
+        --f.n;
+    }
+    // std::cout << f << std::endl;
+    return in;
+}
+
+ObjModel parseObjModel( std::istream & in ){
+    char line[1024];
+    std::string op;
+    std::istringstream line_in;
+    std::set<std::string> groups;
+    groups.insert("default");
+
+    ObjModel data;
+
+    while(in.good()){
+        in.getline(line, 1023);
+        line_in.clear();
+        line_in.str(line);
+
+        if(!(line_in >> op))
+            continue;
+        if(op == "v")
+            line_in >> data.vertex >> data.vertex >> data.vertex;
+        else if(op == "vt")
+            line_in >> data.texCoord >> data.texCoord >> data.texCoord;
+        else if(op == "vn")
+            line_in >> data.normal >> data.normal >> data.normal;
+        else if(op == "g"){
+            groups.clear();
+            while(line_in >> groups) ;
+            groups.insert("default");
+        }
+        else if(op == "f") {
+            std::vector<ObjModel::FaceVertex> list;
+            while(line_in >> list) ;
+            
+            for(std::set<std::string>::const_iterator g = groups.begin(); g != groups.end(); ++g){
+                ObjModel::FaceList & fl = data.faces[*g];
+                fl.second.push_back(fl.first.size());
+                fl.first.insert(fl.first.end(), list.begin(), list.end());
+            }
+        }
+    }
+    for(std::map<std::string, ObjModel::FaceList>::iterator g = data.faces.begin(); g != data.faces.end(); ++g){
+        ObjModel::FaceList & fl = g->second;
+        fl.second.push_back(fl.first.size());
+    }
+    return data;
+}
+
+inline void tesselateObjModel( std::vector<ObjModel::FaceVertex> & input, std::vector<unsigned> & input_start){
+    std::vector<ObjModel::FaceVertex> output;
+    std::vector<unsigned> output_start;
+    output.reserve(input.size());
+    output_start.reserve(input_start.size());
+    
+    for(std::vector<unsigned>::const_iterator s = input_start.begin(); s != input_start.end() - 1; ++s){
+        const unsigned size = *(s+1) - *s;
+        if(size > 3){
+            const ObjModel::FaceVertex & start_vertex = input[*s];
+            for( int i = 1; i < (int)size-1; ++i){
+                output_start.push_back(output.size());
+                output.push_back(start_vertex);
+                output.push_back(input[*s+i]);
+                output.push_back(input[*s+i+1]);
+            }
+        } else {
+            output_start.push_back(output.size());
+            output.insert(output.end(), input.begin() + *s, input.begin() + *(s+1));
+        }
+    }
+    output_start.push_back(output.size());
+    input.swap(output);
+    input_start.swap(output_start);
+}
+
+void tesselateObjModel( ObjModel & obj){
+    for(std::map<std::string, ObjModel::FaceList>::iterator g = obj.faces.begin(); g != obj.faces.end(); ++g){
+        ObjModel::FaceList & fl = g->second;
+        tesselateObjModel(fl.first, fl.second);
+    }
+}
+
+Model convertToModel( const ObjModel & obj ) {
+    // insert all face vertices into a vector and make unique
+    std::vector<ObjModel::FaceVertex> unique(obj.faces.find("default")->second.first);
+    std::sort(unique.begin(), unique.end());
+    unique.erase( std::unique(unique.begin(), unique.end()), unique.end());
+
+    // build a new model with repeated vertices/texcoords/normals to have single indexing
+    Model model;
+    for(std::vector<ObjModel::FaceVertex>::const_iterator f = unique.begin(); f != unique.end(); ++f){
+        model.vertex.insert(model.vertex.end(), obj.vertex.begin() + 3*f->v, obj.vertex.begin() + 3*f->v + 3);
+        if(!obj.texCoord.empty()){
+            const int index = (f->t > -1) ? f->t : f->v;
+            model.texCoord.insert(model.texCoord.end(), obj.texCoord.begin() + 2*index, obj.texCoord.begin() + 2*index + 2);
+        }
+        if(!obj.normal.empty()){
+            const int index = (f->n > -1) ? f->n : f->v;
+            model.normal.insert(model.normal.end(), obj.normal.begin() + 3*index, obj.normal.begin() + 3*index + 3);
+        }
+    }
+    // look up unique index and transform face descriptions
+    for(std::map<std::string, ObjModel::FaceList>::const_iterator g = obj.faces.begin(); g != obj.faces.end(); ++g){
+        const std::string & name = g->first;
+        const ObjModel::FaceList & fl = g->second;
+        std::vector<unsigned short> & v = model.faces[g->first];
+        v.reserve(fl.first.size());
+        for(std::vector<ObjModel::FaceVertex>::const_iterator f = fl.first.begin(); f != fl.first.end(); ++f){
+            const unsigned short index = std::distance(unique.begin(), std::lower_bound(unique.begin(), unique.end(), *f));
+            v.push_back(index);
+        }
+    }
+    return model;
+}
+
+ObjModel tesselateObjModel( const ObjModel & obj ){
+    ObjModel result = obj;
+    tesselateObjModel(result);
+    return result;
+}
+
+Model loadModel( std::istream & in ){
+    ObjModel model = parseObjModel(in);
+    tesselateObjModel(model);
+    return convertToModel(model);
+}
+
+Model loadModelFromString( const std::string & str ){
+    std::istringstream in(str);
+    return loadModel(in);
+}
+
+Model loadModelFromFile( const std::string & str) {
+    std::ifstream in(str.c_str());
+    return loadModel(in);
+}
+
+inline std::ostream & operator<<( std::ostream & out, const ObjModel::FaceVertex & f){
+    out << f.v << "\t" << f.t << "\t" << f.n;
+    return out;
+}
+
+std::ostream & operator<<( std::ostream & out, const Model & m ){
+    if(!m.vertex.empty()){
+        out << "vertex\n";
+        for(int i = 0; i < (int)m.vertex.size(); ++i)
+            out << m.vertex[i] << (((i % 3) == 2)?"\n":"\t");
+    }
+    if(!m.texCoord.empty()){
+        out << "texCoord\n";
+        for(int i = 0; i < (int)m.texCoord.size(); ++i)
+            out << m.texCoord[i] << (((i % 2) == 1)?"\n":"\t");
+    }
+    if(!m.normal.empty()){
+        out << "normal\n";
+        for(int i = 0; i < (int)m.normal.size(); ++i)
+            out << m.normal[i] << (((i % 3) == 2)?"\n":"\t");
+    }
+    if(!m.faces.empty()){
+        out << "faces\t";
+        for(std::map<std::string, std::vector<unsigned short> >::const_iterator g = m.faces.begin(); g != m.faces.end(); ++g){
+            out << g->first << " ";
+        }
+        out << "\n";
+//        for(int i = 0; i < m.face.size(); ++i)
+//            out << m.face[i] << (((i % 3) == 2)?"\n":"\t");
+    }
+    return out;
+}
+
+} // namespace obj
+
+#endif // OBJLOAD_H_
--- a/1/zlib.dll
+++ b/1/zlib.dll
--- a/1/zlibd.dll
+++ b/1/zlibd.dll
--- a/2/Zadania
+++ b/2/Zadania
@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
+<head>
+  <meta charset="utf-8" />
+  <meta name="generator" content="pandoc" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
+  <title>Zadania 2</title>
+  <style>
+    code{white-space: pre-wrap;}
+    span.smallcaps{font-variant: small-caps;}
+    span.underline{text-decoration: underline;}
+    div.column{display: inline-block; vertical-align: top; width: 50%;}
+    div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+    ul.task-list{list-style: none;}
+    pre > code.sourceCode { white-space: pre; position: relative; }
+    pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+    pre > code.sourceCode > span:empty { height: 1.2em; }
+    code.sourceCode > span { color: inherit; text-decoration: inherit; }
+    div.sourceCode { margin: 1em 0; }
+    pre.sourceCode { margin: 0; }
+    @media screen {
+    div.sourceCode { overflow: auto; }
+    }
+    @media print {
+    pre > code.sourceCode { white-space: pre-wrap; }
+    pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+    }
+    pre.numberSource code
+      { counter-reset: source-line 0; }
+    pre.numberSource code > span
+      { position: relative; left: -4em; counter-increment: source-line; }
+    pre.numberSource code > span > a:first-child::before
+      { content: counter(source-line);
+        position: relative; left: -1em; text-align: right; vertical-align: baseline;
+        border: none; display: inline-block;
+        -webkit-touch-callout: none; -webkit-user-select: none;
+        -khtml-user-select: none; -moz-user-select: none;
+        -ms-user-select: none; user-select: none;
+        padding: 0 4px; width: 4em;
+        color: #aaaaaa;
+      }
+    pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+    div.sourceCode
+      {   }
+    @media screen {
+    pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+    }
+    code span.al { color: #ff0000; font-weight: bold; } /* Alert */
+    code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
+    code span.at { color: #7d9029; } /* Attribute */
+    code span.bn { color: #40a070; } /* BaseN */
+    code span.bu { } /* BuiltIn */
+    code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
+    code span.ch { color: #4070a0; } /* Char */
+    code span.cn { color: #880000; } /* Constant */
+    code span.co { color: #60a0b0; font-style: italic; } /* Comment */
+    code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
+    code span.do { color: #ba2121; font-style: italic; } /* Documentation */
+    code span.dt { color: #902000; } /* DataType */
+    code span.dv { color: #40a070; } /* DecVal */
+    code span.er { color: #ff0000; font-weight: bold; } /* Error */
+    code span.ex { } /* Extension */
+    code span.fl { color: #40a070; } /* Float */
+    code span.fu { color: #06287e; } /* Function */
+    code span.im { } /* Import */
+    code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
+    code span.kw { color: #007020; font-weight: bold; } /* Keyword */
+    code span.op { color: #666666; } /* Operator */
+    code span.ot { color: #007020; } /* Other */
+    code span.pp { color: #bc7a00; } /* Preprocessor */
+    code span.sc { color: #4070a0; } /* SpecialChar */
+    code span.ss { color: #bb6688; } /* SpecialString */
+    code span.st { color: #4070a0; } /* String */
+    code span.va { color: #19177c; } /* Variable */
+    code span.vs { color: #4070a0; } /* VerbatimString */
+    code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
+  </style>
+  <link rel="stylesheet" href="style.css" />
+  <!--[if lt IE 9]>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
+  <![endif]-->
+</head>
+<body>
+<h2 id="ładowanie-vao-i-vbo">Ładowanie VAO i VBO</h2>
+<p>W trakcie tych zajęć przećwiczymy ładowanie danych do pamięci. Tym razem, zamiast korzystać z gotowej funkcji utworzymy je samodzielnie. W openglu wykorzystujemy do tego VBO (Vertex Buffer Object) i VAO (Vertex Array Object). Pierwsza jest buforem, który zawiera dane modeli. Natomiast drugi zawiera informacje jak dane bufory interpretować.</p>
+<p>W zadaniu <code>2_1</code> będziemy przesyłać prostopadłościan. Tablica zawierająca jego definicję jest w pliku <code>Box.cpp</code>. Każdy wierzchołek składa się z ośmiu floatów, pierwsze cztery określają jego pozycję, a cztery kolejny określają jego kolor.</p>
+<p>Inicjalizacje będziemy wykonywać wewnątrz funkcji <code>init</code>. Pierwszym krokiem jest wygenerowanie jednego VAO i jednego VBO. Wykorzystuje się do tego odpowiednio funkcje <code>glGenVertexArrays</code> i <code>glGenBuffers</code>. Pierwszym argumentem jest liczba buforów czy array object, które tworzymy, drugim jest adres, w którym ma być bufor/array object umieszczony. W naszym przypadku pierwszym argumentem będzie 1, natomiast drugim będzie wskaźnik na zmienną <code>VAO</code> i <code>VBO</code> odpowiednio. Następnie należy aktywować <code>VAO</code> za pomocą funkcji <code>glBindVertexArray</code>, po czym podpiąć do niego bufor <code>VBO</code> za pomocą <code>glBindBuffer(GLenum target, GLuint buffer)</code> nasz target to <code>GL_ARRAY_BUFFER</code>, czyli bufor, który oznacza atrybuty wierzchołków.</p>
+<p>Kolejnym krokiem jest umieszczenie danych w buforze za pomocą funkcji <code>glBufferData(GLenum target, GLsizeiptr size, const void * data, GLenum usage)</code>. Pierwszym argumentem jest ponownie <code>GL_ARRAY_BUFFER</code>, drugi to rozmiar tablicy w bajtach, trzecim adres tablicy, a czwartym sposób używania tablicy, w naszym przypadku <code>GL_STATIC_DRAW</code>.</p>
+<p>Pozostaje opisanie atrybutów wierzchołków, musimy opisać, gdzie się znajdują, jaką mają strukturę i jak ma się do nich odnieść shader. My mamy 2 atrybuty, jest to pozycja i kolor. Pierwszym krokiem jest aktywacja atrybutów za pomocą <code>glEnableVertexAttribArray(GLuint index)</code>, przy czym po indeksie będą one odnajdywane przez shader. W naszym przypadku będą to odpowiednio 0 i 1. Następnie należy opisać jak GPU ma odczytywać atrybuty z bufora za pomocą funkcji <code>glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * offset)</code>. Jej argumenty to kolejno: * <code>index</code> - indeksy odpowiadające atrybutowi, * <code>size</code> - liczba elementów w atrybucie wierzchołka, może wynosić 1, 2, 3 lub 4, * <code>type</code> - typ danych jako enum, w naszym przypadku <code>GL_FLOAT</code>, * <code>normalized</code> - określa czy wartość ma być znormalizowana, u nas będzie to <code>GL_FALSE</code>, * <code>stride</code> - określa dystans pomiędzy atrybutami w kolejnych wierzchołkach * <code>offset</code> - wskaźnik na pierwszy atrybut w tablicy, licząc względem początku tablicy i typu (void *)</p>
+<p>Struktura naszego prostopadłościanu ma na przemian pozycje i kolory, dlatego w obu przypadkach stride będzie wynosił ośmiokrotność rozmiaru <em>floata</em>. Natomiast <em>offest</em> będzie wynosił zero i czterokrotność rozmiaru <em>floata</em>.</p>
+<p><img src="./img/stride_offest.jpg" /></p>
+<p>Na koniec uwolnij <code>VAO</code> za pomocą instrukcji: <code>glBindVertexArray(0);</code>.</p>
+<p>Pozostaje narysować prostopadłościan. W funkcji <code>renderScene</code> wywołaj <code>glBindVertexArray</code> z argumentem <code>VAO</code>. Następnie narysuj za pomocą <code>glDrawArrays(GLenum mode, GLint first, GLsizei count)</code>. Pierwszym argumentem jest typ rysowanego obiektu, w naszym przypadku jest to <code>GL_TRIANGLES</code>, indeks pierwszego wierzchołka, czyli 0 i liczba wierzchołków czyli 36.</p>
+<h3 id="zadanie">Zadanie</h3>
+<p>podążając za powyższymi instrukcjami zainicjalizuj box, następnie obróć go za pomocą funkcji <code>glm::eulerAngleXYZ</code> tak, żeby było widać trzy ściany prostopadłościany. Dodaj również obrót wokół osi Y w czasie z użyciem funkcji <code>glm::eulerAngleXYZ</code>.</p>
+<h3 id="zadanie-1">Zadanie*</h3>
+<p>Wykonaj zadania z <code>ex_2_1b.hpp</code>.</p>
+<h2 id="shadery">Shadery</h2>
+<p>Shadery są programami uruchamianymi na karcie graficznej. W openglu wykorzystujemy język GLSL, który jest bardzo podobny do C++, posiada on liczne słowa kluczowe i funkcje matematyczne. Istnieją różne rodzaje shaderów, w tej sekcji skupimy się na dwóch z nich: shader wierzchołków i shader fragmentów. Pierwszy rodzaj wykonują operacje na wierzchołkach, przykładowo w tym zadaniu odpowiada za przemnożenie macierzy obrotu przez wierzchołki. Natomiast drugi określa kolor konkretnego fragmentu/piksela. Shadery są łączone w <em>pipeline</em>, to znaczy wykonuje się je sekwencyjnie, dane z poprzedniego są wysyłane do następnego. W zadaniu <code>2_1</code> wykorzystujemy następujące shadery</p>
+<p>shader wierzchołków</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode glsl"><code class="sourceCode glsl"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="pp">#version 430 core</span></span>
+<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="kw">layout</span>(<span class="dt">location</span> = <span class="dv">0</span>) <span class="dt">in</span> <span class="dt">vec4</span> vertexPosition;</span>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a><span class="kw">layout</span>(<span class="dt">location</span> = <span class="dv">1</span>) <span class="dt">in</span> <span class="dt">vec4</span> vertexColor;</span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a><span class="kw">uniform</span> <span class="dt">mat4</span> transformation;</span>
+<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> <span class="fu">main</span>()</span>
+<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a>{</span>
+<span id="cb1-11"><a href="#cb1-11" aria-hidden="true" tabindex="-1"></a>    <span class="bu">gl_Position</span> = transformation * vertexPosition;</span>
+<span id="cb1-12"><a href="#cb1-12" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
+<p>shader fragmentów</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode glsl"><code class="sourceCode glsl"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="pp">#version 430 core</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a><span class="dt">out</span> <span class="dt">vec4</span> out_color;</span>
+<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> <span class="fu">main</span>()</span>
+<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a>{</span>
+<span id="cb2-7"><a href="#cb2-7" aria-hidden="true" tabindex="-1"></a>    out_color = <span class="dt">vec4</span>(<span class="fl">0.8</span>,<span class="fl">0.2</span>,<span class="fl">0.9</span>,<span class="fl">1.0</span>);</span>
+<span id="cb2-8"><a href="#cb2-8" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
+<p>Shader wierzchołków odbiera 2 typy danych. Pierwszym są dane z bufora w liniach.</p>
+<pre><code>layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in vec4 vertexColor;</code></pre>
+<p>są one różne dla każdego wierzchołka. Zmienną, która ma odebrać te dane deklaruje się globalnie funkcją <code>main</code> i poprzedza się słowem kluczowym <code>in</code>. Prefiks <code>layout(location = ..)</code> jest opcjonalny i służy określeniu indeksu atrybutu, jest to ta sama wartość, którą ustawiliśmy w <code>glVertexAttribPointer</code>. Można je usunąć, wtedy o indeksie będzie decydować kolejność. Drugim typem jest <code>uniform</code>, w przeciwieństwie do danych z bufora, są one takie same dla każdego wierzchołka. W tym przypadku przesyłamy za jej pomocą macierz obrotu.</p>
+<p>Shader również wysyła dane. Domyślnie musi wysłać wyjściową pozycję wierzchołka, robi to przez zapisanie w <code>gl_Position</code> wektora 4-wymiarowego w funkcji <code>main</code>. Poza tym może również przesłać inne informacje. Wykonuje się to przez deklaracje zmiennej globalnej, którą poprzedza się słowem kluczowym <code>out</code>. Następnie należy ją wypełnić. W tym przypadku przesyłamy kolor wierzchołka.</p>
+<p>Shader fragmentów odbiera kolor z Shadera wierzchołków. Podobnie jak z obieraniem danych z buforu robimy to za pomocą słowa kluczowego <code>in</code>, w przypadku przesyłania zmiennej z jednego shadera do drugiego nazwy zmiennych muszą być <strong>takie same</strong> przy słowie kluczowym <code>out</code> i <code>in</code>. Zmiennej obranej nie można modyfikować.</p>
+<p>W najnowszej wersji opengla fragment shader nie ma domyślnego wyjścia na kolor, musimy sami je z definiować. Robimy to instrukcją <code>out vec4 out_color</code> następnie w funkcji <code>main</code> przypisujemy mu jakąś wartość.</p>
+<h3 id="zadanie-2">Zadanie</h3>
+<p>W tej chwili nasz prostopadłościan jest jednolitego koloru i nie możemy rozróżnić jego ścian. Przesłana przez nas wcześniej informacja o kolorze nie została wykorzystana. Bazując na powyższych informacjach prześlij wartość koloru zapisaną w <code>vertexColor</code> do shadera fragmentu i przypisz ją do wyjściowego koloru. Dodaj zmienną <code>in vec4 color</code> w shaderze fragmentów, następnie w funkcji <code>main</code> przypisz do niej wartość koloru. W shaderze fragmentów odbierz ją za pomocą <code>out</code> i przypisz do wyjściowego koloru.</p>
+<p>Zauważ, że kolor ścian nie jest jednolity, zamiast tego przechodzą gradientem od jednego koloru do drugiego. Dzieje się tak, ponieważ na etapie rasteryzacji kolor jest interpolowany. To znaczy: wartość jest uśredniana pomiędzy wierzchołkami trójkąta.</p>
+<h3 id="zadanie-3">Zadanie</h3>
+<p>Sprawdź, jak będzie wyglądać prostopadłościan z wyłączoną interpolacją. Dodaj przed <code>in</code> i <code>out</code> <code>color</code> słowo kluczowe <code>flat</code>.</p>
+<h3 id="zadanie-4">Zadanie</h3>
+<p>Prześlij czas od startu aplikacji do shadera fragmentów. Użyj funkcji <code>glfwGetTime</code>, by uzyskać czas. Utwórz zmienną <code>uniform</code> typu <code>float</code> we shaderze fragmentów. Następnie prześlij do niej wynik funkcji <code>glfwGetTime</code>. Aby przesłać czas do shadera, wykorzystaj funkcje <code>glUniform1f</code>. Pierwszym argumentem jest lokacja uniforma, drugim przypisywana wartość. Lokację uzyskamy za pomocą funckji <code>glGetUniformLocation(progam,"time")</code> pierwszym argumentem jest program, którego używamy a drugim nazwa zmiennej uniform. Podziel kolor przez czas, by uzyskać efekt, w którym prostopadłościan robi się czarny.</p>
+<h3 id="zadanie-5">Zadanie*</h3>
+<p>Wykorzystaj przesłany czas, żeby sprawić, żeby prostopadłościan znikał przez mieszanie go z kolorem tła. Wykorzystaj do tego następujące funkcje GLSL: <code>mix</code>, <code>sin</code>, <code>vec4</code>. Opis ich działania możesz znaleźć w dokumentacji https://docs.gl/.</p>
+<h3 id="zadanie-6">Zadanie</h3>
+<p>Prześlij pozycję lokalną i globalną pozycję wierzchołków do shadera fragmentów i wyświetl ją.</p>
+<p>W shaderze wierzchołków obok deklaracji <code>out vec4 color;</code> dodaj analogiczne o nazwie <code>pos_local</code> i <code>pos_global</code>. Do <code>pos_local</code> przypisz <code>vertexPosition</code>, a do <code>pos_global</code> przypisz <code>transformation * vertexPosition</code>. Podobnie dopisz odebranie ich w shaderze fragmentów. Użyj <code>pos_local</code>, następnie <code>pos_global</code> jako zamiast koloru. Dlaczego otrzymaliśmy taki efekt?</p>
+<h3 id="zadanie-7">Zadanie*</h3>
+<p>Użyj jednej ze zmiennych z poprzedniego zadania do zrobienia pasków na przynajmniej jednej ze ścian sześcianu. Wykorzystaj czas, żeby paski się przesuwały.</p>
+</body>
+</html>
--- a/2/Zadania
+++ b/2/Zadania
@ -0,0 +1,105 @@
+## Ładowanie VAO i VBO
+
+W trakcie tych zajęć przećwiczymy ładowanie danych do pamięci. Tym razem, zamiast korzystać z gotowej funkcji utworzymy je samodzielnie. W openglu wykorzystujemy do tego VBO (Vertex Buffer Object) i VAO (Vertex Array Object). Pierwsza jest buforem, który zawiera dane modeli. Natomiast drugi zawiera informacje jak dane bufory interpretować. 
+
+W zadaniu `2_1` będziemy przesyłać prostopadłościan. Tablica zawierająca jego definicję jest w pliku `Box.cpp`. Każdy wierzchołek składa się z ośmiu floatów, pierwsze cztery określają jego pozycję, a cztery kolejny określają jego kolor. 
+
+Inicjalizacje będziemy wykonywać wewnątrz funkcji `init`. Pierwszym krokiem jest wygenerowanie jednego VAO i jednego VBO. Wykorzystuje się do tego odpowiednio funkcje `glGenVertexArrays` i  `glGenBuffers`. Pierwszym argumentem jest liczba buforów czy array object, które tworzymy, drugim jest adres, w którym ma być bufor/array object umieszczony. 
+W naszym przypadku pierwszym argumentem będzie 1, natomiast drugim będzie wskaźnik na zmienną `VAO` i `VBO` odpowiednio. Następnie należy aktywować `VAO` za pomocą funkcji `glBindVertexArray`, po czym podpiąć do niego bufor `VBO` za pomocą `glBindBuffer(GLenum target, GLuint buffer)` nasz target to `GL_ARRAY_BUFFER`, czyli bufor, który oznacza atrybuty wierzchołków. 
+
+Kolejnym krokiem jest umieszczenie danych w buforze za pomocą funkcji `glBufferData(GLenum target, GLsizeiptr size, const void * data, GLenum usage)`.  Pierwszym argumentem jest ponownie `GL_ARRAY_BUFFER`, drugi to rozmiar tablicy w bajtach, trzecim adres tablicy, a czwartym sposób używania tablicy, w naszym przypadku `GL_STATIC_DRAW`.
+
+Pozostaje opisanie atrybutów wierzchołków, musimy opisać, gdzie się znajdują, jaką mają strukturę i jak ma się do nich odnieść shader. My mamy 2 atrybuty, jest to pozycja i kolor. Pierwszym krokiem jest aktywacja atrybutów za pomocą `glEnableVertexAttribArray(GLuint index)`, przy czym po indeksie będą one odnajdywane przez shader. W naszym przypadku będą to odpowiednio 0 i 1. Następnie należy opisać jak GPU ma odczytywać atrybuty z bufora za pomocą funkcji `glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * offset)`. Jej argumenty to kolejno:
+* `index` - indeksy odpowiadające atrybutowi,
+* `size` - liczba elementów w atrybucie wierzchołka, może wynosić 1, 2, 3 lub 4,
+* `type` - typ danych jako enum, w naszym przypadku `GL_FLOAT`,
+* `normalized` - określa czy wartość ma być znormalizowana, u nas będzie to `GL_FALSE`,
+* `stride` - określa dystans pomiędzy atrybutami w kolejnych wierzchołkach
+* `offset` - wskaźnik na pierwszy atrybut w tablicy, licząc względem początku tablicy i typu (void \*)
+
+Struktura naszego prostopadłościanu ma na przemian pozycje i kolory, dlatego w obu przypadkach stride będzie wynosił ośmiokrotność rozmiaru *floata*. Natomiast *offest* będzie wynosił zero i czterokrotność rozmiaru *floata*. 
+
+![](./img/stride_offest.jpg)
+
+Na koniec uwolnij `VAO` za pomocą instrukcji: `glBindVertexArray(0);`.
+
+Pozostaje narysować prostopadłościan. W funkcji `renderScene` wywołaj `glBindVertexArray` z argumentem `VAO`. Następnie narysuj za pomocą `glDrawArrays(GLenum mode, GLint first, GLsizei count)`.  Pierwszym argumentem jest typ rysowanego obiektu, w naszym przypadku jest to `GL_TRIANGLES`, indeks pierwszego wierzchołka, czyli 0 i liczba wierzchołków czyli 36.
+
+### Zadanie 
+podążając za powyższymi instrukcjami zainicjalizuj box, następnie obróć go za pomocą funkcji `glm::eulerAngleXYZ` tak, żeby było widać trzy ściany prostopadłościany. Dodaj również obrót wokół osi Y w czasie z użyciem funkcji `glm::eulerAngleXYZ`.
+
+### Zadanie* 
+Wykonaj zadania z `ex_2_1b.hpp`. 
+
+
+## Shadery
+
+Shadery są programami uruchamianymi na karcie graficznej. W openglu wykorzystujemy język GLSL, który jest bardzo podobny do C++, posiada on liczne słowa kluczowe i funkcje matematyczne. Istnieją różne rodzaje shaderów, w tej sekcji skupimy się na dwóch z nich: shader wierzchołków i shader fragmentów. Pierwszy rodzaj wykonują operacje na wierzchołkach, przykładowo w tym zadaniu odpowiada za przemnożenie macierzy obrotu przez wierzchołki. Natomiast drugi określa kolor konkretnego fragmentu/piksela. Shadery są łączone w *pipeline*, to znaczy wykonuje się je sekwencyjnie, dane z poprzedniego są wysyłane do następnego. 
+W zadaniu `2_1` wykorzystujemy następujące shadery
+
+shader wierzchołków
+```GLSL
+#version 430 core
+
+layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in vec4 vertexColor;
+
+uniform mat4 transformation;
+
+
+void main()
+{
+	gl_Position = transformation * vertexPosition;
+}
+```
+
+shader fragmentów
+```GLSL
+#version 430 core
+
+
+out vec4 out_color;
+void main()
+{
+	out_color = vec4(0.8,0.2,0.9,1.0);
+}
+```
+
+Shader wierzchołków odbiera 2 typy danych. Pierwszym są dane z bufora w liniach.
+```
+layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in vec4 vertexColor;
+```
+są one różne dla każdego wierzchołka. Zmienną, która ma odebrać te dane deklaruje się globalnie funkcją `main` i poprzedza się słowem kluczowym `in`.  Prefiks `layout(location = ..)` jest opcjonalny i służy określeniu indeksu atrybutu, jest to ta sama wartość, którą ustawiliśmy w `glVertexAttribPointer`. Można je usunąć, wtedy o indeksie będzie decydować kolejność.
+Drugim typem jest `uniform`, w przeciwieństwie do danych z bufora, są one takie same dla każdego wierzchołka. W tym przypadku przesyłamy za jej pomocą macierz obrotu. 
+
+Shader również wysyła dane. Domyślnie musi wysłać wyjściową pozycję wierzchołka, robi to przez zapisanie w `gl_Position` wektora 4-wymiarowego w funkcji `main`. Poza tym może również przesłać inne informacje. Wykonuje się to przez deklaracje zmiennej globalnej, którą poprzedza się słowem kluczowym `out`. Następnie należy ją wypełnić. W tym przypadku przesyłamy kolor wierzchołka. 
+
+Shader fragmentów odbiera kolor z Shadera wierzchołków. Podobnie jak z obieraniem danych z buforu robimy to za pomocą słowa kluczowego `in`, w przypadku przesyłania zmiennej z jednego shadera do drugiego nazwy zmiennych muszą być **takie same** przy słowie kluczowym `out` i `in`. Zmiennej obranej nie można modyfikować.
+
+W najnowszej wersji opengla fragment shader nie ma domyślnego wyjścia na kolor, musimy sami je z definiować. Robimy to instrukcją `out vec4 out_color` następnie w funkcji `main` przypisujemy mu jakąś wartość. 
+
+### Zadanie 
+W tej chwili nasz prostopadłościan jest jednolitego koloru i nie możemy rozróżnić jego ścian. Przesłana przez nas wcześniej informacja o kolorze nie została wykorzystana. Bazując na powyższych informacjach prześlij wartość koloru zapisaną w `vertexColor` do shadera fragmentu i przypisz ją do wyjściowego koloru. Dodaj zmienną `in vec4 color` w shaderze fragmentów, następnie w funkcji `main` przypisz do niej wartość koloru. W shaderze fragmentów odbierz ją za pomocą `out` i przypisz do wyjściowego koloru.
+
+Zauważ, że kolor ścian nie jest jednolity, zamiast tego przechodzą gradientem od jednego koloru do drugiego. Dzieje się tak, ponieważ na etapie rasteryzacji kolor jest interpolowany. To znaczy: wartość jest uśredniana pomiędzy wierzchołkami trójkąta. 
+
+### Zadanie
+Sprawdź, jak będzie wyglądać prostopadłościan z wyłączoną interpolacją. Dodaj przed `in` i `out` ` color` słowo kluczowe `flat`.
+
+### Zadanie
+Prześlij czas od startu aplikacji do shadera fragmentów. Użyj funkcji `glfwGetTime`, by uzyskać czas. Utwórz zmienną `uniform` typu `float` we shaderze fragmentów. Następnie prześlij do niej wynik funkcji `glfwGetTime`. Aby przesłać czas do shadera, wykorzystaj funkcje `glUniform1f`. Pierwszym argumentem jest lokacja uniforma, drugim przypisywana wartość. Lokację uzyskamy za pomocą funckji `glGetUniformLocation(progam,"time")` pierwszym argumentem jest program, którego używamy a drugim nazwa zmiennej uniform. 
+Podziel kolor przez czas, by uzyskać efekt, w którym prostopadłościan robi się czarny.
+
+### Zadanie* 
+Wykorzystaj przesłany czas, żeby sprawić, żeby prostopadłościan znikał przez mieszanie go z kolorem tła. Wykorzystaj do tego następujące funkcje GLSL: `mix`, `sin`, `vec4`. Opis ich działania możesz znaleźć w dokumentacji https://docs.gl/.
+
+### Zadanie  
+
+Prześlij pozycję lokalną i globalną pozycję wierzchołków do shadera fragmentów i wyświetl ją.
+
+W shaderze wierzchołków obok deklaracji `out vec4 color;` dodaj analogiczne o nazwie `pos_local` i `pos_global`. Do `pos_local` przypisz `vertexPosition`, a do `pos_global` przypisz `transformation * vertexPosition`. Podobnie dopisz odebranie ich w shaderze fragmentów. Użyj `pos_local`, następnie `pos_global` jako zamiast koloru. Dlaczego otrzymaliśmy taki efekt?
+
+### Zadanie*
+Użyj jednej ze zmiennych z poprzedniego zadania do zrobienia pasków na przynajmniej jednej ze ścian sześcianu. Wykorzystaj czas, żeby paski się przesuwały. 
+
--- a/2/assimp-vc141-mt.dll
+++ b/2/assimp-vc141-mt.dll
--- a/2/assimp-vc141-mtd.dll
+++ b/2/assimp-vc141-mtd.dll
--- a/2/freeglut.dll
+++ b/2/freeglut.dll
--- a/2/glew32.dll
+++ b/2/glew32.dll
--- a/2/grk-cw2.vcxproj
+++ b/2/grk-cw2.vcxproj
@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Box.cpp" />
+    <ClCompile Include="src\Camera.cpp" />
+    <ClCompile Include="src\main.cpp" />
+    <ClCompile Include="src\Render_Utils.cpp" />
+    <ClCompile Include="src\Shader_Loader.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="src\Camera.h" />
+    <ClInclude Include="src\ex_2_1a.hpp" />
+    <ClInclude Include="src\ex_2_1b.hpp" />
+    <ClInclude Include="src\ex_2_2.hpp" />
+    <ClInclude Include="src\Render_Utils.h" />
+    <ClInclude Include="src\Shader_Loader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="shaders\shader_2_1.frag" />
+    <None Include="shaders\shader_2_1.vert" />
+    <None Include="shaders\shader_2_1b.frag" />
+    <None Include="shaders\shader_2_1b.vert" />
+    <None Include="shaders\shader_2_2.frag" />
+    <None Include="shaders\shader_2_2.vert" />
+    <None Include="shaders\shader_2_3.frag" />
+    <None Include="shaders\shader_2_3.vert" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B4031E08-6274-4FFD-B41C-F8EA29E977FB}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>grk-cw9</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <ProjectName>grk-cw2</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <LibraryPath>$(SolutionDir)dependencies\freeglut\lib;$(SolutionDir)dependencies\glew-2.0.0\lib\Release\Win32;$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019;$(SolutionDir)dependencies\assimp;$(LibraryPath)</LibraryPath>
+    <IncludePath>$(SolutionDir)dependencies\freeglut\include\GL;$(SolutionDir)dependencies\glew-2.0.0\include\GL;$(SolutionDir)dependencies\glm;$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\include;$(SolutionDir)dependencies\assimp\include;$(IncludePath)</IncludePath>
+    <ExecutablePath>$(ExecutablePath)</ExecutablePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(SolutionDir)dependencies\freeglut\include\GL;$(SolutionDir)dependencies\glew-2.0.0\include\GL;$(SolutionDir)dependencies\glm;$(IncludePath)</IncludePath>
+    <LibraryPath>$(SolutionDir)dependencies\freeglut\lib;$(SolutionDir)dependencies\glew-2.0.0\lib\Release\Win32;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>opengl32.lib;freeglut.lib;glew32.lib;$(SolutionDir)\dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019\glfw3.lib;$(SolutionDir)\dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019\glfw3dll.lib;zlibd.lib;assimp-vc141-mtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)dependencies\glfw-3.3.8.bin.WIN32\lib-vc2019;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>opengl32.lib;freeglut.lib;glew32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
--- a/2/grk-cw2.vcxproj.filters
+++ b/2/grk-cw2.vcxproj.filters
@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <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>{0a247bb8-2e8e-4a90-b0ef-17415b0941ba}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Shader_Loader.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>
+    <ClCompile Include="src\Render_Utils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="src\Shader_Loader.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Camera.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Render_Utils.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_2_1a.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_2_1b.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\ex_2_2.hpp">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="shaders\shader_2_1.vert">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_1b.frag">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_1b.vert">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_2.frag">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_2.vert">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_3.frag">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_3.vert">
+      <Filter>Shader Files</Filter>
+    </None>
+    <None Include="shaders\shader_2_1.frag">
+      <Filter>Shader Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>
--- a/2/img/2.png
+++ b/2/img/2.png
--- a/2/img/3.webp
+++ b/2/img/3.webp
--- a/2/img/384px-PerlinNoiseDotProducts.png
+++ b/2/img/384px-PerlinNoiseDotProducts.png
--- a/2/img/384px-PerlinNoiseInterpolated.png
+++ b/2/img/384px-PerlinNoiseInterpolated.png
--- a/2/img/4.png
+++ b/2/img/4.png
--- a/2/img/5.webp
+++ b/2/img/5.webp
--- a/2/img/6.webp
+++ b/2/img/6.webp
--- a/2/img/7.webp
+++ b/2/img/7.webp
--- a/2/img/8.webp
+++ b/2/img/8.webp
--- a/2/img/PerlinNoiseDotProducts.png
+++ b/2/img/PerlinNoiseDotProducts.png
--- a/2/img/PerlinNoiseGradientGrid.png
+++ b/2/img/PerlinNoiseGradientGrid.png
--- a/2/img/PerlinNoiseInterpolated.png
+++ b/2/img/PerlinNoiseInterpolated.png
--- a/2/img/blending1.webp
+++ b/2/img/blending1.webp
--- a/2/img/camera.jpg
+++ b/2/img/camera.jpg
--- a/2/img/capture.webm
+++ b/2/img/capture.webm
--- a/2/img/coordinate_systems.jpg
+++ b/2/img/coordinate_systems.jpg
--- a/2/img/cubemaps_sampling.png
+++ b/2/img/cubemaps_sampling.png
--- a/2/img/gamma_correction_brightness.png
+++ b/2/img/gamma_correction_brightness.png
--- a/2/img/lighting_result.png
+++ b/2/img/lighting_result.png
--- a/2/img/noise_examples.jpg
+++ b/2/img/noise_examples.jpg
--- a/2/img/shadow_mapping_projection.png
+++ b/2/img/shadow_mapping_projection.png
--- a/2/img/shadows1.bmp
+++ b/2/img/shadows1.bmp
--- a/2/img/spotlight.png
+++ b/2/img/spotlight.png
--- a/2/img/stride_offest.jpg
+++ b/2/img/stride_offest.jpg
--- a/2/img/stride_offest_2_2.jpg
+++ b/2/img/stride_offest_2_2.jpg
--- a/2/img/struktura.jpg
+++ b/2/img/struktura.jpg
--- a/2/img/sun.png
+++ b/2/img/sun.png
--- a/2/img/textures.png
+++ b/2/img/textures.png
--- a/2/img/z_depth_graph.jpg
+++ b/2/img/z_depth_graph.jpg
--- a/2/img/z_depth_graph2.jpg
+++ b/2/img/z_depth_graph2.jpg
--- a/2/render.py
+++ b/2/render.py
@ -0,0 +1,7 @@
+
+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')   
--- a/2/shaders/shader_2_1.frag
+++ b/2/shaders/shader_2_1.frag
@ -0,0 +1,15 @@
+#version 430 core
+in vec4 color;
+
+uniform float time;
+out vec4 out_color;
+in vec4 pos_global;
+in vec4 pos_local;
+void main()
+{
+	float stripeOffset = mod(gl_FragCoord.y + time * 50.0, 50.0);
+    float stripe = step(40.0, stripeOffset);
+	
+	vec4 Mixcolor = mix(color, vec4(1.0f, 1.0f, 0.0f, 1.0f),  stripe);
+	out_color = Mixcolor ;
+}
--- a/2/shaders/shader_2_1.vert
+++ b/2/shaders/shader_2_1.vert
@ -0,0 +1,17 @@
+#version 430 core
+
+layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in vec4 vertexColor;
+
+uniform mat4 transformation;
+
+out vec4 color;
+out vec4 pos_global;
+out vec4 pos_local;
+void main()
+{
+	color = vertexColor;
+	pos_global = transformation * vertexPosition;
+	pos_local = vertexPosition;
+	gl_Position = transformation * vertexPosition;
+}
--- a/2/shaders/shader_2_1b.frag
+++ b/2/shaders/shader_2_1b.frag
@ -0,0 +1,16 @@
+#version 430 core
+out vec4 fragColor;
+
+in float hue;
+out vec4 out_color;
+
+vec3 hsv2rgb(vec3 c)
+{
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+void main()
+{
+	out_color  = vec4(hsv2rgb(vec3(hue,1,1)), 1.0);
+}
--- a/2/shaders/shader_2_1b.vert
+++ b/2/shaders/shader_2_1b.vert
@ -0,0 +1,11 @@
+#version 430 core
+
+layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in float vertexHue;
+
+out float hue;
+void main()
+{
+	hue = vertexHue;
+	gl_Position = vertexPosition;
+}
--- a/2/shaders/shader_2_2.frag
+++ b/2/shaders/shader_2_2.frag
@ -0,0 +1,7 @@
+#version 430 core
+
+out vec4 out_color;
+void main()
+{
+	out_color = color;
+}
--- a/2/shaders/shader_2_2.vert
+++ b/2/shaders/shader_2_2.vert
@ -0,0 +1,12 @@
+#version 430 core
+
+layout(location = 0) in vec3 vertexPosition;
+layout(location = 1) in vec2 vertexTexCoord;
+layout(location = 2) in vec3 vertexNormal;
+
+uniform mat4 transformation;
+
+void main()
+{
+	gl_Position = transformation * vec4(vertexPosition, 1.0);
+}
--- a/2/shaders/shader_2_3.frag
+++ b/2/shaders/shader_2_3.frag
@ -0,0 +1,7 @@
+#version 430 core
+
+out vec4 out_color;
+void main()
+{
+	out_color = color;
+}
--- a/2/shaders/shader_2_3.vert
+++ b/2/shaders/shader_2_3.vert
@ -0,0 +1,13 @@
+#version 430 core
+
+layout(location = 0) in vec3 vertexPosition;
+layout(location = 1) in vec2 vertexTexCoord;
+layout(location = 2) in vec3 vertexNormal;
+
+uniform mat4 transformation;
+uniform mat4 model;
+
+void main()
+{
+	gl_Position = transformation * model * vec4(vertexPosition, 1.0);
+}
--- a/2/src/Box.cpp
+++ b/2/src/Box.cpp
@ -0,0 +1,55 @@
+
+
+// dane 36 wierzcholkow i kolorow opisujace model pudelka
+const float box[] = {
+
+//  points							colors
+	0.25f, 0.25f, 0.75f, 1.0f,		0.5f, 0.5f, 1.0f, 1.0f,
+	0.25f, -0.25f, 0.75f, 1.0f,		0.5f, 0.5f, 1.0f, 1.0f,
+	-0.25f, 0.25f, 0.75f, 1.0f,		0.0f, 0.0f, 1.0f, 1.0f,
+
+	0.25f, -0.25f, 0.75f, 1.0f,		0.5f, 0.5f, 1.0f, 1.0f,
+	-0.25f, -0.25f, 0.75f, 1.0f,	0.0f, 0.0f, 1.0f, 1.0f,
+	-0.25f, 0.25f, 0.75f, 1.0f,		0.0f, 0.0f, 1.0f, 1.0f,
+
+	0.25f, 0.25f, -0.75f, 1.0f,		1.0f, 1.0f, 1.0f, 1.0f,
+	-0.25f, 0.25f, -0.75f, 1.0f,	1.0f, 1.0f, 1.0f, 1.0f,
+	0.25f, -0.25f, -0.75f, 1.0f,	0.5f, 0.5f, 0.5f, 1.0f,
+
+	0.25f, -0.25f, -0.75f, 1.0f,	0.5f, 0.5f, 0.5f, 1.0f,
+	-0.25f, 0.25f, -0.75f, 1.0f,	1.0f, 1.0f, 1.0f, 1.0f,
+	-0.25f, -0.25f, -0.75f, 1.0f,	0.5f, 0.5f, 0.5f, 1.0f,
+
+	-0.25f, 0.25f, 0.75f, 1.0f,		0.2f, 0.0f, 0.2f, 1.0f,
+	-0.25f, -0.25f, 0.75f, 1.0f,	0.2f, 0.0f, 0.2f, 1.0f,
+	-0.25f, -0.25f, -0.75f, 1.0f,	0.0f, 1.0f, 0.0f, 1.0f,
+	 
+	-0.25f, 0.25f, 0.75f, 1.0f,		0.2f, 0.0f, 0.2f, 1.0f,
+	-0.25f, -0.25f, -0.75f, 1.0f,	0.0f, 1.0f, 0.0f, 1.0f,
+	-0.25f, 0.25f, -0.75f, 1.0f,	0.0f, 1.0f, 0.0f, 1.0f,
+
+	0.25f, 0.25f, 0.75f, 1.0f,		1.0f, 0.2f, 0.0f, 1.0f,
+	0.25f, -0.25f, -0.75f, 1.0f,	0.5f, 0.5f, 0.0f, 1.0f,
+	0.25f, -0.25f, 0.75f, 1.0f,		0.5f, 0.5f, 0.0f, 1.0f,
+
+	0.25f, 0.25f, 0.75f, 1.0f,		1.0f, 0.2f, 0.0f, 1.0f,
+	0.25f, 0.25f, -0.75f, 1.0f,		0.5f, 0.5f, 0.0f, 1.0f,
+	0.25f, -0.25f, -0.75f, 1.0f,	0.5f, 0.5f, 0.0f, 1.0f,
+
+	0.25f, 0.25f, -0.75f, 1.0f,		0.0f, 1.0f, 0.0f, 1.0f,
+	0.25f, 0.25f, 0.75f, 1.0f,		0.0f, 1.0f, 0.0f, 1.0f,
+	-0.25f, 0.25f, 0.75f, 1.0f,		1.0f, 0.0f, 0.0f, 1.0f,
+
+	0.25f, 0.25f, -0.75f, 1.0f,		0.0f, 1.0f, 0.0f, 1.0f,
+	-0.25f, 0.25f, 0.75f, 1.0f,		1.0f, 0.0f, 0.0f, 1.0f,
+	-0.25f, 0.25f, -0.75f, 1.0f,	1.0f, 0.0f, 0.0f, 1.0f,
+
+	0.25f, -0.25f, -0.75f, 1.0f,	1.0f, 1.0f, 1.0f, 1.0f,
+	-0.25f, -0.25f, 0.75f, 1.0f,	1.0f, 0.0f, 1.0f, 1.0f,
+	0.25f, -0.25f, 0.75f, 1.0f,		1.0f, 1.0f, 1.0f, 1.0f,
+
+	0.25f, -0.25f, -0.75f, 1.0f,	1.0f, 1.0f, 1.0f, 1.0f,
+	-0.25f, -0.25f, -0.75f, 1.0f,	1.0f, 0.0f, 1.0f, 1.0f,
+	-0.25f, -0.25f, 0.75f, 1.0f,	1.0f, 0.0f, 1.0f, 1.0f,
+};
+
--- a/2/src/Camera.cpp
+++ b/2/src/Camera.cpp
@ -0,0 +1,32 @@
+#include "Camera.h"
+
+glm::mat4 Core::createPerspectiveMatrix(float zNear, float zFar)
+{
+	const float frustumScale = 1.0f;
+	glm::mat4 perspective;
+	perspective[0][0] = frustumScale;
+	perspective[1][1] = frustumScale;
+	perspective[2][2] = (zFar + zNear) / (zNear - zFar);
+	perspective[3][2] = (2 * zFar * zNear) / (zNear - zFar);
+	perspective[2][3] = -1;
+	perspective[3][3] = 0;
+
+	return perspective;
+}
+
+glm::mat4 Core::createViewMatrix( glm::vec3 position, glm::vec3 forward, glm::vec3 up )
+{
+	glm::vec3 side = glm::cross(forward, up);
+
+	// Trzeba pamietac o minusie przy ustawianiu osi Z kamery.
+	// Wynika to z tego, ze standardowa macierz perspektywiczna zaklada, ze "z przodu" jest ujemna (a nie dodatnia) czesc osi Z.
+	glm::mat4 cameraRotation;
+	cameraRotation[0][0] = side.x; cameraRotation[1][0] = side.y; cameraRotation[2][0] = side.z;
+	cameraRotation[0][1] = up.x; cameraRotation[1][1] = up.y; cameraRotation[2][1] = up.z;
+	cameraRotation[0][2] = -forward.x; cameraRotation[1][2] = -forward.y; cameraRotation[2][2] = -forward.z;
+
+	glm::mat4 cameraTranslation;
+	cameraTranslation[3] = glm::vec4(-position, 1.0f);
+
+	return cameraRotation * cameraTranslation;
+}
--- a/2/src/Camera.h
+++ b/2/src/Camera.h
@ -0,0 +1,14 @@
+#pragma once
+
+#include "glm.hpp"
+
+namespace Core
+{
+	glm::mat4 createPerspectiveMatrix(float zNear = 0.1f, float zFar = 100.0f);
+
+	// position - pozycja kamery
+	// forward - wektor "do przodu" kamery (jednostkowy)
+	// up - wektor "w gore" kamery (jednostkowy)
+	// up i forward musza byc ortogonalne!
+	glm::mat4 createViewMatrix(glm::vec3 position, glm::vec3 forward, glm::vec3 up);
+}
--- a/2/src/Render_Utils.cpp
+++ b/2/src/Render_Utils.cpp
@ -0,0 +1,36 @@
+#include "Render_Utils.h"
+
+#include <algorithm>
+
+#include "glew.h"
+#include "freeglut.h"
+
+
+void Core::DrawContext(Core::RenderContext& context)
+{
+
+	glBindVertexArray(context.vertexArray);
+	glDrawElements(
+		GL_TRIANGLES,      // mode
+		context.size,    // count
+		GL_UNSIGNED_SHORT,   // type
+		(void*)0           // element array buffer offset
+	);
+	glBindVertexArray(0);
+}
+
+
+void Core::deleteVAO(GLuint VAO) {
+    GLint nAttr = 0;
+    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nAttr);
+    glBindVertexArray(VAO);
+    for (int iAttr = 0; iAttr < nAttr; ++iAttr) {
+        GLint vboId = 0;
+        glGetVertexAttribiv(iAttr, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &vboId);
+        if (vboId > 0) {
+            GLuint _v = GLuint(vboId);
+            glDeleteBuffers(1, &_v);
+        }
+    }
+    glDeleteVertexArrays(1, &VAO);
+}
--- a/2/src/Render_Utils.h
+++ b/2/src/Render_Utils.h
@ -0,0 +1,72 @@
+#pragma once
+#include "glm.hpp"
+#include "glew.h"
+//#include "objload.h"
+#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+#include <vector>
+#include <iostream>
+
+#define BUFFER_OFFSET(i) ((void*)(i))
+
+namespace Core
+{
+
+
+	struct RenderContext {
+		GLuint vertexArray;
+		GLuint vertexBuffer;
+		GLuint vertexIndexBuffer;
+		unsigned int size = 0;
+
+		void initFromAiMesh(aiMesh* mesh) {
+			vertexArray = 0;
+			vertexBuffer = 0;
+			vertexIndexBuffer = 0;
+
+
+            std::vector<float> textureCoord;
+            std::vector<unsigned int> indices;
+            //tex coord must be converted to 2d vecs
+            for (unsigned int i = 0; i < mesh->mNumVertices; i++)
+            {
+                if (mesh->mTextureCoords[0] != nullptr) {
+                    textureCoord.push_back(mesh->mTextureCoords[0][i].x);
+                    textureCoord.push_back(mesh->mTextureCoords[0][i].y);
+                }
+                else {
+                    textureCoord.push_back(0.0f);
+                    textureCoord.push_back(0.0f);
+                }
+            }
+            if (mesh->mTextureCoords[0] == nullptr) {
+                std::cout << "no uv coords\n";
+            }
+            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]);
+            }
+
+            unsigned int vertexDataBufferSize = sizeof(float) * mesh->mNumVertices * 3;
+            unsigned int vertexNormalBufferSize = sizeof(float) * mesh->mNumVertices * 3;
+            unsigned int vertexTexBufferSize = sizeof(float) * mesh->mNumVertices * 2;
+
+		}
+
+		~RenderContext() {
+			glDeleteBuffers(1, &vertexBuffer);
+			glDeleteBuffers(1, &vertexIndexBuffer);
+			glDeleteVertexArrays(1, &vertexArray);
+		}
+
+	};
+
+	void DrawContext(RenderContext& context);
+
+    void deleteVAO(GLuint VAO);
+}
+
--- a/2/src/Shader_Loader.cpp
+++ b/2/src/Shader_Loader.cpp
@ -0,0 +1,102 @@
+#include "Shader_Loader.h" 
+#include<iostream>
+#include<fstream>
+#include<vector>
+
+using namespace Core;
+
+Shader_Loader::Shader_Loader(void){}
+Shader_Loader::~Shader_Loader(void){}
+
+std::string Shader_Loader::ReadShader(char *filename)
+{
+
+	std::string shaderCode;
+	std::ifstream file(filename, std::ios::in);
+
+	if (!file.good())
+	{
+		std::cout << "Can't read file " << filename << std::endl;
+		std::terminate();
+	}
+
+	file.seekg(0, std::ios::end);
+	shaderCode.resize((unsigned int)file.tellg());
+	file.seekg(0, std::ios::beg);
+	file.read(&shaderCode[0], shaderCode.size());
+	file.close();
+	return shaderCode;
+}
+
+GLuint Shader_Loader::CreateShader(GLenum shaderType, std::string
+	source, char* shaderName)
+{
+
+	int compile_result = 0;
+
+	GLuint shader = glCreateShader(shaderType);
+	const char *shader_code_ptr = source.c_str();
+	const int shader_code_size = source.size();
+
+	glShaderSource(shader, 1, &shader_code_ptr, &shader_code_size);
+	glCompileShader(shader);
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_result);
+
+	//sprawdz bledy
+	if (compile_result == GL_FALSE)
+	{
+
+		int info_log_length = 0;
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);
+		std::vector<char> shader_log(info_log_length);
+		glGetShaderInfoLog(shader, info_log_length, NULL, &shader_log[0]);
+		std::cout << "ERROR compiling shader: " << shaderName << std::endl << &shader_log[0] << std::endl;
+		return 0;
+	}
+
+	return shader;
+}
+
+GLuint Shader_Loader::CreateProgram(char* vertexShaderFilename,
+	char* fragmentShaderFilename)
+{
+
+	//wczytaj shadery
+	std::string vertex_shader_code = ReadShader(vertexShaderFilename);
+	std::string fragment_shader_code = ReadShader(fragmentShaderFilename);
+
+	GLuint vertex_shader = CreateShader(GL_VERTEX_SHADER, vertex_shader_code, "vertex shader");
+	GLuint fragment_shader = CreateShader(GL_FRAGMENT_SHADER, fragment_shader_code, "fragment shader");
+
+	int link_result = 0;
+	//stworz shader
+	GLuint program = glCreateProgram();
+	glAttachShader(program, vertex_shader);
+	glAttachShader(program, fragment_shader);
+
+	glLinkProgram(program);
+	glGetProgramiv(program, GL_LINK_STATUS, &link_result);
+	//sprawdz bledy w linkerze
+	if (link_result == GL_FALSE)
+	{
+
+		int info_log_length = 0;
+		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);
+		std::vector<char> program_log(info_log_length);
+		glGetProgramInfoLog(program, info_log_length, NULL, &program_log[0]);
+		std::cout << "Shader Loader : LINK ERROR" << std::endl << &program_log[0] << std::endl;
+		return 0;
+	}
+
+	glDetachShader(program, vertex_shader);
+	glDetachShader(program, fragment_shader);
+	glDeleteShader(vertex_shader);
+	glDeleteShader(fragment_shader);
+
+	return program;
+}
+
+void Shader_Loader::DeleteProgram( GLuint program )
+{
+	glDeleteProgram(program);
+}
--- a/2/src/Shader_Loader.h
+++ b/2/src/Shader_Loader.h
@ -0,0 +1,29 @@
+#pragma once
+
+#include "glew.h"
+#include "freeglut.h"
+#include <iostream>
+
+namespace Core
+{
+
+	class Shader_Loader
+	{
+	private:
+
+		std::string ReadShader(char *filename);
+		GLuint CreateShader(GLenum shaderType,
+			std::string source,
+			char* shaderName);
+
+	public:
+
+		Shader_Loader(void);
+		~Shader_Loader(void);
+		GLuint CreateProgram(char* VertexShaderFilename,
+			char* FragmentShaderFilename);
+
+		void DeleteProgram(GLuint program);
+
+	};
+}
--- a/2/src/ex_2_1a
+++ b/2/src/ex_2_1a
@ -0,0 +1,101 @@
+#pragma once
+#include "glew.h"
+#include "glm.hpp"
+#include "ext.hpp"
+#include <iostream>
+#include <cmath>
+#include <GLFW/glfw3.h>
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+#include "Box.cpp"
+
+
+GLuint program;
+Core::Shader_Loader shaderLoader;
+
+GLuint VAO,VBO;
+void renderScene(GLFWwindow* window)
+{
+	float time = glfwGetTime();
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	// ZADANIE: W zalaczonym wyzej pliku Box.cpp znajduja sie tablice pozycji i kolorow wierzcholkow prostopadloscianu. Przesun go o wektor (0.5, 0.5, -0.2) i wyswietl go.
+	// 
+	// Do shadera uzytego w tym zadaniu nalezy przeslac nie tylko pozycje, ale rowniez kolory wierzcholkow.
+	// W funkcji init należy przesłać pozycje i kolory do GPU 
+
+	glUseProgram(program);
+
+	// Powiąż stworzone VAO za pomocą funkcji glBindVertexArray
+	// wykorzystaj glDrawArrays do narysowania prostopadłościanu
+
+	glm::mat4 transformation= glm::eulerAngleXYZ(0.9f,time/2,0.0f);
+	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transformation);
+
+	glUseProgram(0);
+	glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+	glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window)
+{
+	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+	glEnable(GL_DEPTH_TEST);
+	program = shaderLoader.CreateProgram("shaders/shader_2_1.vert", "shaders/shader_2_1.frag");
+	// Dokładny opis działania funkcji z poniższych punktów można znaleźć na slajdach z wykładu, w dokumentacji https://www.khronos.org/registry/OpenGL-Refpages/gl4/ funkcje są opisane także na stronach https://learnopengl.com/Getting-started/Hello-Triangle https://learnopengl.com/Getting-started/Shaders oraz https://open.gl/drawing
+	// W tablicy box są pozycje i kolory kostki, celem zajęć jest narysowanie tej kostki 
+	// Zainicjalizuj VertexArrayObject (VAO) i zapisz w nim atrybuty prostopadłościanu
+	// I Stwórz VAO
+	// 1. Stwórz nowy VAO za pomocą glGenVertexArrays i przypisz jego adres do zmiennej globalnej
+	// 2. Powiąż stworzone VAO za pomocą funkcji glBindVertexArray
+	// II Zainicjalizuj VBO
+	// 3. Stwórz VertexBufferObject do przechowywania pozycji wierzchołków za pomocą funkcji glGenBuffers
+	// 4. Powiąż stworzone VBO za pomocą funkcji glBindBuffer(GLenum target, GLuint )
+	// 5. Zaalokuj w GPU miejsce na tablice box i zaalakokuj ją za pomocą glBufferData
+	//std::cout << sizeof(box);
+	// II Stwórz definicję danych w buforze
+	// 6. Aktywuj atrybut powiązany z pozycją wierchołków za pomocą glEnableVertexAttribArray(GLuint index). Indeks jest zapisany w shaderze wierzchołków w 3. lini. Można odpytać shader o indeks za pomocą funkcji glGetAttribLocation(GL uint program, const GLchar *name)
+	// 6. Aktywuj atrybut powiązany z kolorem wierchołków za pomocą glEnableVertexAttribArray(GLuint index). Indeks jest zapisany w shaderze wierzchołków w 4. lini. Można odpytać shader o indeks za pomocą funkcji glGetAttribLocation(GL uint program, const GLchar *name)
+
+	// 8. Zdefiniuj jak OpenGL powinien interpretować dane za pomocą glVertexAttribPointer
+
+	// w renderScene!
+	//glBindVertexArray(VAO);
+	///glDrawArrays(GL_TRIANGLES, 0, 36);
+
+	// 9. Uwolnij VAO za pomocą funkcji glBindVertexArray(0)
+	glBindVertexArray(0);
+}
+
+
+
+void shutdown(GLFWwindow* window)
+{
+	shaderLoader.DeleteProgram(program);
+}
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+		glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+	while (!glfwWindowShouldClose(window))
+	{
+		processInput(window);
+
+		renderScene(window);
+		glfwPollEvents();
+	}
+}
+//}
--- a/2/src/ex_2_1a.hpp
+++ b/2/src/ex_2_1a.hpp
@ -0,0 +1,115 @@
+#pragma once
+#include "glew.h"
+#include "glm.hpp"
+#include "ext.hpp"
+#include <iostream>
+#include <cmath>
+#include <GLFW/glfw3.h>
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+#include "Box.cpp"
+
+
+GLuint program;
+Core::Shader_Loader shaderLoader;
+
+GLuint VAO, VBO;
+void renderScene(GLFWwindow* window)
+{
+	float time = glfwGetTime();
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	// ZADANIE: W zalaczonym wyzej pliku Box.cpp znajduja sie tablice pozycji i kolorow wierzcholkow prostopadloscianu. Przesun go o wektor (0.5, 0.5, -0.2) i wyswietl go.
+	// 
+	// Do shadera uzytego w tym zadaniu nalezy przeslac nie tylko pozycje, ale rowniez kolory wierzcholkow.
+	// W funkcji init należy przesłać pozycje i kolory do GPU 
+
+	glUseProgram(program);
+
+	time = glfwGetTime();
+	glm::mat4 transformation = glm::eulerAngleXYZ(0.3f, time, 0.2f);
+	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transformation);
+	GLint customValueLocation = glGetUniformLocation(program, "time");
+	glUniform1f(customValueLocation, sin(time));
+	glBindVertexArray(VAO);
+	glDrawArrays(GL_TRIANGLES, 0, 36);
+
+	glUseProgram(0);
+	glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+	glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window)
+{
+	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+	glEnable(GL_DEPTH_TEST);
+	program = shaderLoader.CreateProgram("shaders/shader_2_1.vert", "shaders/shader_2_1.frag");
+	// Dokładny opis działania funkcji z poniższych punktów można znaleźć na slajdach z wykładu, w dokumentacji https://www.khronos.org/registry/OpenGL-Refpages/gl4/ funkcje są opisane także na stronach https://learnopengl.com/Getting-started/Hello-Triangle https://learnopengl.com/Getting-started/Shaders oraz https://open.gl/drawing
+	// W tablicy box są pozycje i kolory kostki, celem zajęć jest narysowanie tej kostki 
+	// Zainicjalizuj VertexArrayObject (VAO) i zapisz w nim atrybuty prostopadłościanu
+	glGenVertexArrays(1, &VAO);
+
+	// 1. Stwórz nowy VAO za pomocą glGenVertexArrays i przypisz jego adres do zmiennej globalnej
+	// 2. Powiąż stworzone VAO za pomocą funkcji glBindVertexArray
+
+	glBindVertexArray(VAO);
+
+	// II Zainicjalizuj VBO
+	glGenBuffers(1, &VBO);
+
+	// 3. Stwórz VertexBufferObject do przechowywania pozycji wierzchołków za pomocą funkcji glGenBuffers
+	glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	// 4. Powiąż stworzone VBO za pomocą funkcji glBindBuffer(GLenum target, GLuint )
+
+	glBufferData(GL_ARRAY_BUFFER, sizeof(box), box, GL_STATIC_DRAW);
+	// 5. Zaalokuj w GPU miejsce na tablice box i zaalakokuj ją za pomocą glBufferData
+	//std::cout << sizeof(box);
+	// II Stwórz definicję danych w buforze
+	glEnableVertexAttribArray(0);
+	glEnableVertexAttribArray(1);
+	//glGetAttribLocation(program, "vertexPosition");
+	// 6. Aktywuj atrybut powiązany z pozycją wierchołków za pomocą glEnableVertexAttribArray(GLuint index). Indeks jest zapisany w shaderze wierzchołków w 3. lini. Można odpytać shader o indeks za pomocą funkcji glGetAttribLocation(GL uint program, const GLchar *name)
+	// 6. Aktywuj atrybut powiązany z kolorem wierchołków za pomocą glEnableVertexAttribArray(GLuint index). Indeks jest zapisany w shaderze wierzchołków w 4. lini. Można odpytać shader o indeks za pomocą funkcji glGetAttribLocation(GL uint program, const GLchar *name)
+	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(float), 0);
+	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(4 * sizeof(float)));
+
+	// 8. Zdefiniuj jak OpenGL powinien interpretować dane za pomocą glVertexAttribPointer
+
+
+
+	// 9. Uwolnij VAO za pomocą funkcji glBindVertexArray(0)
+	glBindVertexArray(0);
+}
+
+
+
+void shutdown(GLFWwindow* window)
+{
+	shaderLoader.DeleteProgram(program);
+}
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+		glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+	while (!glfwWindowShouldClose(window))
+	{
+		processInput(window);
+
+		renderScene(window);
+		glfwPollEvents();
+	}
+}
+//}
--- a/2/src/ex_2_1b.hpp
+++ b/2/src/ex_2_1b.hpp
@ -0,0 +1,120 @@
+#pragma once
+#include "glew.h"
+#include "glm.hpp"
+#include "ext.hpp"
+#include <iostream>
+#include <cmath>
+#include <GLFW/glfw3.h>
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+#include "Box.cpp"
+float points[] = {
+0.0f,1.0f,0.f,1.f,
+0.7818314824680298f,0.6234898018587336f,0.f,1.f,
+0.9749279121818236f,-0.22252093395631434f,0.f,1.f,
+0.43388373911755823f,-0.900968867902419f,0.f,1.f,
+-0.433883739117558f,-0.9009688679024191f,0.f,1.f,
+-0.9749279121818236f,-0.2225209339563146f,0.f,1.f,
+-0.7818314824680299f,0.6234898018587334f,0.f,1.f,
+};
+float hues[] = {
+	0.0f,
+	0.7142857142857143f,
+	0.42857142857142855f,
+	0.14285714285714285f,
+	0.8571428571428571f,
+	0.5714285714285714f,
+	0.2857142857142857f
+};
+
+
+
+GLuint program;
+Core::Shader_Loader shaderLoader;
+
+unsigned int VAO;
+GLuint EBO, VBO;
+
+void renderScene(GLFWwindow* window)
+{
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	glm::mat4 transformation = glm::eulerAngleXYZ(0.3f, 0.3f, 0.2f);
+
+	// ZADANIE: Powyżej w tablicy points znajdują się wierzchołki 7-kąta foremnego, zadanie polega na narysowaniu gwiazdy siedmioramiennej jak na obrazku zad1b.jpg. Do shadera należy przesłać pozycje wierzchołków i ich odcienie z tablicy hues podobnie jak w zadaniu 1a. 
+	// Idealnie rozwiązane zadanie wymaga użycia indeksowania z użyciem Element Buffer Objects oraz trybu rysowania GL_LINE_STRIP
+	// (dodatkowe) Jedna krawędź przechodzi przez wszystkie odcienie zamiast z czerwonego do magenty. Co to powoduje? W jaki sposób byś to naprawił?
+
+	glUseProgram(program);
+	glBindVertexArray(VAO);
+	glDrawElements(GL_LINE_STRIP, 8, GL_UNSIGNED_INT, (void*)0);
+	glUseProgram(0);
+	glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+	glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window)
+{
+	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+	glEnable(GL_DEPTH_TEST);
+	program = shaderLoader.CreateProgram("shaders/shader_2_1b.vert", "shaders/shader_2_1b.frag");
+	glGenVertexArrays(1, &VAO);
+	glBindVertexArray(VAO);
+
+	GLuint VBO;
+
+	glGenBuffers(1, &VBO);
+	glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
+	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
+	glEnableVertexAttribArray(0);
+
+	unsigned int indices[] = { 0, 1, 2, 3, 4, 5, 6 };
+
+	glGenBuffers(1, &EBO);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+
+
+	GLuint VBO_hues;
+	glGenBuffers(1, &VBO_hues);
+	glBindBuffer(GL_ARRAY_BUFFER, VBO_hues);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(hues), hues, GL_STATIC_DRAW);
+
+	// Attribute pointers for hues
+	glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, sizeof(float), 0);
+	glEnableVertexAttribArray(1);
+
+	glBindVertexArray(0);
+}
+
+void shutdown(GLFWwindow* window)
+{
+	shaderLoader.DeleteProgram(program);
+}
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+		glfwSetWindowShouldClose(window, true);
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+	while (!glfwWindowShouldClose(window))
+	{
+		processInput(window);
+
+		renderScene(window);
+		glfwPollEvents();
+	}
+}
+//}
--- a/2/src/ex_2_2.hpp
+++ b/2/src/ex_2_2.hpp
@ -0,0 +1,107 @@
+#include "glew.h"
+#include <GLFW/glfw3.h>
+#include "glm.hpp"
+#include "ext.hpp"
+#include <iostream>
+#include <cmath>
+
+#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 <string>
+
+
+
+GLuint program;
+Core::Shader_Loader shaderLoader;
+
+Core::RenderContext shipContext;
+Core::RenderContext sphereContext;
+
+float cameraAngle = 0;
+glm::vec3 cameraPos = glm::vec3(-5, 0, 0);
+glm::vec3 cameraDir;
+
+
+glm::mat4 createCameraMatrix()
+{
+	cameraDir = glm::vec3(cosf(cameraAngle), 0.0f, sinf(cameraAngle));
+	glm::vec3 up = glm::vec3(0, 1, 0);
+
+	return Core::createViewMatrix(cameraPos, cameraDir, up);
+}
+void renderScene(GLFWwindow* window)
+{
+	glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	glUseProgram(program);
+
+	glm::mat4 camera = createCameraMatrix();
+	glm::mat4 perspective = Core::createPerspectiveMatrix();
+	glm::mat4 transformation = perspective * camera;
+
+	glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transformation);
+
+	glUseProgram(0);
+	glfwSwapBuffers(window);
+}
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+	glViewport(0, 0, width, height);
+}
+
+void init(GLFWwindow* window)
+{
+	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+	glEnable(GL_DEPTH_TEST);
+	program = shaderLoader.CreateProgram("shaders/shader_2_2.vert", "shaders/shader_2_2.frag");
+
+}
+
+void shutdown(GLFWwindow* window)
+{
+	shaderLoader.DeleteProgram(program);
+}
+
+//obsluga wejscia
+void processInput(GLFWwindow* window)
+{
+	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
+		glfwSetWindowShouldClose(window, true);
+	}
+
+
+	float angleSpeed = 0.1f;
+	float moveSpeed = 0.1f;
+	if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
+		cameraAngle -= angleSpeed;
+	}
+	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
+		cameraAngle += angleSpeed;
+	}
+	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
+		cameraPos += cameraDir * moveSpeed;
+	}
+	if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
+		cameraPos -= cameraDir * moveSpeed;
+	}
+}
+
+// funkcja jest glowna petla
+void renderLoop(GLFWwindow* window) {
+	while (!glfwWindowShouldClose(window))
+	{
+		processInput(window);
+
+		renderScene(window);
+		glfwPollEvents();
+	}
+}
+//}
--- a/2/src/main.cpp
+++ b/2/src/main.cpp
@ -0,0 +1,47 @@
+#include "glew.h"
+#include "glm.hpp"
+#include "ext.hpp"
+#include <iostream>
+#include <cmath>
+#include <GLFW/glfw3.h>
+
+#include "Shader_Loader.h"
+#include "Render_Utils.h"
+
+#include "ex_2_1a.hpp"
+
+int main(int argc, char** argv)
+{
+	// inicjalizacja glfw
+	glfwInit();
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+#ifdef __APPLE__
+	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+	// tworzenie okna za pomocą glfw
+	GLFWwindow* window = glfwCreateWindow(500, 500, "FirstWindow", NULL, NULL);
+	if (window == NULL)
+	{
+		std::cout << "Failed to create GLFW window" << std::endl;
+		glfwTerminate();
+		return -1;
+	}
+	glfwMakeContextCurrent(window);
+
+	// ladowanie OpenGL za pomoca glew
+	glewInit();
+	glViewport(0, 0, 500, 500);
+
+	init(window);
+
+	// uruchomienie glownej petli
+	renderLoop(window);
+
+	shutdown(window);
+	glfwTerminate();
+	return 0;
+}
--- a/2/style.css
+++ b/2/style.css
@ -0,0 +1,107 @@
+html { font-size: 100%; overflow-y: scroll; -webkit-text-size-adjust: 100%; -ms-text-size-adjust: 100%; }
+
+body{
+color:#444;
+font-family:Georgia, Palatino, 'Palatino Linotype', Times, 'Times New Roman', serif;
+font-size:12px;
+line-height:1.5em;
+padding:1em;
+margin:auto;
+max-width:42em;
+background:#fefefe;
+}
+
+a{ color: #0645ad; text-decoration:none;}
+a:visited{ color: #0b0080; }
+a:hover{ color: #06e; }
+a:active{ color:#faa700; }
+a:focus{ outline: thin dotted; }
+a:hover, a:active{ outline: 0; }
+
+::-moz-selection{background:rgba(255,255,0,0.3);color:#000}
+::selection{background:rgba(255,255,0,0.3);color:#000}
+
+a::-moz-selection{background:rgba(255,255,0,0.3);color:#0645ad}
+a::selection{background:rgba(255,255,0,0.3);color:#0645ad}
+
+p{
+margin:1em 0;
+}
+
+img{
+max-width:100%;
+}
+
+h1,h2,h3,h4,h5,h6{
+font-weight:normal;
+color:#111;
+line-height:1em;
+}
+h4,h5,h6{ font-weight: bold; }
+h1{ font-size:2.5em; }
+h2{ font-size:2em; }
+h3{ font-size:1.5em; }
+h4{ font-size:1.2em; }
+h5{ font-size:1em; }
+h6{ font-size:0.9em; }
+
+blockquote{
+color:#666666;
+margin:0;
+padding-left: 3em;
+border-left: 0.5em #EEE solid;
+}
+hr { display: block; height: 2px; border: 0; border-top: 1px solid #aaa;border-bottom: 1px solid #eee; margin: 1em 0; padding: 0; }
+pre, code, kbd, samp { color: #000; font-family: monospace, monospace; _font-family: 'courier new', monospace; font-size: 0.98em; }
+pre { white-space: pre; white-space: pre-wrap; word-wrap: break-word; }
+
+b, strong { font-weight: bold; }
+
+dfn { font-style: italic; }
+
+ins { background: #ff9; color: #000; text-decoration: none; }
+
+mark { background: #ff0; color: #000; font-style: italic; font-weight: bold; }
+
+sub, sup { font-size: 75%; line-height: 0; position: relative; vertical-align: baseline; }
+sup { top: -0.5em; }
+sub { bottom: -0.25em; }
+
+ul, ol { margin: 1em 0; padding: 0 0 0 2em; }
+li p:last-child { margin:0 }
+dd { margin: 0 0 0 2em; }
+
+img { border: 0; -ms-interpolation-mode: bicubic; vertical-align: middle; }
+
+table {
+border-collapse: collapse;
+border-spacing: 0;
+width: 100%;
+}
+th { border-bottom: 1px solid black; }
+td { vertical-align: top; }
+
+@media only screen and (min-width: 480px) {
+body{font-size:14px;}
+}
+
+@media only screen and (min-width: 768px) {
+body{font-size:16px;}
+}
+
+@media print {
+  * { background: transparent !important; color: black !important; filter:none !important; -ms-filter: none !important; }
+  body{font-size:12pt; max-width:100%;}
+  a, a:visited { text-decoration: underline; }
+  hr { height: 1px; border:0; border-bottom:1px solid black; }
+  a[href]:after { content: " (" attr(href) ")"; }
+  abbr[title]:after { content: " (" attr(title) ")"; }
+  .ir a:after, a[href^="javascript:"]:after, a[href^="#"]:after { content: ""; }
+  pre, blockquote { border: 1px solid #999; padding-right: 1em; page-break-inside: avoid; }
+  tr, img { page-break-inside: avoid; }
+  img { max-width: 100% !important; }
+  @page :left { margin: 15mm 20mm 15mm 10mm; }
+  @page :right { margin: 15mm 10mm 15mm 20mm; }
+  p, h2, h3 { orphans: 3; widows: 3; }
+  h2, h3 { page-break-after: avoid; }
+}
--- a/2/zad1b.JPG
+++ b/2/zad1b.JPG
--- a/2/zlib.dll
+++ b/2/zlib.dll
--- a/2/zlibd.dll
+++ b/2/zlibd.dll
--- a/Show More
+++ b/Show More