--- /dev/null
+++ b/src/Graphic3d/Graphic3d_CubeMap.cxx
+// Author: Ilya Khramov
+// Copyright (c) 2016-2019 OPEN CASCADE SAS

+  //! Sets iterator state to +X cubemap side.
+  Graphic3d_CubeMap& Reset() { myCurrentSide = 0; return *this; }

+  //! Returns index of current cubemap side (iterator state).
+  //! Uses OpenGL cubemap sides order (+X, -X, +Y, -Y, +Z, -Z).
+  unsigned int CurrentSide() const { return myCurrentSide; }
...
+  unsigned int myCurrentSide; //! index of current cubemap side in (+X, -X, +Y, -Y, +Z, -Z) array

+  //! Sets environment cubemap as background.
+  virtual void SetBackgroundCubeMap (const Handle(Graphic3d_CubeMap)& theCubeMap) = 0;

+  //! Returns rather Z axis is inverted during cubemap background rendering.
+  virtual Standard_Boolean BackgroundCubeMapZIsInverted() const = 0;
+
+  //! Sets innversion of Z axis during cubemap background rendering.
+  //! Z axis inverting allows to make a horizontal flip of background cubemap (to sync text orientation for example).
+  virtual void SetBackgroundCubeMapZInversion (Standard_Boolean theZIsInverted) = 0;

+Graphic3d_CubeMapPacked::Graphic3d_CubeMapPacked (const TCollection_AsciiString&          theFilePath,
+                                                  const NCollection_Array1<unsigned int>& theOrder):
+  Graphic3d_CubeMap (theFilePath),

+      Handle(Image_PixMap) aWrapper = new Image_PixMap;

+Standard_Boolean Graphic3d_CubeMapPacked::checkOrder (const NCollection_Array1<unsigned int>& theOrder)
+{
+  if (theOrder.Size() != 6)
+  {
+    return Standard_False;
+  }

+  Standard_ShortReal aRatio = theImage->SizeX() / Standard_ShortReal(theImage->SizeY());
+
+  if (aRatio == 1.f / 6.f)
+  {
+    theTileNumberX = 1;
+  }
+  else if (aRatio == 6.f)
+  {
+    theTileNumberX = 6;
+  }

+//! Class to keep cupemap packed in one image containing tile grid.
+class Graphic3d_CubeMapPacked : public Graphic3d_CubeMap

+  static const NCollection_Array1<unsigned int> DefaultOrder; //!< contains {0, 1, 2, 3, 4, 5}

+
+protected:
+
+  NCollection_Array1<unsigned int> myOrder;       //!< order mapping tile grit to cubemap sides
+  unsigned int                     myTileNumberX; //!< width of tile grid
+
+private:
+
+  //! Generates Graphic3d_CubeMapPacked::DefaultOrder
+  static NCollection_Array1<unsigned int> generateDefaultOrder()

--- /dev/null
+++ b/src/Graphic3d/Graphic3d_CubeMapSeparate.cxx
+#include <OSD_File.hxx>
+#include <Graphic3d_CubeMapSeparate.hxx>

+Graphic3d_CubeMapSeparate::Graphic3d_CubeMapSeparate (const NCollection_Array1<TCollection_AsciiString>& thePaths) :
+  Graphic3d_CubeMap ()

+  if (thePaths.Size() == 6)
+  {
+    for (unsigned int i = 0; i < 6; ++i)
+    {
+      myPaths[i] = thePaths[i];
+    }
+  }
...
+    if (theImages[0]->SizeX() != theImages[0]->SizeY())
+    {
+      return;
+    }
...
+      if (!theImages[i].IsNull())
+      {
+        if (theImages[i]->SizeX() == myImages[0]->SizeX()
+         && theImages[i]->SizeY() == myImages[0]->SizeY()
+         && theImages[i]->Format() == myImages[0]->Format())

+Handle(Image_PixMap) Graphic3d_CubeMapSeparate::Value()
+{
+    TCollection_AsciiString aFilePath;
+    myPaths[myCurrentSide].SystemName(aFilePath);
+    if (!aFilePath.IsEmpty())
+    {
+      Handle(Image_AlienPixMap) anImage = new Image_AlienPixMap;
+      if (anImage->Load(aFilePath))
+      {
+        if (anImage->SizeX() == anImage->SizeY())
+        {
+          if (myCurrentSide == 0)
+          {
+            mySize =   anImage->SizeX();

+  }
+}
\ No newline at end of file

+Handle(Image_PixMap) Graphic3d_CubeMapSeparate::GetImage() const
+{
+  return Handle(Image_PixMap)();
+}

 enum Graphic3d_TypeOfBackground
 {
-Graphic3d_TOB_NONE,
 Graphic3d_TOB_GRADIENT,
-Graphic3d_TOB_TEXTURE
+Graphic3d_TOB_TEXTURE,
+Graphic3d_TOB_CUBEMAP,
+Graphic3d_TOB_NONE,
+
+Graphic3d_TOB_Number = Graphic3d_TOB_NONE
 };

+      EOL"uniform int uZCoeff = 1;" // defines orientation of Z axis to make horizontal flip

+      EOL"out vec3 ViewDirection;"
...
+      EOL"in vec3 ViewDirection;"
...
+      EOL"  occSetFragColor (vec4(texture(occEnvCubemap, ViewDirection).rgb, 1.0));"

+      Release(theCtx.operator->());

+      return Init(theCtx, *anImage.get(), theTextureMap->Type());

+    GLenum aPixelFormat;
+    GLenum aDataType;
+    GLint aTextFormat;
+
+    if (!GetDataFormat(theCtx, *anImage.get(), aTextFormat, aPixelFormat, aDataType))

+#if !defined (GL_ES_VERSION_2_0)
+    glTexImage2D (GL_PROXY_TEXTURE_2D, 0, aTextFormat,
+                  GLsizei(anImage->SizeX()), GLsizei(anImage->SizeY()), 0,
+                  aPixelFormat, aDataType, NULL);

+    glPixelStorei(GL_UNPACK_ALIGNMENT, anAligment);

+
+#if !defined(GL_ES_VERSION_2_0)
+    // notice that GL_UNPACK_ROW_LENGTH is not available on OpenGL ES 2.0 without GL_EXT_unpack_subimage extension
+    const GLint anExtraBytes = GLint(anImage->RowExtraBytes());
+    const GLint aPixelsWidth = GLint(anImage->SizeRowBytes() / anImage->SizePixelBytes());
+    const GLint aRowLength = (anExtraBytes >= anAligment) ? aPixelsWidth : 0;
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, aRowLength);
+#endif

+    if (glGetError() != GL_NO_ERROR)

+    if (glGetError() != GL_NO_ERROR)
+    {
+      Unbind(theCtx);
+      Release(theCtx.get());
+      return false;
+    }
+  }
+
+  return true;

--- a/src/OpenGl/OpenGl_Texture.hxx
+++ b/src/OpenGl/OpenGl_Texture.hxx
@@ -20,6 +20,7 @@
 #include <OpenGl_Sampler.hxx>
 #include <Graphic3d_TypeOfTexture.hxx>
 #include <Graphic3d_TextureUnit.hxx>
+#include <Graphic3d_CubeMap.hxx>

+
+Graphic3d_TOB_Number = Graphic3d_TOB_NONE

-    myTextureParams->Release (theCtx.get());
+    myTextureParams->Release(theCtx.get());
...
-  const Standard_Boolean wasUsedZBuffer = theWorkspace->SetUseZBuffer (Standard_False);
+  const Standard_Boolean wasUsedZBuffer = theWorkspace->SetUseZBuffer(Standard_False);
...
-    aCtx->core11fwd->glDisable (GL_DEPTH_TEST);
+    aCtx->core11fwd->glDisable(GL_DEPTH_TEST);
...
-    theWorkspace->SetUseZBuffer (Standard_True);
-    aCtx->core11fwd->glEnable (GL_DEPTH_TEST);
+    theWorkspace->SetUseZBuffer(Standard_True);
+    aCtx->core11fwd->glEnable(GL_DEPTH_TEST);

--- a/src/OpenGl/OpenGl_View_Redraw.cxx
+++ b/src/OpenGl/OpenGl_View_Redraw.cxx
@@ -74,65 +74,93 @@ namespace
 void OpenGl_View::drawBackground (const Handle(OpenGl_Workspace)& theWorkspace)
 {

+  //! Sets inversion of Z axis during background cibemap rendering.

+      aCamera.SetZRange(0.01, 1.0); // need to avoid perspective camera exeption

+    aBackgroundCommandNameMap["vsetcubemapbg"]    = BackgroundCommand_CubeMap;
+    aBackgroundCommandNameMap["vsetcmzinversion"] = BackgroundCommand_CubeMapZInversion;

+NCollection_Array1<unsigned int> Graphic3d_CubeMapPacked::DefaultOrder()
+{

+    throw Standard_Failure("Invalid number of images in Graphic3d_CubeMapSeparate initialization");
+    return;

+                "'" + aFilePath + "' inconsistent image format or dimansion in Graphic3d_CubeMapSeparate");

+  Handle(Image_PixMap) GetImage() const Standard_OVERRIDE

+      theSize = unsigned int (anImage->SizeX());

+        "Unable to get foirs side of cubemap");

+    Handle(Image_PixMap) anImage = Handle(Image_PixMap)();

An exception was caught 00000235108F4EF0 : OSD_Exception_ACCESS_VIOLATION: ACCESS VIOLATION at address 0x000002351B63AFF0 during 'READ' operation

    if (!myPixMap.IsNull())
    {
      Handle(Image_PixMap) aWrapper = new Image_PixMap();

      Standard_Size aTileSize = myPixMap->SizeX() / myTileNumberX;

      unsigned int aTileIndexY = myOrder[myCurrentSide] / myTileNumberX;
      unsigned int aTileIndexX = myOrder[myCurrentSide] % myTileNumberX;

      if (aWrapper->InitWrapper (myPixMap->Format(),
                                 myPixMap->ChangeRawValue(aTileIndexY * aTileSize, aTileIndexX * aTileSize),
                                 aTileSize,
                                 aTileSize,
                                 myPixMap->SizeRowBytes()))
      {
        return aWrapper;
      }
    }

+                        static_cast<unsigned char> (std::stoi(anOrderItem)));

+// This constat is used in 'HasRepitities' method

+  //! Returns cubemap being setted last time on background.
+  virtual Handle(Graphic3d_CubeMap) BackgroundCubeMap() const = 0;

+  //! Constructor definig direct cubemap initialization from PixMap.
+  Graphic3d_CubeMap (const Handle(Image_PixMap)& thePixmap = Handle(Image_PixMap)()) :

+const unsigned int Graphic3d_CubeMapOrder::repititiesConstant =

+  unsigned int convolution;  //!< Contains all values of permutation as power convolution
+  bool         hasOverflows; //!< Indicates if there are attempts to assign index greater than 5

-            aResource->SetRevision (aTexture->Revision());
+            aResource->SetRevision(aTexture->Revision());

#include <bitset>

template <std::size_t theMaxValue, typename TheContainer>
bool HasDuplicates (const TheContainer& theContainer)
{
  typedef std::bitset<theMaxValue> AValueFlags;
  AValueFlags aValueFlags;
  // std::bitset::all() is not used due to C++03 limitation
  for (std::size_t anElementIndex = 0; anElementIndex < theContainer.size(); ++anElementIndex)
  {
    typename AValueFlags::reference aValueFlag = aValueFlags[theContainer[anElementIndex]];
    if (aValueFlag)
    {
      return true;
    }
    aValueFlag = true;
  }
  return false;
}