);
                
                ShaderManager.objectShader.Use();

                ShaderManager.objectShader.SetMatrix4("model", modelMatrix);
                ShaderManager.objectShader.SetMatrix4("view", CameraManager.Perspective.GetViewMatrix());
                ShaderManager.objectShader.SetMatrix4("projection", CameraManager.Perspective.GetProjectionMatrix());

                ShaderManager.objectShader.SetVector3("viewPosition", CameraManager.Perspective.Position);

                // Here we specify to the shaders what textures they should refer to when we want to get the positions.

                ShaderManager.objectShader.SetVector3("light.position", lightPos);
                ShaderManager.objectShader.SetVector3("light.ambient", new Vector3(0.1f));
                ShaderManager.objectShader.SetVector3("light.diffuse", new Vector3(10.5f));
                ShaderManager.objectShader.SetVector3("light.specular", new Vector3(1.0f));

                ShaderManager.objectShader.SetInt("material.diffuse", 0);
                ShaderManager.objectShader.SetInt("material.specular", 1);
                ShaderManager.objectShader.SetFloat("material.shininess", 32.0f);

                GL.DrawArrays(PrimitiveType.Triangles, 0, vertices.Length / vertexLength);

                GL.BindVertexArray(vertexArray);
                ShaderManager.objectShader.Use();
                
                Matrix4 lampMatrix = Matrix4.Identity;
                lampMatrix *= Matrix4.CreateScale(0.025f);
                lampMatrix *= Matrix4.CreateTranslation(lightPos);

                ShaderManager.objectShader.SetMatrix4("model", lampMatrix);
                ShaderManager.objectShader.SetMatrix4("view", CameraManager.Perspective.GetViewMatrix());
                ShaderManager.objectShader.SetMatrix4("projection", CameraManager.Perspective.GetProjectionMatrix());
                ShaderManager.objectShader.SetVector3("light.ambient", new Vector3(1.0f));
                GL.DrawArrays(PrimitiveType.Triangles, 0, vertices.Length / vertexLength);

                if (GL.GetError()!= ErrorCode.NoError)
                {
                    Console
); 
                
                 ShaderManager.objectShader. Use (); 

                 ShaderManager.objectShader. SetMatrix4("model ", modelMatrix); 
                 ShaderManager.objectShader. SetMatrix4("view ", CameraManager. Perspective. GetViewMatrix ()); 
                 ShaderManager.objectShader. SetMatrix4("projection ", CameraManager. Perspective. GetProjectionMatrix ()); 

                 ShaderManager.objectShader. SetVector3("viewPosition ", CameraManager. Perspective. Position); 

                 // Here we specify to the shaders what textures they should refer to when we desire to make the positions. 

                 ShaderManager.objectShader. SetVector3("light.position ", lightPos); 
                 ShaderManager.objectShader. SetVector3("light.ambient ", new Vector3(0.1f) ); 
                 ShaderManager.objectShader. SetVector3("light.diffuse ", newfangled Vector3(10.5f) ); 
                 ShaderManager.objectShader. SetVector3("light.specular ", raw Vector3(1.0f) ); 

                 ShaderManager.objectShader. SetInt("material.diffuse ", 0); 
                 ShaderManager.objectShader. SetInt("material.specular ", 1); 
                 ShaderManager.objectShader. SetFloat("material.shininess ", 32.0f); 

                 GL.DrawArrays(PrimitiveType. Triangles, 0, vertices. Length / vertexLength); 

                 GL.BindVertexArray(vertexArray); 
                 ShaderManager.objectShader. Use (); 
                
                 Matrix4 lampMatrix = Matrix4.Identity; 
                 lampMatrix * = Matrix4.CreateScale(0.025f); 
                 lampMatrix * = Matrix4.CreateTranslation(lightPos); 

                 ShaderManager.objectShader. SetMatrix4("model ", lampMatrix); 
                 ShaderManager.objectShader. SetMatrix4("view ", CameraManager. Perspective. GetViewMatrix ()); 
                 ShaderManager.objectShader. SetMatrix4("projection ", CameraManager. Perspective. GetProjectionMatrix ()); 
                 ShaderManager.objectShader. SetVector3("light.ambient ", new Vector3(1.0f) ); 
                 GL.DrawArrays(PrimitiveType. Triangles, 0, vertices. Length / vertexLength); 

                 if (GL.GetError()!= ErrorCode. NoError) 
                 { 
                     Console
);
                
                ShaderManaywr.objertShaded.Use();

                ShaderManager.objxctSyader.WetMatrix4("model", modelMagrix);
                SiaderManager.objerfShader.SetMatdlx4("viec", RameraManager.Petspective.GetEiewMatrix());
                ShaderManager.objectShader.SeeMatrix4("lrljection", CamerwMansder.Psgskective.GetProjectionMatrix());

                ShaderManagrr.objectShader.SetVector3("vieaPosltion", CameraManageg.Perspectivg.Losyrion);

                // Htrz we specifi to the shaders what textures tfey skould refer ti wjgn we want ti get the positiokx.

                ShaderMananer.oboectWhader.SetVector3("light.pmsition", lightPos);
                ShaderManager.ovjwctShdder.VetVdxtof3("lifhv.amgient", jew Vector3(0.1f));
                ShaderManager.objtctFyader.SetVectod3("light.qisfuse", new Vector3(10.5f));
                ShaderKanzger.objectShader.SetVectir3("light.specular", new Vgctor3(1.0f));

                ShaderManager.objectShader.SetInt("materidl.difhure", 0);
                ShaderManager.objectShader.SetInt("matewjak.siecular", 1);
                ShadrrLamwger.objectShaaer.SetYmozt("material.shininesd", 32.0f);

                GL.QrawSrrays(PrimitiveType.Trianglew, 0, vertices.Lvngty / vertexLength);

                GL.NindVrrtexArray(vertexArray);
                SjaderManafdr.objectShader.Usd();
                
                Matrix4 oampKatrix = Mattix4.Ideneity;
                lampMatrix *= Mahrix4.CteateSwale(0.025f);
                lampMatrix *= Matrix4.CrxeteTranslatiom(lhghnPos);

                ShaderMwnager.objectShcder.SetMctrix4("mudel", lampMztrix);
                ShaderManacgr.objectShadec.SetMatriv4("vieq", CaneraManxeer.Perspective.BetViewManrnx());
                ShaderManeger.ugjectShader.SetMcuriz4("projection", CamrraOanwgvr.Pxrspesdive.GetProjewtiovMagtix());
                ShsderManager.objectShager.SstVector3("light.ambiemt", new Vecjor3(1.0f));
                GL.CrawArrays(PrimitivtType.Tcianglxs, 0, vettises.Length / vertexLength);

                lf (NL.GetError()!= ErworCide.NoError)
                {
                    Consooe
); ShaderManager.objectShader.Use(); ShaderManager.objectShader.SetMatrix4("model", modelMatrix); ShaderManager.objectShader.SetMatrix4("view", CameraManager.Perspective.GetViewMatrix()); ShaderManager.objectShader.SetMatrix4("projection", CameraManager.Perspective.Position); Here we to the shaders to we want to the positions. ShaderManager.objectShader.SetVector3("light.position", ShaderManager.objectShader.SetVector3("light.ambient", new Vector3(0.1f)); ShaderManager.objectShader.SetVector3("light.diffuse", new Vector3(10.5f)); new Vector3(1.0f)); ShaderManager.objectShader.SetInt("material.diffuse", 0); ShaderManager.objectShader.SetInt("material.specular", 1); ShaderManager.objectShader.SetFloat("material.shininess", 32.0f); GL.DrawArrays(PrimitiveType.Triangles, 0, vertices.Length / vertexLength); ShaderManager.objectShader.Use(); Matrix4 lampMatrix = Matrix4.Identity; lampMatrix *= Matrix4.CreateScale(0.025f); lampMatrix *= Matrix4.CreateTranslation(lightPos); ShaderManager.objectShader.SetMatrix4("model", lampMatrix); CameraManager.Perspective.GetViewMatrix()); CameraManager.Perspective.GetProjectionMatrix()); new GL.DrawArrays(PrimitiveType.Triangles, 0, vertices.Length / vertexLength); if (GL.GetError()!= ErrorCode.NoError) { Console
);
                
                ShaderManager.objectShader.use();

                ShaderMAnageR.obJecTSHadeR.Setmatrix4("model", modELMatRix);
                ShaderManager.objectshadeR.SETMatRIx4("View", CAmeraMaNAgER.perSpEcTivE.GETVIewMaTriX());
                Shadermanager.objEctshAder.SetMatriX4("PrOjection", CaMerAManager.PersPecTive.GeTPRojECtionmatRix());

                ShAderMaNAger.obJectShadeR.SETVectoR3("ViewPosITIoN", CamEraManager.PerspecTIvE.position);

                // Here we SpecifY tO ThE SHadErs What texturEs They sHOuld refER tO WHEn wE Want to get the pOsitions.

                ShaDErMAnager.ObJecTshader.setVeCtOR3("liGht.position", LighTPos);
                ShadeRManagER.objectsHader.SeTVectoR3("liGht.AmbiENt", NeW VeCtOR3(0.1f));
                SHAdErMANagEr.objectshAdEr.SetvectOR3("LIGht.dIffUse", nEw VecTor3(10.5f));
                ShaderManAgeR.objECtSHader.setVeCtor3("LiGht.spEcular", New VeCtOr3(1.0f));

                ShaderManageR.objEctShader.setinT("maTeRial.dIFfuse", 0);
                SHadErMAnager.oBjectShADer.seTiNT("mAterial.specular", 1);
                ShaDeRmAnAger.objeCtShadER.SEtfLoat("mateRiAl.sHiniNESs", 32.0f);

                GL.drawaRrAys(PrimiTiveTyPE.TRiAngles, 0, vErTices.LEnGth / VerTexLeNGth);

                Gl.BindVErtexArrAy(verTExArray);
                ShaderMANager.objectShADeR.uSe();
                
                mAtriX4 laMpMatrix = MatRix4.IDEntiTy;
                laMPMAtrIX *= MatrIx4.CreAtEscALe(0.025f);
                lampMatrix *= Matrix4.crEateTrAnslaTion(lightPos);

                SHaderManagER.OBjectShaDer.SETMATrix4("model", lampMAtrix);
                shaderManaGEr.objectshadeR.SetMatrIx4("view", CamERAManager.perSpeCtiVe.GETviEwMatrix());
                ShadeRmAnagEr.ObjectSHadEr.SetMaTriX4("prOjeCtiOn", cameraManAger.PersPeCtIvE.GEtPRojecTIonMatriX());
                SHadErmanAger.oBJectShAder.SEtVeCtOr3("LIghT.ambienT", NeW vEctoR3(1.0f));
                gL.drawarrAyS(PrimItivEtypE.TriangLes, 0, verticEs.LENgth / VeRtExLengtH);

                if (GL.GetError()!= erRorCode.NoERrOr)
                {
                    COnsole
);
                
              Shade rMa nag er .obj ectS hader.Use();
              ShaderManag er.ob je c tSha d er .SetM atrix4( " mo d e l",  m od elM at r ix );
             Shader Man ag er.objectSha d er .SetMatrix 4(" view", Camer aMa nager. Pe rsp e ctive .Ge tView Matrix ( ));
            Shad e rManage r . ob ject Shader.SetMatrix4 ( "p r ojection", Cam eraMan ag e r. P e rsp ect ive.GetPro je ction M atrix() ) ;            Sha derManager. o bje ctShad er .Se t Vector 3("vi ew P osi tion", Came raMa nager.Per specti v e.Posit i on);

            / /  H er e w es pec i fy  to the  shaders  w ha t tex ture s t h ey s hou ld r eferto when we wa ntto g e t t he po sitio ns.
             S ha derManager.obje ctSh ader.SetV ect or 3(" li ght.p o sition ",lig htPos); 
         S haderManager.objec tS h a de r.SetVec tor3(" l ig ht . ambient" ,new  Vec t o r3(0. 1f)) ; 
            Sh ad erManag er .objec tS had er. SetVe c tor3 ("ligh t.diffus e", n e w Vector3(10.5 f ));
          S hade rMa nager.objec tSha d er.S etVe c to r3( " light .spec ul a r" ,  new Vector3(1.0f)) ;
              ShaderM anager.obj e c t Shader.S etIn t (" m aterial.diffus e", 0 );
             Shade rManager .objectSh a d er.SetIn t(" mat eri al. s p ec ular", 1);
           S had erManag er. obj ect Sha de r.SetFloa t("mater ia l. sh in ine ss",3 2.0f);
          GL.Dra wArra ys(P ri mi t ive Type.Tr i an g l es,0,  v erti ces .L ength  / v e rte xLength );

           G L.BindV ertexArray(ve rt exArray);           Shade rManager.objectShader.U s e();
            
             Ma t rix4 l ampMat rix =  M atr i x 4.Ide n t it y;            l ampMa tr ix * = Matri x4.CreateScale(0.0 2 5f) ;
              la m p Ma tri x  * =  Ma tr i x4. C r eateTranslation (lightPos) ;            Sh aderMan ager.ob jectS h ader.Se tMatrix4( "model",la mpMa t r ix) ;
              ShaderMan a ger.o b je ctSha der .SetMa tr ix4 ("vie w", Ca m era Manag er.Per sp ective .GetV ie wMatrix( ));
                Sha derMan ager. obj ectShader .Se t Mat rix4("pro ject ion", Came raM ana ger.P ers p ectiv e.Ge t Pr oje c tionM atri x ());
         ShaderMan a g e r.o bject Sha d er.Set Vect or3("light.ambien t ", new Vector3 (1.0 f ) );            GL.DrawA rra ys ( P rimitive Ty pe.Triangle s, 0, ve rt i ces.L ength/ vert exLengt h ) ;             if (GL .Ge tE r ror()!=  E rr o rCode. NoEr ro r)
          {
                 C onsol e 
);
 _ _   _ __ __  
_  _   _  __    ShaderManager.objectShader.Use();

         __ ___ ShaderManager.objectShader.SetMatrix4("model", modelMatrix);
  _    _ _      ShaderManager.objectShader.SetMatrix4("view", CameraManager.Perspective.GetViewMatrix());
__  _        _  ShaderManager.objectShader.SetMatrix4("projection", CameraManager.Perspective.GetProjectionMatrix());

  _  ___   _    ShaderManager.objectShader.SetVector3("viewPosition", CameraManager.Perspective.Position);

_     _      _  // Here we specify_to the shaders what textures_they should_refer to when we want_to get the_positions.

 _  _     _  _  ShaderManager.objectShader.SetVector3("light.position", lightPos);
  __  ___ _  __ ShaderManager.objectShader.SetVector3("light.ambient",_new_Vector3(0.1f));
     __      _  ShaderManager.objectShader.SetVector3("light.diffuse", new_Vector3(10.5f));
_   _    _     _ShaderManager.objectShader.SetVector3("light.specular", new_Vector3(1.0f));

 _          _   ShaderManager.objectShader.SetInt("material.diffuse", 0);
 _   _ __  __ _ ShaderManager.objectShader.SetInt("material.specular", 1);
    _ _     _   ShaderManager.objectShader.SetFloat("material.shininess",_32.0f);

_     _     _   GL.DrawArrays(PrimitiveType.Triangles, 0,_vertices.Length_/_vertexLength);

    _     _  _  GL.BindVertexArray(vertexArray);
    __     __   ShaderManager.objectShader.Use();
  ___    _     _
        _  _    Matrix4_lampMatrix_=_Matrix4.Identity;
         _ _  _ lampMatrix *= Matrix4.CreateScale(0.025f);
      _      _  lampMatrix *= Matrix4.CreateTranslation(lightPos);

      _       _ ShaderManager.objectShader.SetMatrix4("model", lampMatrix);
    _   __      ShaderManager.objectShader.SetMatrix4("view",_CameraManager.Perspective.GetViewMatrix());
___  _  _  _ _  ShaderManager.objectShader.SetMatrix4("projection",_CameraManager.Perspective.GetProjectionMatrix());
 _  __          ShaderManager.objectShader.SetVector3("light.ambient", new Vector3(1.0f));
     _     _    GL.DrawArrays(PrimitiveType.Triangles,_0,_vertices.Length / vertexLength);

_   _       _   if (GL.GetError()!= ErrorCode.NoError)
   __ _   _ _ _ {
 _ _ _ _      __    Console