Image_PixMap has been extended to support definition of 3D bitmap (as an array of 2D slices).
Graphic3d_TypeOfTexture enumeration values have been renamed to include full enum prefix.
Added Graphic3d_TypeOfTexture_3D redirecting to GL_TEXTURE_3D.
OpenGl_Texture::Init() has been extended to allow initialization of 3D texture.
Graphic3d_Texture2Dmanual merged into Graphic3d_Texture2D and marked as deprecated alias.
Graphic3d_TOT_2D_MIPMAP has been deprecated in favor of dedicated Graphic3d_TextureRoot::SetMipMaps().
Added Graphic3d_Texture3D class.
vtexture - added argument -3d for uploading 3D texture.
#include <BRepBuilderAPI_MakeWire.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <gp_Pnt.hxx>
-#include <Graphic3d_Texture1D.hxx>
-#include <Graphic3d_Texture1Dsegment.hxx>
-#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_Texture2D.hxx>
#include <Image_AlienPixMap.hxx>
#include <Prs3d_ShadingAspect.hxx>
#include <TopoDS_Edge.hxx>
this->Set(TopoDS_Shape(myFace));
myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
- Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(myFilename);
+ Handle(Graphic3d_Texture2D) aTexture = new Graphic3d_Texture2D (myFilename);
aTexture->DisableModulate();
myDrawer->ShadingAspect()->Aspect()->SetTextureMap (aTexture);
myDrawer->ShadingAspect()->Aspect()->SetTextureMapOn();
#include <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_Group.hxx>
#include <Graphic3d_StructureManager.hxx>
-#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_Texture2D.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
#include <Prs3d_Drawer.hxx>
TCollection_AsciiString aTextureDesc;
if (!myTexturePixMap.IsNull())
{
- myTexture = new Graphic3d_Texture2Dmanual (myTexturePixMap);
+ myTexture = new Graphic3d_Texture2D (myTexturePixMap);
aTextureDesc = " (custom image)";
}
else if (myPredefTexture != Graphic3d_NOT_2D_UNKNOWN)
{
- myTexture = new Graphic3d_Texture2Dmanual (myPredefTexture);
+ myTexture = new Graphic3d_Texture2D (myPredefTexture);
aTextureDesc = TCollection_AsciiString(" (predefined texture ") + myTexture->GetId() + ")";
}
else
{
- myTexture = new Graphic3d_Texture2Dmanual (myTextureFile.ToCString());
+ myTexture = new Graphic3d_Texture2D (myTextureFile.ToCString());
aTextureDesc = TCollection_AsciiString(" (") + myTextureFile + ")";
}
#include <PrsMgr_PresentationManager.hxx>
class Graphic3d_AspectFillArea3d;
-class Graphic3d_Texture2Dmanual;
+class Graphic3d_Texture2D;
//! This class allows to map textures on shapes.
//! Presentations modes AIS_WireFrame (0) and AIS_Shaded (1) behave in the same manner as in AIS_Shape,
protected: //! @name presentation fields
- Handle(Graphic3d_Texture2Dmanual) myTexture;
+ Handle(Graphic3d_Texture2D) myTexture;
Handle(Graphic3d_AspectFillArea3d) myAspect;
protected: //! @name texture source fields
#include <SelectMgr_EntityOwner.hxx>
//! Texture holder.
-class AIS_XRTrackedDevice::XRTexture : public Graphic3d_Texture2Dmanual
+class AIS_XRTrackedDevice::XRTexture : public Graphic3d_Texture2D
{
public:
//! Constructor.
XRTexture (const Handle(Image_Texture)& theImageSource,
const Graphic3d_TextureUnit theUnit = Graphic3d_TextureUnit_BaseColor)
- : Graphic3d_Texture2Dmanual (""), myImageSource (theImageSource)
+ : Graphic3d_Texture2D (""), myImageSource (theImageSource)
{
if (!theImageSource->TextureId().IsEmpty())
{
const OpenGl_TextureFormat aDepthFormat = OpenGl_TextureFormat::FindSizedFormat (theCtx, myDepthFormat);
if (aDepthFormat.IsValid()
- && !myDepthStencilTexture->Init (theCtx, aDepthFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TOT_2D))
+ && !myDepthStencilTexture->Init (theCtx, aDepthFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TypeOfTexture_2D))
{
Release (theCtx.get());
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
Graphic3d_Texture1Dsegment.hxx
Graphic3d_Texture2D.cxx
Graphic3d_Texture2D.hxx
-Graphic3d_Texture2Dmanual.cxx
Graphic3d_Texture2Dmanual.hxx
Graphic3d_Texture2Dplane.cxx
Graphic3d_Texture2Dplane.hxx
+Graphic3d_Texture3D.cxx
+Graphic3d_Texture3D.hxx
Graphic3d_TextureEnv.cxx
Graphic3d_TextureEnv.hxx
Graphic3d_TextureMap.cxx
#include <Graphic3d_CubeMap.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_CubeMap, Graphic3d_TextureMap)
+
+// =======================================================================
+// function : Graphic3d_CubeMap
+// purpose :
+// =======================================================================
+Graphic3d_CubeMap::Graphic3d_CubeMap (const TCollection_AsciiString& theFileName,
+ Standard_Boolean theToGenerateMipmaps)
+: Graphic3d_TextureMap (theFileName, Graphic3d_TypeOfTexture_CUBEMAP),
+ myCurrentSide (Graphic3d_CMS_POS_X),
+ myEndIsReached (false),
+ myZIsInverted (false)
+{
+ myHasMipmaps = theToGenerateMipmaps;
+}
+
+// =======================================================================
+// function : Graphic3d_CubeMap
+// purpose :
+// =======================================================================
+Graphic3d_CubeMap::Graphic3d_CubeMap (const Handle(Image_PixMap)& thePixmap,
+ Standard_Boolean theToGenerateMipmaps)
+: Graphic3d_TextureMap (thePixmap, Graphic3d_TypeOfTexture_CUBEMAP),
+ myCurrentSide (Graphic3d_CMS_POS_X),
+ myEndIsReached (false),
+ myZIsInverted (false)
+{
+ myHasMipmaps = theToGenerateMipmaps;
+}
+
+// =======================================================================
+// function : ~Graphic3d_CubeMap
+// purpose :
+// =======================================================================
+Graphic3d_CubeMap::~Graphic3d_CubeMap()
+{
+ //
+}
public:
//! Constructor defining loading cubemap from file.
- Graphic3d_CubeMap (const TCollection_AsciiString& theFileName,
- Standard_Boolean theToGenerateMipmaps = Standard_False) :
- Graphic3d_TextureMap (theFileName, Graphic3d_TOT_CUBEMAP),
- myCurrentSide (Graphic3d_CMS_POS_X),
- myEndIsReached (false),
- myZIsInverted (false),
- myHasMipmaps (theToGenerateMipmaps)
- {}
+ Standard_EXPORT Graphic3d_CubeMap (const TCollection_AsciiString& theFileName,
+ Standard_Boolean theToGenerateMipmaps = Standard_False);
//! Constructor defining direct cubemap initialization from PixMap.
- Graphic3d_CubeMap (const Handle(Image_PixMap)& thePixmap = Handle(Image_PixMap)(),
- Standard_Boolean theToGenerateMipmaps = Standard_False) :
- Graphic3d_TextureMap (thePixmap, Graphic3d_TOT_CUBEMAP),
- myCurrentSide (Graphic3d_CMS_POS_X),
- myEndIsReached (false),
- myZIsInverted (false),
- myHasMipmaps (theToGenerateMipmaps)
- {}
+ Standard_EXPORT Graphic3d_CubeMap (const Handle(Image_PixMap)& thePixmap = Handle(Image_PixMap)(),
+ Standard_Boolean theToGenerateMipmaps = Standard_False);
//! Returns whether the iterator has reached the end (true if it hasn't).
Standard_Boolean More() const { return !myEndIsReached; }
}
//! Empty destructor.
- ~Graphic3d_CubeMap() {}
+ Standard_EXPORT virtual ~Graphic3d_CubeMap();
protected:
Graphic3d_CubeMapSide myCurrentSide; //!< Iterator state
Standard_Boolean myEndIsReached; //!< Indicates whether end of iteration has been reached or hasn't
Standard_Boolean myZIsInverted; //!< Indicates whether Z axis is inverted that allows to synchronize vertical flip of cubemap
- Standard_Boolean myHasMipmaps; //!< Indicates whether mipmaps of cubemap will be generated or not
};
// ================================================================
Graphic3d_MediaTexture::Graphic3d_MediaTexture (const Handle(Standard_HMutex)& theMutex,
Standard_Integer thePlane)
-: Graphic3d_Texture2D ("", Graphic3d_TOT_2D),
+: Graphic3d_Texture2D ("", Graphic3d_TypeOfTexture_2D),
myMutex (theMutex),
myPlane (thePlane)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-
#include <Graphic3d_Texture1Dmanual.hxx>
-#include <Graphic3d_TypeOfTextureMode.hxx>
-#include <Standard_Type.hxx>
+
#include <TCollection_AsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Texture1Dmanual,Graphic3d_Texture1D)
// purpose :
// =======================================================================
Graphic3d_Texture1Dmanual::Graphic3d_Texture1Dmanual (const TCollection_AsciiString& theFileName)
-: Graphic3d_Texture1D (theFileName, Graphic3d_TOT_1D)
+: Graphic3d_Texture1D (theFileName, Graphic3d_TypeOfTexture_1D)
{
//
}
// purpose :
// =======================================================================
Graphic3d_Texture1Dmanual::Graphic3d_Texture1Dmanual (const Graphic3d_NameOfTexture1D theNOT)
-: Graphic3d_Texture1D (theNOT, Graphic3d_TOT_1D)
+: Graphic3d_Texture1D (theNOT, Graphic3d_TypeOfTexture_1D)
{
//
}
// purpose :
// =======================================================================
Graphic3d_Texture1Dmanual::Graphic3d_Texture1Dmanual (const Handle(Image_PixMap)& thePixMap)
-: Graphic3d_Texture1D (thePixMap, Graphic3d_TOT_1D)
+: Graphic3d_Texture1D (thePixMap, Graphic3d_TypeOfTexture_1D)
{
//
}
#ifndef _Graphic3d_Texture1Dmanual_HeaderFile
#define _Graphic3d_Texture1Dmanual_HeaderFile
-#include <Standard.hxx>
-#include <Standard_Type.hxx>
-
#include <Graphic3d_Texture1D.hxx>
#include <Graphic3d_NameOfTexture1D.hxx>
-class TCollection_AsciiString;
-
-class Graphic3d_Texture1Dmanual;
DEFINE_STANDARD_HANDLE(Graphic3d_Texture1Dmanual, Graphic3d_Texture1D)
//! This class provides the implementation of a manual 1D texture.
-//! you MUST provides texture coordinates on your facets if you want to see your texture.
+//! you MUST provide texture coordinates on your facets if you want to see your texture.
class Graphic3d_Texture1Dmanual : public Graphic3d_Texture1D
{
-
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_Texture1Dmanual, Graphic3d_Texture1D)
public:
-
//! Creates a texture from the file FileName.
Standard_EXPORT Graphic3d_Texture1Dmanual(const TCollection_AsciiString& theFileName);
-
+
//! Create a texture from a predefined texture name set.
Standard_EXPORT Graphic3d_Texture1Dmanual(const Graphic3d_NameOfTexture1D theNOT);
-
+
//! Creates a texture from the pixmap.
Standard_EXPORT Graphic3d_Texture1Dmanual(const Handle(Image_PixMap)& thePixMap);
-
-
-
- DEFINE_STANDARD_RTTIEXT(Graphic3d_Texture1Dmanual,Graphic3d_Texture1D)
-
-protected:
-
-
-
-
-private:
-
-
-
-
};
-
-
-
-
-
-
#endif // _Graphic3d_Texture1Dmanual_HeaderFile
// purpose :
// =======================================================================
Graphic3d_Texture1Dsegment::Graphic3d_Texture1Dsegment (const TCollection_AsciiString& theFileName)
-: Graphic3d_Texture1D (theFileName, Graphic3d_TOT_1D),
+: Graphic3d_Texture1D (theFileName, Graphic3d_TypeOfTexture_1D),
myX1 (0.0f),
myY1 (0.0f),
myZ1 (0.0f),
// purpose :
// =======================================================================
Graphic3d_Texture1Dsegment::Graphic3d_Texture1Dsegment (const Graphic3d_NameOfTexture1D theNOT)
-: Graphic3d_Texture1D (theNOT, Graphic3d_TOT_1D),
+: Graphic3d_Texture1D (theNOT, Graphic3d_TypeOfTexture_1D),
myX1 (0.0f),
myY1 (0.0f),
myZ1 (0.0f),
// purpose :
// =======================================================================
Graphic3d_Texture1Dsegment::Graphic3d_Texture1Dsegment (const Handle(Image_PixMap)& thePixMap)
-: Graphic3d_Texture1D (thePixMap, Graphic3d_TOT_1D),
+: Graphic3d_Texture1D (thePixMap, Graphic3d_TypeOfTexture_1D),
myX1 (0.0f),
myY1 (0.0f),
myZ1 (0.0f),
#include <Graphic3d_Texture2D.hxx>
+#include <Graphic3d_TextureParams.hxx>
#include <Standard_OutOfRange.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Texture2D,Graphic3d_TextureMap)
"2d_chess.rgba"
};
+// =======================================================================
+// function : Graphic3d_Texture2D
+// purpose :
+// =======================================================================
+Graphic3d_Texture2D::Graphic3d_Texture2D (const TCollection_AsciiString& theFileName)
+: Graphic3d_TextureMap (theFileName, Graphic3d_TypeOfTexture_2D),
+ myName (Graphic3d_NOT_2D_UNKNOWN)
+{
+ myHasMipmaps = true;
+ myParams->SetModulate (true);
+ myParams->SetRepeat (true);
+ myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
+}
+
// =======================================================================
// function : Graphic3d_Texture2D
// purpose :
: Graphic3d_TextureMap (theFileName, theType),
myName (Graphic3d_NOT_2D_UNKNOWN)
{
+ //
+}
+
+// =======================================================================
+// function : Graphic3d_Texture2D
+// purpose :
+// =======================================================================
+Graphic3d_Texture2D::Graphic3d_Texture2D (const Graphic3d_NameOfTexture2D theNOT)
+: Graphic3d_TextureMap (NameOfTexture2d_to_FileName[theNOT], Graphic3d_TypeOfTexture_2D),
+ myName (theNOT)
+{
+ myPath.SetTrek (Graphic3d_TextureRoot::TexturesFolder());
+ myTexId = TCollection_AsciiString ("Graphic3d_Texture2D_")
+ + NameOfTexture2d_to_FileName[theNOT];
+
+ myHasMipmaps = true;
+ myParams->SetModulate (true);
+ myParams->SetRepeat (true);
+ myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
}
// =======================================================================
+ NameOfTexture2d_to_FileName[theNOT];
}
+// =======================================================================
+// function : Graphic3d_Texture2D
+// purpose :
+// =======================================================================
+Graphic3d_Texture2D::Graphic3d_Texture2D (const Handle(Image_PixMap)& thePixMap)
+: Graphic3d_TextureMap (thePixMap, Graphic3d_TypeOfTexture_2D),
+ myName (Graphic3d_NOT_2D_UNKNOWN)
+{
+ myHasMipmaps = true;
+ myParams->SetModulate (true);
+ myParams->SetRepeat (true);
+ myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
+}
+
// =======================================================================
// function : Graphic3d_Texture2D
// purpose :
: Graphic3d_TextureMap (thePixMap, theType),
myName (Graphic3d_NOT_2D_UNKNOWN)
{
+ //
}
// =======================================================================
public:
+ //! Creates a texture from a file.
+ //! MipMaps levels will be automatically generated if needed.
+ Standard_EXPORT Graphic3d_Texture2D (const TCollection_AsciiString& theFileName);
+
+ //! Creates a texture from a predefined texture name set.
+ //! MipMaps levels will be automatically generated if needed.
+ Standard_EXPORT Graphic3d_Texture2D (const Graphic3d_NameOfTexture2D theNOT);
+
+ //! Creates a texture from the pixmap.
+ //! MipMaps levels will be automatically generated if needed.
+ Standard_EXPORT Graphic3d_Texture2D (const Handle(Image_PixMap)& thePixMap);
+
//! Returns the name of the predefined textures or NOT_2D_UNKNOWN
//! when the name is given as a filename.
Standard_EXPORT Graphic3d_NameOfTexture2D Name() const;
//! Note that this method does not invalidate already uploaded resources - consider calling ::UpdateRevision() if needed.
Standard_EXPORT void SetImage (const Handle(Image_PixMap)& thePixMap);
- //! Return true if mip-maps should be used.
- Standard_Boolean HasMipMaps() const { return myType == Graphic3d_TOT_2D_MIPMAP; }
-
- //! Set if mip-maps should be used (generated if needed).
- //! Note that this method should be called before loading / using the texture.
- void SetMipMaps (const Standard_Boolean theToUse) { myType = theToUse ? Graphic3d_TOT_2D_MIPMAP : Graphic3d_TOT_2D; }
-
protected:
Standard_EXPORT Graphic3d_Texture2D(const TCollection_AsciiString& theFileName, const Graphic3d_TypeOfTexture theType);
+++ /dev/null
-// Created on: 1997-07-28
-// Created by: Pierre CHALAMET
-// Copyright (c) 1997-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Graphic3d_Texture2Dmanual.hxx>
-
-#include <Graphic3d_TextureParams.hxx>
-#include <Graphic3d_TypeOfTextureMode.hxx>
-
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Texture2Dmanual,Graphic3d_Texture2D)
-
-// =======================================================================
-// function : Graphic3d_Texture2Dmanual
-// purpose :
-// =======================================================================
-Graphic3d_Texture2Dmanual::Graphic3d_Texture2Dmanual (const TCollection_AsciiString& theFileName)
-: Graphic3d_Texture2D (theFileName, Graphic3d_TOT_2D_MIPMAP)
-{
- myParams->SetModulate (Standard_True);
- myParams->SetRepeat (Standard_True);
- myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
-}
-
-// =======================================================================
-// function : Graphic3d_Texture2Dmanual
-// purpose :
-// =======================================================================
-Graphic3d_Texture2Dmanual::Graphic3d_Texture2Dmanual (const Graphic3d_NameOfTexture2D theNOT)
-: Graphic3d_Texture2D (theNOT, Graphic3d_TOT_2D_MIPMAP)
-{
- myParams->SetModulate (Standard_True);
- myParams->SetRepeat (Standard_True);
- myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
-}
-
-// =======================================================================
-// function : Graphic3d_Texture2Dmanual
-// purpose :
-// =======================================================================
-Graphic3d_Texture2Dmanual::Graphic3d_Texture2Dmanual (const Handle(Image_PixMap)& thePixMap)
-: Graphic3d_Texture2D (thePixMap, Graphic3d_TOT_2D_MIPMAP)
-{
- myParams->SetModulate (Standard_True);
- myParams->SetRepeat (Standard_True);
- myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
-}
#include <Graphic3d_Texture2D.hxx>
#include <Graphic3d_NameOfTexture2D.hxx>
-//! This class defined a manual texture 2D
-//! facets MUST define texture coordinate
-//! if you want to see somethings on.
-class Graphic3d_Texture2Dmanual : public Graphic3d_Texture2D
-{
- DEFINE_STANDARD_RTTIEXT(Graphic3d_Texture2Dmanual,Graphic3d_Texture2D)
-public:
-
- //! Creates a texture from a file.
- //! MipMaps levels will be automatically generated if needed.
- Standard_EXPORT Graphic3d_Texture2Dmanual(const TCollection_AsciiString& theFileName);
-
- //! Creates a texture from a predefined texture name set.
- //! MipMaps levels will be automatically generated if needed.
- Standard_EXPORT Graphic3d_Texture2Dmanual(const Graphic3d_NameOfTexture2D theNOT);
-
- //! Creates a texture from the pixmap.
- //! MipMaps levels will be automatically generated if needed.
- Standard_EXPORT Graphic3d_Texture2Dmanual(const Handle(Image_PixMap)& thePixMap);
-
-};
-
-DEFINE_STANDARD_HANDLE(Graphic3d_Texture2Dmanual, Graphic3d_Texture2D)
+Standard_DEPRECATED ("Deprecated alias to Graphic3d_Texture2D")
+typedef Graphic3d_Texture2D Graphic3d_Texture2Dmanual;
#endif // _Graphic3d_Texture2Dmanual_HeaderFile
// purpose :
// =======================================================================
Graphic3d_Texture2Dplane::Graphic3d_Texture2Dplane (const TCollection_AsciiString& theFileName)
-: Graphic3d_Texture2D (theFileName, Graphic3d_TOT_2D_MIPMAP)
+: Graphic3d_Texture2D (theFileName)
{
- myParams->SetModulate (Standard_True);
- myParams->SetRepeat (Standard_True);
- myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
myParams->SetGenMode (Graphic3d_TOTM_OBJECT,
Graphic3d_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
Graphic3d_Vec4 (0.0f, 1.0f, 0.0f, 0.0f));
// purpose :
// =======================================================================
Graphic3d_Texture2Dplane::Graphic3d_Texture2Dplane (const Graphic3d_NameOfTexture2D theNOT)
-: Graphic3d_Texture2D (theNOT, Graphic3d_TOT_2D_MIPMAP)
+: Graphic3d_Texture2D (theNOT)
{
- myParams->SetModulate (Standard_True);
- myParams->SetRepeat (Standard_True);
- myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
myParams->SetGenMode (Graphic3d_TOTM_OBJECT,
Graphic3d_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
Graphic3d_Vec4 (0.0f, 1.0f, 0.0f, 0.0f));
// purpose :
// =======================================================================
Graphic3d_Texture2Dplane::Graphic3d_Texture2Dplane (const Handle(Image_PixMap)& thePixMap)
-: Graphic3d_Texture2D (thePixMap, Graphic3d_TOT_2D_MIPMAP)
+: Graphic3d_Texture2D (thePixMap)
{
- myParams->SetModulate (Standard_True);
- myParams->SetRepeat (Standard_True);
- myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
myParams->SetGenMode (Graphic3d_TOTM_OBJECT,
Graphic3d_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
Graphic3d_Vec4 (0.0f, 1.0f, 0.0f, 0.0f));
--- /dev/null
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <Graphic3d_Texture3D.hxx>
+
+#include <Graphic3d_TextureParams.hxx>
+#include <Image_AlienPixMap.hxx>
+#include <Message.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Texture3D, Graphic3d_TextureMap)
+
+// =======================================================================
+// function : Graphic3d_Texture3D
+// purpose :
+// =======================================================================
+Graphic3d_Texture3D::Graphic3d_Texture3D (const TCollection_AsciiString& theFileName)
+: Graphic3d_TextureMap (theFileName, Graphic3d_TypeOfTexture_3D)
+{
+ myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
+}
+
+// =======================================================================
+// function : Graphic3d_Texture3D
+// purpose :
+// =======================================================================
+Graphic3d_Texture3D::Graphic3d_Texture3D (const Handle(Image_PixMap)& thePixMap)
+: Graphic3d_TextureMap (thePixMap, Graphic3d_TypeOfTexture_3D)
+{
+ myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
+}
+
+// =======================================================================
+// function : Graphic3d_Texture3D
+// purpose :
+// =======================================================================
+Graphic3d_Texture3D::Graphic3d_Texture3D (const NCollection_Array1<TCollection_AsciiString>& theFiles)
+: Graphic3d_TextureMap ("", Graphic3d_TypeOfTexture_3D)
+{
+ myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
+ myPaths.Resize (theFiles.Lower(), theFiles.Upper(), false);
+ myPaths.Assign (theFiles);
+}
+
+// =======================================================================
+// function : ~Graphic3d_Texture3D
+// purpose :
+// =======================================================================
+Graphic3d_Texture3D::~Graphic3d_Texture3D()
+{
+ //
+}
+
+// =======================================================================
+// function : SetImage
+// purpose :
+// =======================================================================
+void Graphic3d_Texture3D::SetImage (const Handle(Image_PixMap)& thePixMap)
+{
+ myPixMap = thePixMap;
+ myPath = OSD_Path();
+
+ NCollection_Array1<TCollection_AsciiString> anArr;
+ myPaths.Move (anArr);
+}
+
+// =======================================================================
+// function : GetImage
+// purpose :
+// =======================================================================
+Handle(Image_PixMap) Graphic3d_Texture3D::GetImage (const Handle(Image_SupportedFormats)& theSupported)
+{
+ if (myPaths.IsEmpty()
+ || !myPixMap.IsNull())
+ {
+ return base_type::GetImage (theSupported);
+ }
+
+ Handle(Image_PixMap) anImage3D;
+ const Standard_Integer aNbSlices = myPaths.Length();
+ for (Standard_Integer aSlice = 0; aSlice < aNbSlices; ++aSlice)
+ {
+ const TCollection_AsciiString& aSlicePath = myPaths[myPaths.Lower() + aSlice];
+ Handle(Image_AlienPixMap) anImage = new Image_AlienPixMap();
+ if (!anImage->Load (aSlicePath))
+ {
+ Message::SendFail() << "Graphic3d_Texture3D::GetImage() failed to load slice " << aSlice << " from '" << aSlicePath << "'";
+ return Handle(Image_PixMap)();
+ }
+
+ convertToCompatible (theSupported, anImage);
+ if (anImage3D.IsNull())
+ {
+ myIsTopDown = anImage->IsTopDown();
+ anImage3D = new Image_PixMap();
+ anImage3D->SetTopDown (myIsTopDown);
+ if (!anImage3D->InitTrash3D (anImage->Format(),
+ NCollection_Vec3<Standard_Size> (anImage->SizeX(), anImage->SizeY(), aNbSlices),
+ anImage->SizeRowBytes()))
+ {
+ Message::SendFail() << "Graphic3d_Texture3D::GetImage() failed to allocate 3D image " << (int )anImage->SizeX() << "x" << (int )anImage->SizeY() << "x" << aNbSlices;
+ return Handle(Image_PixMap)();
+ }
+ }
+ if (anImage->Format() != anImage3D->Format()
+ || anImage->SizeX() != anImage3D->SizeX()
+ || anImage->SizeY() != anImage3D->SizeY()
+ || anImage->SizeRowBytes() != anImage3D->SizeRowBytes())
+ {
+ Message::SendFail() << "Graphic3d_Texture3D::GetImage() slice " << aSlice << " from '" << aSlicePath << "' have different dimensions";
+ return Handle(Image_PixMap)();
+ }
+
+ memcpy (anImage3D->ChangeSlice (aSlice), anImage->Data(), anImage->SizeBytes());
+ }
+
+ return anImage3D;
+}
--- /dev/null
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Graphic3d_Texture3D_HeaderFile
+#define _Graphic3d_Texture3D_HeaderFile
+
+#include <Graphic3d_TextureMap.hxx>
+#include <NCollection_Array1.hxx>
+
+//! This abstract class for managing 3D textures.
+class Graphic3d_Texture3D : public Graphic3d_TextureMap
+{
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_Texture3D, Graphic3d_TextureMap)
+public:
+
+ //! Creates a texture from a file.
+ Standard_EXPORT Graphic3d_Texture3D (const TCollection_AsciiString& theFileName);
+
+ //! Creates a texture from the pixmap.
+ Standard_EXPORT Graphic3d_Texture3D (const Handle(Image_PixMap)& thePixMap);
+
+ //! Creates a texture from a file.
+ Standard_EXPORT Graphic3d_Texture3D (const NCollection_Array1<TCollection_AsciiString>& theFiles);
+
+ //! Destructor.
+ Standard_EXPORT virtual ~Graphic3d_Texture3D();
+
+ //! Assign new image to the texture.
+ //! Note that this method does not invalidate already uploaded resources - consider calling ::UpdateRevision() if needed.
+ Standard_EXPORT void SetImage (const Handle(Image_PixMap)& thePixMap);
+
+ //! Load and return image.
+ Standard_EXPORT virtual Handle(Image_PixMap) GetImage (const Handle(Image_SupportedFormats)& theSupported) Standard_OVERRIDE;
+
+protected:
+
+ NCollection_Array1<TCollection_AsciiString> myPaths;
+
+};
+
+#endif // _Graphic3d_Texture3D_HeaderFile
// purpose :
// =======================================================================
Graphic3d_TextureEnv::Graphic3d_TextureEnv (const TCollection_AsciiString& theFileName)
-: Graphic3d_TextureRoot (theFileName, Graphic3d_TOT_2D_MIPMAP),
+: Graphic3d_TextureRoot (theFileName, Graphic3d_TypeOfTexture_2D),
myName (Graphic3d_NOT_ENV_UNKNOWN)
{
+ myHasMipmaps = true;
myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
myParams->SetGenMode (Graphic3d_TOTM_SPHERE,
Graphic3d_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
// purpose :
// =======================================================================
Graphic3d_TextureEnv::Graphic3d_TextureEnv (const Graphic3d_NameOfTextureEnv theNOT)
-: Graphic3d_TextureRoot (NameOfTextureEnv_to_FileName[theNOT], Graphic3d_TOT_2D_MIPMAP),
+: Graphic3d_TextureRoot (NameOfTextureEnv_to_FileName[theNOT], Graphic3d_TypeOfTexture_2D),
myName (theNOT)
{
+ myHasMipmaps = true;
myPath.SetTrek (Graphic3d_TextureRoot::TexturesFolder());
myTexId = TCollection_AsciiString ("Graphic3d_TextureEnv_")
+ NameOfTextureEnv_to_FileName[theNOT];
// purpose :
// =======================================================================
Graphic3d_TextureEnv::Graphic3d_TextureEnv (const Handle(Image_PixMap)& thePixMap)
-: Graphic3d_TextureRoot (thePixMap, Graphic3d_TOT_2D_MIPMAP),
+: Graphic3d_TextureRoot (thePixMap, Graphic3d_TypeOfTexture_2D),
myName (Graphic3d_NOT_ENV_UNKNOWN)
{
+ myHasMipmaps = true;
myParams->SetFilter (Graphic3d_TOTF_TRILINEAR);
myParams->SetGenMode (Graphic3d_TOTM_SPHERE,
Graphic3d_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
: myParams (new Graphic3d_TextureParams()),
myPath (theFileName),
myRevision (0),
- myType (theType),
+ myType (theType == Graphic3d_TOT_2D_MIPMAP ? Graphic3d_TypeOfTexture_2D : theType),
myIsColorMap (true),
- myIsTopDown (true)
+ myIsTopDown (true),
+ myHasMipmaps (theType == Graphic3d_TOT_2D_MIPMAP)
{
generateId();
}
: myParams (new Graphic3d_TextureParams()),
myPixMap (thePixMap),
myRevision (0),
- myType (theType),
+ myType (theType == Graphic3d_TOT_2D_MIPMAP ? Graphic3d_TypeOfTexture_2D : theType),
myIsColorMap (true),
- myIsTopDown (true)
+ myIsTopDown (true),
+ myHasMipmaps (theType == Graphic3d_TOT_2D_MIPMAP)
{
generateId();
}
//! Set flag indicating color nature of values within the texture.
void SetColorMap (Standard_Boolean theIsColor) { myIsColorMap = theIsColor; }
+ //! Returns whether mipmaps should be generated or not.
+ Standard_Boolean HasMipmaps() const { return myHasMipmaps; }
+
+ //! Sets whether to generate mipmaps or not.
+ void SetMipmapsGeneration (Standard_Boolean theToGenerateMipmaps) { myHasMipmaps = theToGenerateMipmaps; }
+
//! Returns whether row's memory layout is top-down.
Standard_Boolean IsTopDown() const { return myIsTopDown; }
Graphic3d_TypeOfTexture myType; //!< texture type
Standard_Boolean myIsColorMap; //!< flag indicating color nature of values within the texture
Standard_Boolean myIsTopDown; //!< Stores rows's memory layout
-
+ Standard_Boolean myHasMipmaps; //!< Indicates whether mipmaps should be generated or not
};
//! Type of the texture file format.
enum Graphic3d_TypeOfTexture
{
-Graphic3d_TOT_1D,
-Graphic3d_TOT_2D,
-Graphic3d_TOT_2D_MIPMAP,
-Graphic3d_TOT_CUBEMAP
+ //! 1D texture (array).
+ //! Note that this texture type might be unsupported by graphics API (emulated by 2D texture with 1 pixel height).
+ Graphic3d_TypeOfTexture_1D,
+
+ //! 2D texture (image plane).
+ Graphic3d_TypeOfTexture_2D,
+
+ //! 3D texture (a set of image planes).
+ Graphic3d_TypeOfTexture_3D,
+
+ //! Cubemap texture (6 image planes defining cube sides).
+ Graphic3d_TypeOfTexture_CUBEMAP,
+
+ //! Obsolete type - Graphic3d_TextureRoot::SetMipmapsGeneration() should be used instead.
+ Graphic3d_TOT_2D_MIPMAP,
+
+ // old aliases
+ Graphic3d_TOT_1D = Graphic3d_TypeOfTexture_1D,
+ Graphic3d_TOT_2D = Graphic3d_TypeOfTexture_2D,
+ Graphic3d_TOT_CUBEMAP = Graphic3d_TypeOfTexture_CUBEMAP
};
#endif // _Graphic3d_TypeOfTexture_HeaderFile
};
}
-IMPLEMENT_STANDARD_RTTIEXT(Image_PixMap,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(Image_PixMapData, NCollection_Buffer)
+IMPLEMENT_STANDARD_RTTIEXT(Image_PixMap, Standard_Transient)
// =======================================================================
// function : DefaultAllocator
}
// =======================================================================
-// function : InitWrapper
+// function : InitWrapper3D
// purpose :
// =======================================================================
-bool Image_PixMap::InitWrapper (Image_Format thePixelFormat,
- Standard_Byte* theDataPtr,
- const Standard_Size theSizeX,
- const Standard_Size theSizeY,
- const Standard_Size theSizeRowBytes)
+bool Image_PixMap::InitWrapper3D (Image_Format thePixelFormat,
+ Standard_Byte* theDataPtr,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes)
{
Clear();
myImgFormat = thePixelFormat;
- if ((theSizeX == 0) || (theSizeY == 0) || (theDataPtr == NULL))
+ if (theSizeXYZ.x() == 0
+ || theSizeXYZ.y() == 0
+ || theSizeXYZ.z() == 0
+ || theDataPtr == nullptr)
{
return false;
}
Handle(NCollection_BaseAllocator) anEmptyAlloc;
myData.Init (anEmptyAlloc, Image_PixMap::SizePixelBytes (thePixelFormat),
- theSizeX, theSizeY, theSizeRowBytes, theDataPtr);
+ theSizeXYZ, theSizeRowBytes, theDataPtr);
return true;
}
// =======================================================================
-// function : InitTrash
+// function : InitWrapper
// purpose :
// =======================================================================
-bool Image_PixMap::InitTrash (Image_Format thePixelFormat,
- const Standard_Size theSizeX,
- const Standard_Size theSizeY,
- const Standard_Size theSizeRowBytes)
+bool Image_PixMap::InitWrapper (Image_Format thePixelFormat,
+ Standard_Byte* theDataPtr,
+ const Standard_Size theSizeX,
+ const Standard_Size theSizeY,
+ const Standard_Size theSizeRowBytes)
+{
+ return InitWrapper3D (thePixelFormat, theDataPtr, NCollection_Vec3<Standard_Size> (theSizeX, theSizeY, 1), theSizeRowBytes);
+}
+
+// =======================================================================
+// function : InitTrash3D
+// purpose :
+// =======================================================================
+bool Image_PixMap::InitTrash3D (Image_Format thePixelFormat,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes)
{
Clear();
myImgFormat = thePixelFormat;
- if ((theSizeX == 0) || (theSizeY == 0))
+ if (theSizeXYZ.x() == 0
+ || theSizeXYZ.y() == 0
+ || theSizeXYZ.z() == 0)
{
return false;
}
// use argument only if it greater
- const Standard_Size aSizeRowBytes = std::max (theSizeRowBytes, theSizeX * SizePixelBytes (thePixelFormat));
+ const Standard_Size aSizeRowBytes = std::max (theSizeRowBytes, theSizeXYZ.x() * SizePixelBytes (thePixelFormat));
myData.Init (DefaultAllocator(), Image_PixMap::SizePixelBytes (thePixelFormat),
- theSizeX, theSizeY, aSizeRowBytes, NULL);
+ theSizeXYZ, aSizeRowBytes, NULL);
return !myData.IsEmpty();
}
// =======================================================================
-// function : InitZero
+// function : InitTrash
// purpose :
// =======================================================================
-bool Image_PixMap::InitZero (Image_Format thePixelFormat,
- const Standard_Size theSizeX,
- const Standard_Size theSizeY,
- const Standard_Size theSizeRowBytes,
- const Standard_Byte theValue)
+bool Image_PixMap::InitTrash (Image_Format thePixelFormat,
+ const Standard_Size theSizeX,
+ const Standard_Size theSizeY,
+ const Standard_Size theSizeRowBytes)
{
- if (!InitTrash (thePixelFormat, theSizeX, theSizeY, theSizeRowBytes))
+ return InitTrash3D (thePixelFormat, NCollection_Vec3<Standard_Size> (theSizeX, theSizeY, 1), theSizeRowBytes);
+}
+
+// =======================================================================
+// function : InitZero3D
+// purpose :
+// =======================================================================
+bool Image_PixMap::InitZero3D (Image_Format thePixelFormat,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes,
+ const Standard_Byte theValue)
+{
+ if (theSizeXYZ.z() > 1)
{
- return false;
+ if (!InitTrash3D (thePixelFormat, theSizeXYZ, theSizeRowBytes))
+ {
+ return false;
+ }
+ }
+ else
+ {
+ if (!InitTrash (thePixelFormat, theSizeXYZ.x(), theSizeXYZ.y(), theSizeRowBytes))
+ {
+ return false;
+ }
}
memset (myData.ChangeData(), (int )theValue, SizeBytes());
return true;
// self-copying disallowed
return false;
}
- if (InitTrash (theCopy.myImgFormat, theCopy.SizeX(), theCopy.SizeY(), theCopy.SizeRowBytes()))
+
+ if (theCopy.SizeZ() > 1)
+ {
+ if (!InitTrash3D (theCopy.myImgFormat, theCopy.SizeXYZ(), theCopy.SizeRowBytes()))
+ {
+ return false;
+ }
+ }
+ else
{
- memcpy (myData.ChangeData(), theCopy.myData.Data(), theCopy.SizeBytes());
- return true;
+ if (!InitTrash (theCopy.myImgFormat, theCopy.SizeX(), theCopy.SizeY(), theCopy.SizeRowBytes()))
+ {
+ return false;
+ }
}
- return false;
+
+ memcpy (myData.ChangeData(), theCopy.myData.Data(), theCopy.SizeBytes());
+ return true;
}
// =======================================================================
{
Handle(NCollection_BaseAllocator) anEmptyAlloc;
myData.Init (anEmptyAlloc, Image_PixMap::SizePixelBytes (myImgFormat),
- 0, 0, 0, NULL);
+ NCollection_Vec3<Standard_Size> (0), 0, nullptr);
}
// =======================================================================
-// function : PixelColor
+// function : ColorFromRawPixel
// purpose :
// =======================================================================
-Quantity_ColorRGBA Image_PixMap::PixelColor (const Standard_Integer theX,
- const Standard_Integer theY,
- const Standard_Boolean theToLinearize) const
+Quantity_ColorRGBA Image_PixMap::ColorFromRawPixel (const Standard_Byte* theRawValue,
+ const Image_Format theFormat,
+ const Standard_Boolean theToLinearize)
{
- if (IsEmpty()
- || theX < 0 || (Standard_Size )theX >= SizeX()
- || theY < 0 || (Standard_Size )theY >= SizeY())
- {
- return Quantity_ColorRGBA (0.0f, 0.0f, 0.0f, 0.0f); // transparent
- }
-
- switch (myImgFormat)
+ switch (theFormat)
{
case Image_Format_GrayF:
{
- const Standard_ShortReal& aPixel = Value<Standard_ShortReal> (theY, theX);
+ const Standard_ShortReal& aPixel = *reinterpret_cast<const Standard_ShortReal*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (aPixel, aPixel, aPixel, 1.0f)); // opaque
}
case Image_Format_AlphaF:
{
- const Standard_ShortReal& aPixel = Value<Standard_ShortReal> (theY, theX);
+ const Standard_ShortReal& aPixel = *reinterpret_cast<const Standard_ShortReal*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (1.0f, 1.0f, 1.0f, aPixel));
}
case Image_Format_RGF:
{
- const Image_ColorRGF& aPixel = Value<Image_ColorRGF> (theY, theX);
+ const Image_ColorRGF& aPixel = *reinterpret_cast<const Image_ColorRGF*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (aPixel.r(), aPixel.g(), 0.0f, 1.0f));
}
case Image_Format_RGBAF:
{
- const Image_ColorRGBAF& aPixel = Value<Image_ColorRGBAF> (theY, theX);
+ const Image_ColorRGBAF& aPixel = *reinterpret_cast<const Image_ColorRGBAF*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (aPixel.r(), aPixel.g(), aPixel.b(), aPixel.a()));
}
case Image_Format_BGRAF:
{
- const Image_ColorBGRAF& aPixel = Value<Image_ColorBGRAF> (theY, theX);
+ const Image_ColorBGRAF& aPixel = *reinterpret_cast<const Image_ColorBGRAF*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (aPixel.r(), aPixel.g(), aPixel.b(), aPixel.a()));
}
case Image_Format_RGBF:
{
- const Image_ColorRGBF& aPixel = Value<Image_ColorRGBF> (theY, theX);
+ const Image_ColorRGBF& aPixel = *reinterpret_cast<const Image_ColorRGBF*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (aPixel.r(), aPixel.g(), aPixel.b(), 1.0f)); // opaque
}
case Image_Format_BGRF:
{
- const Image_ColorBGRF& aPixel = Value<Image_ColorBGRF> (theY, theX);
+ const Image_ColorBGRF& aPixel = *reinterpret_cast<const Image_ColorBGRF*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (aPixel.r(), aPixel.g(), aPixel.b(), 1.0f)); // opaque
}
case Image_Format_GrayF_half:
{
- const uint16_t& aPixel = Value<uint16_t> (theY, theX);
+ const uint16_t& aPixel = *reinterpret_cast<const uint16_t*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (ConvertFromHalfFloat (aPixel), 0.0f, 0.0f, 1.0f));
}
case Image_Format_RGF_half:
{
- const NCollection_Vec2<uint16_t>& aPixel = Value<NCollection_Vec2<uint16_t>> (theY, theX);
+ const NCollection_Vec2<uint16_t>& aPixel = *reinterpret_cast<const NCollection_Vec2<uint16_t>*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (ConvertFromHalfFloat (aPixel.x()), ConvertFromHalfFloat (aPixel.y()), 0.0f, 1.0f));
}
case Image_Format_RGBAF_half:
{
- const NCollection_Vec4<uint16_t>& aPixel = Value<NCollection_Vec4<uint16_t>> (theY, theX);
+ const NCollection_Vec4<uint16_t>& aPixel = *reinterpret_cast<const NCollection_Vec4<uint16_t>*> (theRawValue);
return Quantity_ColorRGBA (NCollection_Vec4<float> (ConvertFromHalfFloat (aPixel.r()), ConvertFromHalfFloat (aPixel.g()),
ConvertFromHalfFloat (aPixel.b()), ConvertFromHalfFloat (aPixel.a())));
}
case Image_Format_RGBA:
{
- const Image_ColorRGBA& aPixel = Value<Image_ColorRGBA> (theY, theX);
+ const Image_ColorRGBA& aPixel = *reinterpret_cast<const Image_ColorRGBA*> (theRawValue);
return theToLinearize
? Quantity_ColorRGBA (Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.r()) / 255.0f),
Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.g()) / 255.0f),
}
case Image_Format_BGRA:
{
- const Image_ColorBGRA& aPixel = Value<Image_ColorBGRA> (theY, theX);
+ const Image_ColorBGRA& aPixel = *reinterpret_cast<const Image_ColorBGRA*> (theRawValue);
return theToLinearize
? Quantity_ColorRGBA (Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.r()) / 255.0f),
Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.g()) / 255.0f),
}
case Image_Format_RGB32:
{
- const Image_ColorRGB32& aPixel = Value<Image_ColorRGB32> (theY, theX);
+ const Image_ColorRGB32& aPixel = *reinterpret_cast<const Image_ColorRGB32*> (theRawValue);
return theToLinearize
? Quantity_ColorRGBA (Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.r()) / 255.0f),
Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.g()) / 255.0f),
}
case Image_Format_BGR32:
{
- const Image_ColorBGR32& aPixel = Value<Image_ColorBGR32> (theY, theX);
+ const Image_ColorBGR32& aPixel = *reinterpret_cast<const Image_ColorBGR32*> (theRawValue);
return theToLinearize
? Quantity_ColorRGBA (Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.r()) / 255.0f),
Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.g()) / 255.0f),
}
case Image_Format_RGB:
{
- const Image_ColorRGB& aPixel = Value<Image_ColorRGB> (theY, theX);
+ const Image_ColorRGB& aPixel = *reinterpret_cast<const Image_ColorRGB*> (theRawValue);
return theToLinearize
? Quantity_ColorRGBA (Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.r()) / 255.0f),
Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.g()) / 255.0f),
}
case Image_Format_BGR:
{
- const Image_ColorBGR& aPixel = Value<Image_ColorBGR> (theY, theX);
+ const Image_ColorBGR& aPixel = *reinterpret_cast<const Image_ColorBGR*> (theRawValue);
return theToLinearize
? Quantity_ColorRGBA (Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.r()) / 255.0f),
Quantity_Color::Convert_sRGB_To_LinearRGB (float(aPixel.g()) / 255.0f),
}
case Image_Format_Gray:
{
- const Standard_Byte& aPixel = Value<Standard_Byte> (theY, theX);
+ const Standard_Byte& aPixel = *reinterpret_cast<const Standard_Byte*> (theRawValue);
const float anIntensity = float(aPixel) / 255.0f;
return Quantity_ColorRGBA (anIntensity, anIntensity, anIntensity, 1.0f); // opaque
}
case Image_Format_Alpha:
{
- const Standard_Byte& aPixel = Value<Standard_Byte> (theY, theX);
+ const Standard_Byte& aPixel = *reinterpret_cast<const Standard_Byte*> (theRawValue);
return Quantity_ColorRGBA (1.0f, 1.0f, 1.0f, float(aPixel) / 255.0f);
}
case Image_Format_Gray16:
{
- const uint16_t& aPixel = Value<uint16_t> (theY, theX);
+ const uint16_t& aPixel = *reinterpret_cast<const uint16_t*> (theRawValue);
const float anIntensity = float(aPixel) / 65535.0f;
return Quantity_ColorRGBA (anIntensity, anIntensity, anIntensity, 1.0f); // opaque
}
}
// =======================================================================
-// function : SetPixelColor
+// function : ColorToRawPixel
// purpose :
// =======================================================================
-void Image_PixMap::SetPixelColor (const Standard_Integer theX,
- const Standard_Integer theY,
- const Quantity_ColorRGBA& theColor,
- const Standard_Boolean theToDeLinearize)
+void Image_PixMap::ColorToRawPixel (Standard_Byte* theRawValue,
+ const Image_Format theFormat,
+ const Quantity_ColorRGBA& theColor,
+ const Standard_Boolean theToDeLinearize)
{
- if (IsEmpty()
- || theX < 0 || Standard_Size(theX) >= SizeX()
- || theY < 0 || Standard_Size(theY) >= SizeY())
- {
- return;
- }
-
const NCollection_Vec4<float>& aColor = theColor;
- switch (myImgFormat)
+ switch (theFormat)
{
case Image_Format_GrayF:
{
- ChangeValue<Standard_ShortReal> (theY, theX) = aColor.r();
+ *reinterpret_cast<Standard_ShortReal*> (theRawValue) = aColor.r();
return;
}
case Image_Format_AlphaF:
{
- ChangeValue<Standard_ShortReal> (theY, theX) = aColor.a();
+ *reinterpret_cast<Standard_ShortReal*> (theRawValue) = aColor.a();
return;
}
case Image_Format_RGF:
{
- Image_ColorRGF& aPixel = ChangeValue<Image_ColorRGF> (theY, theX);
+ Image_ColorRGF& aPixel = *reinterpret_cast<Image_ColorRGF*> (theRawValue);
aPixel.r() = aColor.r();
aPixel.g() = aColor.g();
return;
}
case Image_Format_RGBAF:
{
- Image_ColorRGBAF& aPixel = ChangeValue<Image_ColorRGBAF> (theY, theX);
+ Image_ColorRGBAF& aPixel = *reinterpret_cast<Image_ColorRGBAF*> (theRawValue);
aPixel.r() = aColor.r();
aPixel.g() = aColor.g();
aPixel.b() = aColor.b();
}
case Image_Format_BGRAF:
{
- Image_ColorBGRAF& aPixel = ChangeValue<Image_ColorBGRAF> (theY, theX);
+ Image_ColorBGRAF& aPixel = *reinterpret_cast<Image_ColorBGRAF*> (theRawValue);
aPixel.r() = aColor.r();
aPixel.g() = aColor.g();
aPixel.b() = aColor.b();
}
case Image_Format_RGBF:
{
- Image_ColorRGBF& aPixel = ChangeValue<Image_ColorRGBF> (theY, theX);
+ Image_ColorRGBF& aPixel = *reinterpret_cast<Image_ColorRGBF*> (theRawValue);
aPixel.r() = aColor.r();
aPixel.g() = aColor.g();
aPixel.b() = aColor.b();
}
case Image_Format_BGRF:
{
- Image_ColorBGRF& aPixel = ChangeValue<Image_ColorBGRF> (theY, theX);
+ Image_ColorBGRF& aPixel = *reinterpret_cast<Image_ColorBGRF*> (theRawValue);
aPixel.r() = aColor.r();
aPixel.g() = aColor.g();
aPixel.b() = aColor.b();
}
case Image_Format_GrayF_half:
{
- uint16_t& aPixel = ChangeValue<uint16_t> (theY, theX);
+ uint16_t& aPixel = *reinterpret_cast<uint16_t*> (theRawValue);
aPixel = ConvertToHalfFloat (aColor.r());
return;
}
case Image_Format_RGF_half:
{
- NCollection_Vec2<uint16_t>& aPixel = ChangeValue<NCollection_Vec2<uint16_t>> (theY, theX);
+ NCollection_Vec2<uint16_t>& aPixel = *reinterpret_cast<NCollection_Vec2<uint16_t>*> (theRawValue);
aPixel.x() = ConvertToHalfFloat (aColor.r());
aPixel.y() = ConvertToHalfFloat (aColor.g());
return;
}
case Image_Format_RGBAF_half:
{
- NCollection_Vec4<uint16_t>& aPixel = ChangeValue<NCollection_Vec4<uint16_t>> (theY, theX);
+ NCollection_Vec4<uint16_t>& aPixel = *reinterpret_cast<NCollection_Vec4<uint16_t>*> (theRawValue);
aPixel.r() = ConvertToHalfFloat (aColor.r());
aPixel.g() = ConvertToHalfFloat (aColor.g());
aPixel.b() = ConvertToHalfFloat (aColor.b());
}
case Image_Format_RGBA:
{
- Image_ColorRGBA& aPixel = ChangeValue<Image_ColorRGBA> (theY, theX);
+ Image_ColorRGBA& aPixel = *reinterpret_cast<Image_ColorRGBA*> (theRawValue);
if (theToDeLinearize)
{
aPixel.r() = Standard_Byte(Quantity_Color::Convert_LinearRGB_To_sRGB (aColor.r()) * 255.0f);
}
case Image_Format_BGRA:
{
- Image_ColorBGRA& aPixel = ChangeValue<Image_ColorBGRA> (theY, theX);
+ Image_ColorBGRA& aPixel = *reinterpret_cast<Image_ColorBGRA*> (theRawValue);
if (theToDeLinearize)
{
aPixel.r() = Standard_Byte(Quantity_Color::Convert_LinearRGB_To_sRGB (aColor.r()) * 255.0f);
}
case Image_Format_RGB32:
{
- Image_ColorRGB32& aPixel = ChangeValue<Image_ColorRGB32> (theY, theX);
+ Image_ColorRGB32& aPixel = *reinterpret_cast<Image_ColorRGB32*> (theRawValue);
if (theToDeLinearize)
{
aPixel.r() = Standard_Byte(Quantity_Color::Convert_LinearRGB_To_sRGB (aColor.r()) * 255.0f);
}
case Image_Format_BGR32:
{
- Image_ColorBGR32& aPixel = ChangeValue<Image_ColorBGR32> (theY, theX);
+ Image_ColorBGR32& aPixel = *reinterpret_cast<Image_ColorBGR32*> (theRawValue);
if (theToDeLinearize)
{
aPixel.r() = Standard_Byte(Quantity_Color::Convert_LinearRGB_To_sRGB (aColor.r()) * 255.0f);
}
case Image_Format_RGB:
{
- Image_ColorRGB& aPixel = ChangeValue<Image_ColorRGB> (theY, theX);
+ Image_ColorRGB& aPixel = *reinterpret_cast<Image_ColorRGB*> (theRawValue);
if (theToDeLinearize)
{
aPixel.r() = Standard_Byte(Quantity_Color::Convert_LinearRGB_To_sRGB (aColor.r()) * 255.0f);
}
case Image_Format_BGR:
{
- Image_ColorBGR& aPixel = ChangeValue<Image_ColorBGR> (theY, theX);
+ Image_ColorBGR& aPixel = *reinterpret_cast<Image_ColorBGR*> (theRawValue);
if (theToDeLinearize)
{
aPixel.r() = Standard_Byte(Quantity_Color::Convert_LinearRGB_To_sRGB (aColor.r()) * 255.0f);
}
case Image_Format_Gray:
{
- ChangeValue<Standard_Byte> (theY, theX) = Standard_Byte(aColor.r() * 255.0f);
+ *reinterpret_cast<Standard_Byte*>(theRawValue) = Standard_Byte(aColor.r() * 255.0f);
return;
}
case Image_Format_Alpha:
{
- ChangeValue<Standard_Byte> (theY, theX) = Standard_Byte(aColor.a() * 255.0f);
+ *reinterpret_cast<Standard_Byte*>(theRawValue) = Standard_Byte(aColor.a() * 255.0f);
return;
}
case Image_Format_Gray16:
{
- ChangeValue<uint16_t> (theY, theX) = uint16_t(aColor.r() * 65535.0f);
+ *reinterpret_cast<uint16_t*>(theRawValue) = uint16_t(aColor.r() * 65535.0f);
return;
}
case Image_Format_UNKNOWN:
{
const bool toResetAlpha = theImage.Format() == Image_Format_BGR32
|| theImage.Format() == Image_Format_RGB32;
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- Image_ColorRGBA& aPixel = theImage.ChangeValue<Image_ColorRGBA> (aRow, aCol);
- Image_ColorBGRA aPixelCopy = theImage.Value <Image_ColorBGRA> (aRow, aCol);
- aPixel.r() = aPixelCopy.r();
- aPixel.g() = aPixelCopy.g();
- aPixel.b() = aPixelCopy.b();
- if (toResetAlpha)
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
{
- aPixel.a() = 255;
+ Image_ColorRGBA& aPixel = theImage.ChangeValueXYZ<Image_ColorRGBA> (aCol, aRow, aSlice);
+ Image_ColorBGRA aPixelCopy = theImage.ValueXYZ <Image_ColorBGRA> (aCol, aRow, aSlice);
+ aPixel.r() = aPixelCopy.r();
+ aPixel.g() = aPixelCopy.g();
+ aPixel.b() = aPixelCopy.b();
+ if (toResetAlpha)
+ {
+ aPixel.a() = 255;
+ }
}
}
}
case Image_Format_BGR:
case Image_Format_RGB:
{
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- Image_ColorRGB& aPixel = theImage.ChangeValue<Image_ColorRGB> (aRow, aCol);
- Image_ColorBGR aPixelCopy = theImage.Value <Image_ColorBGR> (aRow, aCol);
- aPixel.r() = aPixelCopy.r();
- aPixel.g() = aPixelCopy.g();
- aPixel.b() = aPixelCopy.b();
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ {
+ Image_ColorRGB& aPixel = theImage.ChangeValueXYZ<Image_ColorRGB> (aCol, aRow, aSlice);
+ Image_ColorBGR aPixelCopy = theImage.ValueXYZ <Image_ColorBGR> (aCol, aRow, aSlice);
+ aPixel.r() = aPixelCopy.r();
+ aPixel.g() = aPixelCopy.g();
+ aPixel.b() = aPixelCopy.b();
+ }
}
}
return true;
case Image_Format_BGRAF:
case Image_Format_RGBAF:
{
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- Image_ColorRGBF& aPixel = theImage.ChangeValue<Image_ColorRGBF> (aRow, aCol);
- Image_ColorBGRF aPixelCopy = theImage.Value <Image_ColorBGRF> (aRow, aCol);
- aPixel.r() = aPixelCopy.r();
- aPixel.g() = aPixelCopy.g();
- aPixel.b() = aPixelCopy.b();
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ {
+ Image_ColorRGBF& aPixel = theImage.ChangeValueXYZ<Image_ColorRGBF> (aCol, aRow, aSlice);
+ Image_ColorBGRF aPixelCopy = theImage.ValueXYZ <Image_ColorBGRF> (aCol, aRow, aSlice);
+ aPixel.r() = aPixelCopy.r();
+ aPixel.g() = aPixelCopy.g();
+ aPixel.b() = aPixelCopy.b();
+ }
}
}
return true;
case Image_Format_Gray:
case Image_Format_Alpha:
{
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- unsigned char& aPixel = theImage.ChangeValue<unsigned char> (aRow, aCol);
- if (aPixel != 0)
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
{
- aPixel = 255;
+ uint8_t& aPixel = theImage.ChangeValueXYZ<uint8_t> (aCol, aRow, aSlice);
+ if (aPixel != 0)
+ {
+ aPixel = 255;
+ }
}
}
}
}
case Image_Format_Gray16:
{
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- uint16_t& aPixel = theImage.ChangeValue<uint16_t> (aRow, aCol);
- if (aPixel != 0)
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
{
- aPixel = 65535;
+ uint16_t& aPixel = theImage.ChangeValueXYZ<uint16_t> (aCol, aRow, aSlice);
+ if (aPixel != 0)
+ {
+ aPixel = 65535;
+ }
}
}
}
case Image_Format_RGBA:
case Image_Format_BGRA:
{
- const NCollection_Vec3<unsigned char> aWhite24 (255, 255, 255);
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ const NCollection_Vec3<uint8_t> aWhite24 (255, 255, 255);
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- NCollection_Vec3<unsigned char>& aPixel = theImage.ChangeValue< NCollection_Vec3<unsigned char> > (aRow, aCol);
- if (aPixel[0] != 0
- || aPixel[1] != 0
- || aPixel[2] != 0)
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
{
- aPixel = aWhite24;
+ NCollection_Vec3<uint8_t>& aPixel = theImage.ChangeValueXYZ< NCollection_Vec3<uint8_t> > (aCol, aRow, aSlice);
+ if (aPixel[0] != 0
+ || aPixel[1] != 0
+ || aPixel[2] != 0)
+ {
+ aPixel = aWhite24;
+ }
}
}
}
default:
{
const Quantity_ColorRGBA aWhiteRgba (1.0f, 1.0f, 1.0f, 1.0f);
- for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
+ for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
- const Quantity_ColorRGBA aPixelRgba = theImage.PixelColor (Standard_Integer(aCol), Standard_Integer(aRow));
- const NCollection_Vec4<float>& aPixel = aPixelRgba;
- if (aPixel[0] != 0.0f
- || aPixel[1] != 0.0f
- || aPixel[2] != 0.0f)
+ for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
{
- theImage.SetPixelColor (int(aCol), int(aRow), aWhiteRgba);
+ Standard_Byte* aRawPixel = theImage.ChangeRawValueXYZ (aCol, aRow, aSlice);
+ const Quantity_ColorRGBA aPixelRgba = ColorFromRawPixel (aRawPixel, theImage.Format());
+ const NCollection_Vec4<float>& aPixel = aPixelRgba;
+ if (aPixel[0] != 0.0f
+ || aPixel[1] != 0.0f
+ || aPixel[2] != 0.0f)
+ {
+ ColorToRawPixel (aRawPixel, theImage.Format(), aWhiteRgba);
+ }
}
}
}
}
// =======================================================================
-// function : InitCopy
+// function : FlipY
// purpose :
// =======================================================================
bool Image_PixMap::FlipY (Image_PixMap& theImage)
// for odd height middle row should be left as is
Standard_Size aNbRowsHalf = theImage.SizeY() / 2;
- for (Standard_Size aRowT = 0, aRowB = theImage.SizeY() - 1; aRowT < aNbRowsHalf; ++aRowT, --aRowB)
+ for (Standard_Size aSlice = 0; aSlice < theImage.SizeZ(); ++aSlice)
{
- Standard_Byte* aTop = theImage.ChangeRow (aRowT);
- Standard_Byte* aBot = theImage.ChangeRow (aRowB);
- memcpy (aTmp.ChangeData(), aTop, aRowSize);
- memcpy (aTop, aBot, aRowSize);
- memcpy (aBot, aTmp.Data(), aRowSize);
+ for (Standard_Size aRowT = 0, aRowB = theImage.SizeY() - 1; aRowT < aNbRowsHalf; ++aRowT, --aRowB)
+ {
+ Standard_Byte* aTop = theImage.ChangeSliceRow (aSlice, aRowT);
+ Standard_Byte* aBot = theImage.ChangeSliceRow (aSlice, aRowB);
+ memcpy (aTmp.ChangeData(), aTop, aRowSize);
+ memcpy (aTop, aBot, aRowSize);
+ memcpy (aBot, aTmp.Data(), aRowSize);
+ }
}
return true;
}
return !aUnion.myChar[0];
}
+ //! Return bytes reserved for one pixel (may include extra bytes for alignment).
+ Standard_EXPORT static Standard_Size SizePixelBytes (const Image_Format thePixelFormat);
+
//! Auxiliary method for swapping bytes between RGB and BGR formats.
//! This method modifies the image data but does not change pixel format!
//! Method will fail if pixel format is not one of the following:
//! Return string representation of compressed pixel format.
Standard_EXPORT static Standard_CString ImageFormatToString (Image_CompressedFormat theFormat);
+ //! Convert raw pixel value into Quantity_ColorRGBA. This function is relatively slow.
+ //! @param[in] theRawValue pointer to pixel definition
+ //! @param[in] theFormat pixel format
+ //! @param[in] theToLinearize when TRUE, the color stored in non-linear color space (e.g. Image_Format_RGB) will be linearized
+ //! @return the pixel color
+ Standard_EXPORT static Quantity_ColorRGBA ColorFromRawPixel (const Standard_Byte* theRawValue,
+ const Image_Format theFormat,
+ const Standard_Boolean theToLinearize = false);
+
+ //! Set raw pixel value from Quantity_ColorRGBA. This function is relatively slow.
+ //! @param[out] theRawValue pointer to pixel definition to modify
+ //! @param[in] theFormat pixel format
+ //! @param[in] theColor color value to convert from
+ //! @param[in] theToDeLinearize when TRUE, the gamma correction will be applied for storing in non-linear color space (e.g. Image_Format_RGB)
+ Standard_EXPORT static void ColorToRawPixel (Standard_Byte* theRawValue,
+ const Image_Format theFormat,
+ const Quantity_ColorRGBA& theColor,
+ const Standard_Boolean theToDeLinearize = false);
+
public: // high-level API
//! Return pixel format.
//! (e.g. ImgGray and ImgAlpha).
Standard_EXPORT void SetFormat (const Image_Format thePixelFormat);
- //! Return image width in pixels
+ //! Return image width in pixels.
Standard_Size Width() const { return myData.SizeX; }
- //! Return image height in pixels
+ //! Return image height in pixels.
Standard_Size Height() const { return myData.SizeY; }
- //! Return image width in pixels
+ //! Return image depth in pixels.
+ Standard_Size Depth() const { return myData.SizeZ; }
+
+ //! Return image width in pixels.
Standard_Size SizeX() const { return myData.SizeX; }
- //! Return image height in pixels
+ //! Return image height in pixels.
Standard_Size SizeY() const { return myData.SizeY; }
+ //! Return image depth in pixels.
+ Standard_Size SizeZ() const { return myData.SizeZ; }
+
+ //! Return image width x height x depth in pixels.
+ NCollection_Vec3<Standard_Size> SizeXYZ() const
+ {
+ return NCollection_Vec3<Standard_Size> (myData.SizeX, myData.SizeY, myData.SizeZ);
+ }
+
//! Return width / height.
Standard_Real Ratio() const
{
//! Returns the pixel color. This function is relatively slow.
//! Beware that this method takes coordinates in opposite order in contrast to ::Value() and ::ChangeValue().
- //! @param theX [in] column index from left
- //! @param theY [in] row index from top
- //! @param theToLinearize [in] when TRUE, the color stored in non-linear color space (e.g. Image_Format_RGB) will be linearized
+ //! @param[in] theX column index from left, starting from 0
+ //! @param[in] theY row index from top, starting from 0
+ //! @param[in] theToLinearize when TRUE, the color stored in non-linear color space (e.g. Image_Format_RGB) will be linearized
//! @return the pixel color
- Standard_EXPORT Quantity_ColorRGBA PixelColor (const Standard_Integer theX,
- const Standard_Integer theY,
- const Standard_Boolean theToLinearize = Standard_False) const;
+ Quantity_ColorRGBA PixelColor (Standard_Integer theX,
+ Standard_Integer theY,
+ Standard_Boolean theToLinearize = false) const
+ {
+ if (IsEmpty()
+ || theX < 0 || (Standard_Size )theX >= SizeX()
+ || theY < 0 || (Standard_Size )theY >= SizeY())
+ {
+ return Quantity_ColorRGBA (0.0f, 0.0f, 0.0f, 0.0f); // transparent
+ }
+
+ const Standard_Byte* aRawPixel = RawValueXY (theX, theY);
+ return ColorFromRawPixel (aRawPixel, myImgFormat, theToLinearize);
+ }
//! Sets the pixel color. This function is relatively slow.
//! Beware that this method takes coordinates in opposite order in contrast to ::Value() and ::ChangeValue().
- //! @param theX [in] column index from left
- //! @param theY [in] row index from top
- //! @param theColor [in] color to store
- //! @param theToDeLinearize [in] when TRUE, the gamma correction will be applied for storing in non-linear color space (e.g. Image_Format_RGB)
+ //! @param[in] theX column index from left
+ //! @param[in] theY row index from top
+ //! @param[in] theColor color to store
+ //! @param[in] theToDeLinearize when TRUE, the gamma correction will be applied for storing in non-linear color space (e.g. Image_Format_RGB)
void SetPixelColor (const Standard_Integer theX,
const Standard_Integer theY,
const Quantity_Color& theColor,
- const Standard_Boolean theToDeLinearize = Standard_False)
+ const Standard_Boolean theToDeLinearize = false)
{
SetPixelColor (theX, theY, Quantity_ColorRGBA (theColor, 1.0f), theToDeLinearize);
}
//! Sets the pixel color. This function is relatively slow.
//! Beware that this method takes coordinates in opposite order in contrast to ::Value() and ::ChangeValue().
- //! @param theX [in] column index from left
- //! @param theY [in] row index from top
- //! @param theColor [in] color to store
- //! @param theToDeLinearize [in] when TRUE, the gamma correction will be applied for storing in non-linear color space (e.g. Image_Format_RGB)
- Standard_EXPORT void SetPixelColor (const Standard_Integer theX,
- const Standard_Integer theY,
- const Quantity_ColorRGBA& theColor,
- const Standard_Boolean theToDeLinearize = Standard_False);
+ //! @param[in] theX column index from left
+ //! @param[in] theY row index from top
+ //! @param[in] theColor color to store
+ //! @param[in] theToDeLinearize when TRUE, the gamma correction will be applied for storing in non-linear color space (e.g. Image_Format_RGB)
+ void SetPixelColor (const Standard_Integer theX,
+ const Standard_Integer theY,
+ const Quantity_ColorRGBA& theColor,
+ const Standard_Boolean theToDeLinearize = false)
+ {
+ if (IsEmpty()
+ || theX < 0 || Standard_Size(theX) >= SizeX()
+ || theY < 0 || Standard_Size(theY) >= SizeY())
+ {
+ return;
+ }
+
+ Standard_Byte* aRawPixel = ChangeRawValueXY (theX, theY);
+ ColorToRawPixel (aRawPixel, myImgFormat, theColor, theToDeLinearize);
+ }
//! Initialize image plane as wrapper over alien data.
//! Data will not be copied! Notice that caller should ensure
//! Initialize image plane with required dimensions.
//! Buffer will be zeroed (black color for most formats).
- Standard_EXPORT bool InitZero (Image_Format thePixelFormat,
- const Standard_Size theSizeX,
- const Standard_Size theSizeY,
- const Standard_Size theSizeRowBytes = 0,
- const Standard_Byte theValue = 0);
+ bool InitZero (Image_Format thePixelFormat,
+ const Standard_Size theSizeX,
+ const Standard_Size theSizeY,
+ const Standard_Size theSizeRowBytes = 0,
+ const Standard_Byte theValue = 0)
+ {
+ return InitZero3D (thePixelFormat, NCollection_Vec3<Standard_Size> (theSizeX, theSizeY, 1), theSizeRowBytes, theValue);
+ }
//! Method correctly deallocate internal buffer.
Standard_EXPORT virtual void Clear();
+public:
+
+ //! Initialize 2D/3D image as wrapper over alien data.
+ //! Data will not be copied! Notice that caller should ensure
+ //! that data pointer will not be released during this wrapper lifetime.
+ //! You may call InitCopy() to perform data copying.
+ Standard_EXPORT virtual bool InitWrapper3D (Image_Format thePixelFormat,
+ Standard_Byte* theDataPtr,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes = 0);
+
+ //! Initialize 2D/3D image with required dimensions.
+ //! Memory will be left uninitialized (performance trick).
+ Standard_EXPORT virtual bool InitTrash3D (Image_Format thePixelFormat,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes = 0);
+
+ //! Initialize 2D/3D image with required dimensions.
+ //! Buffer will be zeroed (black color for most formats).
+ Standard_EXPORT bool InitZero3D (Image_Format thePixelFormat,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes = 0,
+ const Standard_Byte theValue = 0);
+
public: //! @name low-level API for batch-processing (pixels reading / comparison / modification)
//! Returns TRUE if image data is stored from Top to the Down.
//! convert input row-index to apply this flag!
//! You should use this flag only if interconnect with alien APIs and buffers.
//! @return true if image data is top-down
- inline bool IsTopDown() const
- {
- return myData.TopToDown == 1;
- }
+ bool IsTopDown() const { return myData.TopToDown == 1; }
//! Setup scanlines order in memory - top-down or bottom-up.
//! Drawers should explicitly specify this value if current state IsTopDown() was ignored!
//! @param theIsTopDown top-down flag
- inline void SetTopDown (const bool theIsTopDown)
- {
- myData.SetTopDown (theIsTopDown);
- }
+ void SetTopDown (const bool theIsTopDown) { myData.SetTopDown (theIsTopDown); }
//! Returns +1 if scanlines ordered in Top->Down order in memory and -1 otherwise.
//! @return scanline increment for Top->Down iteration
- inline Standard_Size TopDownInc() const
+ Standard_Size TopDownInc() const { return myData.TopToDown; }
+
+ //! Return data pointer for low-level operations (copying entire buffer, parsing with extra tools etc.).
+ const Standard_Byte* Data() const { return myData.Data(); }
+
+ //! Return data pointer for low-level operations (copying entire buffer, parsing with extra tools etc.).
+ Standard_Byte* ChangeData() { return myData.ChangeData(); }
+
+ //! Return data pointer to requested row (first column).
+ //! Indexation starts from 0.
+ const Standard_Byte* Row (Standard_Size theRow) const { return myData.Row (theRow); }
+
+ //! Return data pointer to requested row (first column).
+ //! Indexation starts from 0.
+ Standard_Byte* ChangeRow (Standard_Size theRow) { return myData.ChangeRow (theRow); }
+
+ //! Return data pointer to requested 2D slice.
+ //! Indexation starts from 0.
+ const Standard_Byte* Slice (Standard_Size theSlice) const { return myData.Slice (theSlice); }
+
+ //! Return data pointer to requested 2D slice.
+ //! Indexation starts from 0.
+ Standard_Byte* ChangeSlice (Standard_Size theSlice) { return myData.ChangeSlice (theSlice); }
+
+ //! Return data pointer to requested row (first column).
+ //! Indexation starts from 0.
+ const Standard_Byte* SliceRow (Standard_Size theSlice,
+ Standard_Size theRow) const
{
- return myData.TopToDown;
+ return myData.SliceRow (theSlice, theRow);
}
- //! @return data pointer for low-level operations (copying entire buffer, parsing with extra tools etc.).
- inline const Standard_Byte* Data() const
+ //! Return data pointer to requested row (first column).
+ //! Indexation starts from 0.
+ Standard_Byte* ChangeSliceRow (Standard_Size theSlice,
+ Standard_Size theRow)
{
- return myData.Data();
+ return myData.ChangeSliceRow (theSlice, theRow);
}
- //! @return data pointer for low-level operations (copying entire buffer, parsing with extra tools etc.).
- inline Standard_Byte* ChangeData()
+ //! Return bytes reserved for one pixel (may include extra bytes for alignment).
+ Standard_Size SizePixelBytes() const { return myData.SizeBPP; }
+
+ //! Return bytes reserved per row.
+ //! Could be larger than needed to store packed row (extra bytes for alignment etc.).
+ Standard_Size SizeRowBytes() const { return myData.SizeRowBytes; }
+
+ //! Return the extra bytes in the row.
+ Standard_Size RowExtraBytes() const
{
- return myData.ChangeData();
+ return SizeRowBytes() - SizeX() * SizePixelBytes();
}
- //! @return data pointer to requested row (first column).
- inline const Standard_Byte* Row (const Standard_Size theRow) const
+ //! Compute the maximal row alignment for current row size.
+ //! @return maximal row alignment in bytes (up to 16 bytes).
+ Standard_Size MaxRowAligmentBytes() const { return myData.MaxRowAligmentBytes(); }
+
+ //! Return number of bytes per 2D slice.
+ Standard_Size SizeSliceBytes() const { return myData.SizeSliceBytes; }
+
+ //! Return buffer size
+ Standard_Size SizeBytes() const { return myData.Size(); }
+
+public:
+
+ //! Access image pixel with specified color type.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in the decreasing majority following memory layout - e.g. row first, column next.
+ template <typename ColorType_t>
+ const ColorType_t& Value (Standard_Size theRow,
+ Standard_Size theCol) const
{
- return myData.Row (theRow);
+ return *reinterpret_cast<const ColorType_t*>(myData.Value (theRow, theCol));
}
- //! @return data pointer to requested row (first column).
- inline Standard_Byte* ChangeRow (const Standard_Size theRow)
+ //! Access image pixel with specified color type.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in the decreasing majority following memory layout - e.g. row first, column next.
+ template <typename ColorType_t>
+ ColorType_t& ChangeValue (Standard_Size theRow,
+ Standard_Size theCol)
{
- return myData.ChangeRow (theRow);
+ return *reinterpret_cast<ColorType_t* >(myData.ChangeValue (theRow, theCol));
}
- //! @return bytes reserved for one pixel (may include extra bytes for alignment).
- inline Standard_Size SizePixelBytes() const
+ //! Access image pixel as raw data pointer.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in the decreasing majority following memory layout - e.g. row first, column next.
+ const Standard_Byte* RawValue (Standard_Size theRow,
+ Standard_Size theCol) const
{
- return myData.SizeBPP;
+ return myData.Value (theRow, theCol);
}
- //! @return bytes reserved for one pixel (may include extra bytes for alignment).
- Standard_EXPORT static Standard_Size SizePixelBytes (const Image_Format thePixelFormat);
+ //! Access image pixel as raw data pointer.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in the decreasing majority following memory layout - e.g. row first, column next.
+ Standard_Byte* ChangeRawValue (Standard_Size theRow,
+ Standard_Size theCol)
+ {
+ return myData.ChangeValue (theRow, theCol);
+ }
- //! @return bytes reserved per row.
- //! Could be larger than needed to store packed row (extra bytes for alignment etc.).
- inline Standard_Size SizeRowBytes() const
+ //! Access image pixel with specified color type.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in traditional X, Y order.
+ template <typename ColorType_t>
+ const ColorType_t& ValueXY (Standard_Size theX,
+ Standard_Size theY) const
{
- return myData.SizeRowBytes;
+ return *reinterpret_cast<const ColorType_t*>(myData.ValueXY (theX, theY));
}
- //! @return the extra bytes in the row.
- inline Standard_Size RowExtraBytes() const
+ //! Access image pixel with specified color type.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in traditional X, Y order.
+ template <typename ColorType_t>
+ ColorType_t& ChangeValueXY (Standard_Size theX,
+ Standard_Size theY)
{
- return SizeRowBytes() - SizeX() * SizePixelBytes();
+ return *reinterpret_cast<ColorType_t* >(myData.ChangeValueXY (theX, theY));
}
- //! Compute the maximal row alignment for current row size.
- //! @return maximal row alignment in bytes (up to 16 bytes).
- inline Standard_Size MaxRowAligmentBytes() const
+ //! Access image pixel as raw data pointer.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in traditional X, Y order.
+ const Standard_Byte* RawValueXY (Standard_Size theX,
+ Standard_Size theY) const
{
- return myData.MaxRowAligmentBytes();
+ return myData.ValueXY (theX, theY);
}
- //! @return buffer size
- inline Standard_Size SizeBytes() const
+ //! Access image pixel as raw data pointer.
+ //! Indexation starts from 0.
+ //! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in traditional X, Y order.
+ Standard_Byte* ChangeRawValueXY (Standard_Size theX,
+ Standard_Size theY)
{
- return myData.Size();
+ return myData.ChangeValueXY (theX, theY);
}
+public:
+
//! Access image pixel with specified color type.
+ //! Indexation starts from 0.
//! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in traditional X, Y, Z order.
template <typename ColorType_t>
- inline const ColorType_t& Value (const Standard_Size theRow,
- const Standard_Size theCol) const
+ const ColorType_t& ValueXYZ (Standard_Size theX,
+ Standard_Size theY,
+ Standard_Size theZ) const
{
- return *reinterpret_cast<const ColorType_t*>(myData.Value (theRow, theCol));
+ return *reinterpret_cast<const ColorType_t*>(myData.ValueXYZ (theX, theY, theZ));
}
//! Access image pixel with specified color type.
+ //! Indexation starts from 0.
//! This method does not perform any type checks - use on own risk (check Format() before)!
+ //! WARNING: Input parameters are defined in traditional X, Y, Z order.
template <typename ColorType_t>
- inline ColorType_t& ChangeValue (const Standard_Size theRow,
- const Standard_Size theCol)
+ ColorType_t& ChangeValueXYZ (Standard_Size theX,
+ Standard_Size theY,
+ Standard_Size theZ)
{
- return *reinterpret_cast<ColorType_t* >(myData.ChangeValue (theRow, theCol));
+ return *reinterpret_cast<ColorType_t* >(myData.ChangeValueXYZ (theX, theY, theZ));
}
//! Access image pixel as raw data pointer.
+ //! Indexation starts from 0.
//! This method does not perform any type checks - use on own risk (check Format() before)!
- const Standard_Byte* RawValue (Standard_Size theRow,
- Standard_Size theCol) const
+ //! WARNING: Input parameters are defined in traditional X, Y, Z order.
+ const Standard_Byte* RawValueXYZ (Standard_Size theX,
+ Standard_Size theY,
+ Standard_Size theZ) const
{
- return myData.Value (theRow, theCol);
+ return myData.ValueXYZ (theX, theY, theZ);
}
//! Access image pixel as raw data pointer.
+ //! Indexation starts from 0.
//! This method does not perform any type checks - use on own risk (check Format() before)!
- Standard_Byte* ChangeRawValue (Standard_Size theRow,
- Standard_Size theCol)
+ //! WARNING: Input parameters are defined in traditional X, Y, Z order.
+ Standard_Byte* ChangeRawValueXYZ (Standard_Size theX,
+ Standard_Size theY,
+ Standard_Size theZ)
{
- return myData.ChangeValue (theRow, theCol);
+ return myData.ChangeValueXYZ (theX, theY, theZ);
}
public:
#include <Image_Color.hxx>
#include <NCollection_Buffer.hxx>
+#include <NCollection_Vec3.hxx>
//! Structure to manage image buffer.
class Image_PixMapData : public NCollection_Buffer
SizeBPP (0),
SizeX (0),
SizeY (0),
+ SizeZ (0),
SizeRowBytes (0),
+ SizeSliceBytes (0),
TopToDown (Standard_Size(-1))
{
//
const Standard_Size theSizeY,
const Standard_Size theSizeRowBytes,
Standard_Byte* theDataPtr)
+ {
+ return Init (theAlloc, theSizeBPP, NCollection_Vec3<Standard_Size> (theSizeX, theSizeY, 1), theSizeRowBytes, theDataPtr);
+ }
+
+ //! Initializer.
+ bool Init (const Handle(NCollection_BaseAllocator)& theAlloc,
+ const Standard_Size theSizeBPP,
+ const NCollection_Vec3<Standard_Size>& theSizeXYZ,
+ const Standard_Size theSizeRowBytes,
+ Standard_Byte* theDataPtr)
{
SetAllocator (theAlloc); // will free old data as well
myData = theDataPtr;
myTopRowPtr = NULL;
SizeBPP = theSizeBPP;
- SizeX = theSizeX;
- SizeY = theSizeY;
- SizeRowBytes = theSizeRowBytes != 0 ? theSizeRowBytes : (theSizeX * theSizeBPP);
- mySize = SizeRowBytes * SizeY;
+ SizeX = theSizeXYZ.x();
+ SizeY = theSizeXYZ.y();
+ SizeZ = theSizeXYZ.z();
+ SizeRowBytes = theSizeRowBytes != 0 ? theSizeRowBytes : (SizeX * theSizeBPP);
+ SizeSliceBytes = SizeRowBytes * SizeY;
+ mySize = SizeSliceBytes * SizeZ;
if (myData == NULL)
{
Allocate (mySize);
}
}
- //! @return data pointer to requested row (first column).
- inline const Standard_Byte* Row (const Standard_Size theRow) const
+ //! Return data pointer to requested row (first column).
+ const Standard_Byte* Row (const Standard_Size theRow) const
{
return myTopRowPtr + ptrdiff_t(SizeRowBytes * theRow * TopToDown);
}
- //! @return data pointer to requested row (first column).
- inline Standard_Byte* ChangeRow (const Standard_Size theRow)
+ //! Return data pointer to requested row (first column).
+ Standard_Byte* ChangeRow (const Standard_Size theRow)
{
return myTopRowPtr + ptrdiff_t(SizeRowBytes * theRow * TopToDown);
}
- //! @return data pointer to requested position.
- inline const Standard_Byte* Value (const Standard_Size theRow,
- const Standard_Size theCol) const
+ //! Return data pointer to requested position.
+ const Standard_Byte* Value (const Standard_Size theRow,
+ const Standard_Size theCol) const
{
return myTopRowPtr + ptrdiff_t(SizeRowBytes * theRow * TopToDown) + SizeBPP * theCol;
}
- //! @return data pointer to requested position.
- inline Standard_Byte* ChangeValue (const Standard_Size theRow,
- const Standard_Size theCol)
+ //! Return data pointer to requested position.
+ Standard_Byte* ChangeValue (Standard_Size theRow,
+ Standard_Size theCol)
{
return myTopRowPtr + ptrdiff_t(SizeRowBytes * theRow * TopToDown) + SizeBPP * theCol;
}
+ //! Return data pointer to requested position.
+ const Standard_Byte* ValueXY (Standard_Size theX,
+ Standard_Size theY) const
+ {
+ return myTopRowPtr + ptrdiff_t(SizeRowBytes * theY * TopToDown) + SizeBPP * theX;
+ }
+
+ //! Return data pointer to requested position.
+ Standard_Byte* ChangeValueXY (Standard_Size theX,
+ Standard_Size theY)
+ {
+ return myTopRowPtr + ptrdiff_t(SizeRowBytes * theY * TopToDown) + SizeBPP * theX;
+ }
+
+public:
+
+ //! Return data pointer to requested 2D slice.
+ const Standard_Byte* Slice (Standard_Size theSlice) const
+ {
+ return myData + ptrdiff_t(SizeSliceBytes * theSlice);
+ }
+
+ //! Return data pointer to requested 2D slice.
+ Standard_Byte* ChangeSlice (Standard_Size theSlice)
+ {
+ return myData + ptrdiff_t(SizeSliceBytes * theSlice);
+ }
+
+ //! Return data pointer to requested row (first column).
+ const Standard_Byte* SliceRow (Standard_Size theSlice,
+ Standard_Size theRow) const
+ {
+ return myTopRowPtr + ptrdiff_t(SizeRowBytes * theRow * TopToDown) + ptrdiff_t(SizeSliceBytes * theSlice);
+ }
+
+ //! Return data pointer to requested row (first column).
+ Standard_Byte* ChangeSliceRow (Standard_Size theSlice,
+ Standard_Size theRow)
+ {
+ return myTopRowPtr + ptrdiff_t(SizeRowBytes * theRow * TopToDown) + ptrdiff_t(SizeSliceBytes * theSlice);
+ }
+
+ //! Return data pointer to requested position.
+ const Standard_Byte* ValueXYZ (Standard_Size theX,
+ Standard_Size theY,
+ Standard_Size theZ) const
+ {
+ return myTopRowPtr + ptrdiff_t(SizeRowBytes * theY * TopToDown) + SizeBPP * theX + ptrdiff_t(SizeSliceBytes * theZ);
+ }
+
+ //! Return data pointer to requested position.
+ Standard_Byte* ChangeValueXYZ (Standard_Size theX,
+ Standard_Size theY,
+ Standard_Size theZ)
+ {
+ return myTopRowPtr + ptrdiff_t(SizeRowBytes * theY * TopToDown) + SizeBPP * theX + ptrdiff_t(SizeSliceBytes * theZ);
+ }
+
//! Compute the maximal row alignment for current row size.
//! @return maximal row alignment in bytes (up to 16 bytes).
- inline Standard_Size MaxRowAligmentBytes() const
+ Standard_Size MaxRowAligmentBytes() const
{
Standard_Size anAlignment = 2;
for (; anAlignment <= 16; anAlignment <<= 1)
//! Setup scanlines order in memory - top-down or bottom-up.
//! Drawers should explicitly specify this value if current state IsTopDown() was ignored!
//! @param theIsTopDown top-down flag
- inline void SetTopDown (const bool theIsTopDown)
+ void SetTopDown (const bool theIsTopDown)
{
TopToDown = (theIsTopDown ? 1 : Standard_Size(-1));
myTopRowPtr = ((TopToDown == 1 || myData == NULL)
public:
- Standard_Size SizeBPP; //!< bytes per pixel
- Standard_Size SizeX; //!< width in pixels
- Standard_Size SizeY; //!< height in pixels
- Standard_Size SizeRowBytes; //!< number of bytes per line (in most cases equal to 3 * sizeX)
- Standard_Size TopToDown; //!< image scanlines direction in memory from Top to the Down
-
+ Standard_Size SizeBPP; //!< bytes per pixel
+ Standard_Size SizeX; //!< width in pixels
+ Standard_Size SizeY; //!< height in pixels
+ Standard_Size SizeZ; //!< depth in pixels
+ Standard_Size SizeRowBytes; //!< number of bytes per line (in most cases equal to 3 * sizeX)
+ Standard_Size SizeSliceBytes; //!< number of bytes per 2D slice
+ Standard_Size TopToDown; //!< image scanlines direction in memory from Top to the Down
public:
- DEFINE_STANDARD_RTTI_INLINE(Image_PixMapData,NCollection_Buffer) // Type definition
+ DEFINE_STANDARD_RTTIEXT(Image_PixMapData, NCollection_Buffer)
};
{
public:
- MeshVS_ImageTexture2D (const Handle(Image_PixMap)& theImg) : Graphic3d_Texture2D (theImg, Graphic3d_TOT_2D)
+ MeshVS_ImageTexture2D (const Handle(Image_PixMap)& theImg)
+ : Graphic3d_Texture2D (theImg, Graphic3d_TypeOfTexture_2D)
{
- myParams->SetModulate (Standard_True);
+ myParams->SetModulate (true);
myParams->SetFilter (Graphic3d_TOTF_BILINEAR);
}
DEFINE_STANDARD_RTTI_INLINE(MeshVS_ImageTexture2D,Graphic3d_Texture2D)
};
-DEFINE_STANDARD_HANDLE (MeshVS_ImageTexture2D, Graphic3d_Texture2D)
-
-
//================================================================
// Function : getNearestPow2
// Purpose : Returns the nearest power of two greater than the
if (!hadAlreadyRGBA)
{
- aSprite->Init (theCtx, *anImage, Graphic3d_TOT_2D, true);
+ aSprite->Init (theCtx, *anImage, Graphic3d_TypeOfTexture_2D, true);
}
if (!hadAlreadyAlpha)
{
if (Handle(Image_PixMap) anImageA = aSprite->GetFormat() != GL_ALPHA ? aNewMarkerImage->GetImageAlpha() : Handle(Image_PixMap)())
{
- aSpriteA->Init (theCtx, *anImageA, Graphic3d_TOT_2D, true);
+ aSpriteA->Init (theCtx, *anImageA, Graphic3d_TypeOfTexture_2D, true);
}
}
}
myTextureRgbaWhite = new OpenGl_Texture();
Image_PixMap anImage;
anImage.InitZero (Image_Format_RGBA, 2, 2, 0, (Standard_Byte )0);
- if (!myTextureRgbaBlack->Init (this, OpenGl_TextureFormat::Create<GLubyte, 4>(), Graphic3d_Vec2i (2, 2), Graphic3d_TOT_2D, &anImage))
+ if (!myTextureRgbaBlack->Init (this, OpenGl_TextureFormat::Create<GLubyte, 4>(), Graphic3d_Vec2i (2, 2), Graphic3d_TypeOfTexture_2D, &anImage))
{
PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
"Error: unable to create unit mock PBR texture map.");
}
anImage.InitZero (Image_Format_RGBA, 2, 2, 0, (Standard_Byte )255);
- if (!myTextureRgbaWhite->Init (this, OpenGl_TextureFormat::Create<GLubyte, 4>(), Graphic3d_Vec2i (2, 2), Graphic3d_TOT_2D, &anImage))
+ if (!myTextureRgbaWhite->Init (this, OpenGl_TextureFormat::Create<GLubyte, 4>(), Graphic3d_Vec2i (2, 2), Graphic3d_TypeOfTexture_2D, &anImage))
{
PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
"Error: unable to create normal mock PBR texture map.");
Image_PixMap aBlackImg;
if (!aBlackImg.InitZero (Image_Format_Alpha, Standard_Size(aTextureSizeX), Standard_Size(aTextureSizeY))
- || !aTexture->Init (theCtx, aBlackImg, Graphic3d_TOT_2D, true)) // myTextureFormat
+ || !aTexture->Init (theCtx, aBlackImg, Graphic3d_TypeOfTexture_2D, true)) // myTextureFormat
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
TCollection_AsciiString ("New texture initialization of size ")
const GLint aColorFormat = myColorFormats (aColorBufferIdx);
const OpenGl_TextureFormat aFormat = OpenGl_TextureFormat::FindSizedFormat (theGlContext, aColorFormat);
if (!aFormat.IsValid()
- || !aColorTexture->Init (theGlContext, aFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TOT_2D))
+ || !aColorTexture->Init (theGlContext, aFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TypeOfTexture_2D))
{
Release (theGlContext.get());
return Standard_False;
const GLint aColorFormat = myColorFormats (aColorBufferIdx);
const OpenGl_TextureFormat aFormat = OpenGl_TextureFormat::FindSizedFormat (theGlContext, aColorFormat);
if (!aFormat.IsValid()
- || !aColorTexture->Init (theGlContext, aFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TOT_2D))
+ || !aColorTexture->Init (theGlContext, aFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TypeOfTexture_2D))
{
Release (theGlContext.operator->());
return Standard_False;
// instead of just trying to create such texture
const OpenGl_TextureFormat aDepthFormat = OpenGl_TextureFormat::FindSizedFormat (theGlContext, myDepthFormat);
if (aDepthFormat.IsValid()
- && !myDepthStencilTexture->Init (theGlContext, aDepthFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TOT_2D))
+ && !myDepthStencilTexture->Init (theGlContext, aDepthFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TypeOfTexture_2D))
{
theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
"Warning! Depth textures are not supported by hardware!");
// NVIDIA's driver didn't work properly with 3 channel texture for diffuse SH coefficients so that alpha channel has been added
if (!myIBLMaps[OpenGl_TypeOfIBLMap_DiffuseSH].Init (theCtx,
OpenGl_TextureFormat::FindFormat (theCtx, Image_Format_RGBAF, false),
- Graphic3d_Vec2i (9, 1), Graphic3d_TOT_2D))
+ Graphic3d_Vec2i (9, 1), Graphic3d_TypeOfTexture_2D))
{
Message::SendFail() << "OpenGl_PBREnvironment, DiffuseSH texture creation failed";
return false;
if (!myIBLMaps[OpenGl_TypeOfIBLMap_DiffuseFallback].Init (theCtx,
OpenGl_TextureFormat::FindFormat (theCtx, Image_Format_RGBA, false),
- Graphic3d_Vec2i (10, 4), Graphic3d_TOT_2D))
+ Graphic3d_Vec2i (10, 4), Graphic3d_TypeOfTexture_2D))
{
Message::SendFail() << "OpenGl_PBREnvironment, DiffuseFallback texture creation failed";
return false;
{
if (!myIBLMaps[OpenGl_TypeOfIBLMap_DiffuseSH].Init (theCtx,
OpenGl_TextureFormat::FindFormat (theCtx, Image_Format_RGBAF, false),
- Graphic3d_Vec2i (9, 1), Graphic3d_TOT_2D, &anImageF))
+ Graphic3d_Vec2i (9, 1), Graphic3d_TypeOfTexture_2D, &anImageF))
{
Message::SendFail() << "OpenGl_PBREnvironment, DiffuseSH texture update failed";
return false;
theCtx->core11fwd->glEnable (GL_TEXTURE_2D);
break;
}
- default: break;
+ case GL_TEXTURE_3D:
+ default:
+ {
+ break;
+ }
}
}
theCtx->core11fwd->glDisable (GL_TEXTURE_2D);
break;
}
- default: break;
+ case GL_TEXTURE_3D:
+ default:
+ {
+ break;
+ }
}
}
}
}
-//! Compute the upper mipmap level for complete mipmap set (e.g. till the 1x1 level).
-static Standard_Integer computeUpperMipMapLevel (Standard_Integer theSizeX, Standard_Integer theSizeY)
-{
- return computeUpperMipMapLevel (Max (theSizeX, theSizeY));
-}
-
//! Compute size of the smallest defined mipmap level (for verbose messages).
static Graphic3d_Vec2i computeSmallestMipMapSize (const Graphic3d_Vec2i& theBaseSize, Standard_Integer theMaxLevel)
{
myRevision (0),
myTextureId (NO_TEXTURE),
myTarget (GL_TEXTURE_2D),
- mySizeX (0),
- mySizeY (0),
- mySizeZ (0),
myTextFormat (GL_RGBA),
mySizedFormat(GL_RGBA8),
myNbSamples (1),
theGlCtx->core11fwd->glDeleteTextures (1, &myTextureId);
}
myTextureId = NO_TEXTURE;
- mySizeX = mySizeY = mySizeZ = 0;
+ mySize.SetValues (0, 0, 0);
}
// =======================================================================
// =======================================================================
bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
const OpenGl_TextureFormat& theFormat,
- const Graphic3d_Vec2i& theSizeXY,
+ const Graphic3d_Vec3i& theSizeXYZ,
const Graphic3d_TypeOfTexture theType,
const Image_PixMap* theImage)
{
- if (theSizeXY.x() < 1
- || theSizeXY.y() < 1)
+ if (theSizeXYZ.x() < 1
+ || theSizeXYZ.y() < 1
+ || theSizeXYZ.z() < 1)
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
TCollection_AsciiString ("Error: texture of 0 size cannot be created [") + myResourceId +"]");
return false;
}
- const GLenum aTarget = (theType == Graphic3d_TOT_1D
- && theCtx->GraphicsLibrary() != Aspect_GraphicsLibrary_OpenGLES)
- ? GL_TEXTURE_1D
- : GL_TEXTURE_2D;
+ GLenum aTarget = GL_TEXTURE_2D;
+ switch (theType)
+ {
+ case Graphic3d_TypeOfTexture_1D:
+ {
+ aTarget = theCtx->GraphicsLibrary() != Aspect_GraphicsLibrary_OpenGLES
+ ? GL_TEXTURE_1D
+ : GL_TEXTURE_2D;
+ break;
+ }
+ case Graphic3d_TypeOfTexture_2D:
+ case Graphic3d_TOT_2D_MIPMAP:
+ {
+ aTarget = GL_TEXTURE_2D;
+ break;
+ }
+ case Graphic3d_TypeOfTexture_3D:
+ {
+ aTarget = GL_TEXTURE_3D;
+ break;
+ }
+ case Graphic3d_TypeOfTexture_CUBEMAP:
+ {
+ aTarget = GL_TEXTURE_CUBE_MAP;
+ break;
+ }
+ }
const bool toPatchExisting = IsValid()
&& myTextFormat == theFormat.PixelFormat()
&& myTarget == aTarget
- && HasMipmaps() == (theType == Graphic3d_TOT_2D_MIPMAP)
- && mySizeX == theSizeXY.x()
- && (mySizeY == theSizeXY.y() || theType == Graphic3d_TOT_1D);
+ && mySize.x() == theSizeXYZ.x()
+ && (mySize.y() == theSizeXYZ.y() || theType == Graphic3d_TypeOfTexture_1D)
+ && mySize.z() == theSizeXYZ.z();
if (!Create (theCtx))
{
Release (theCtx.get());
myIsAlpha = theFormat.PixelFormat() == GL_ALPHA;
}
- myMaxMipLevel = theType == Graphic3d_TOT_2D_MIPMAP && theCtx->arbFBO != NULL
- ? computeUpperMipMapLevel (theSizeXY.x(), theSizeXY.y())
- : 0;
+ myMaxMipLevel = 0;
myTextFormat = theFormat.PixelFormat();
mySizedFormat = theFormat.InternalFormat();
myNbSamples = 1;
return false;
}
- const GLsizei aMaxSize = theCtx->MaxTextureSize();
- if (theSizeXY.x() > aMaxSize
- || theSizeXY.y() > aMaxSize)
+ const Standard_Integer aMaxSize = theCtx->MaxTextureSize();
+ if (theSizeXYZ.maxComp() > aMaxSize)
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Error: Texture dimension - ") + theSizeXY.x() + "x" + theSizeXY.y()
+ TCollection_AsciiString ("Error: Texture dimension - ") + theSizeXYZ.x() + "x" + theSizeXYZ.y()
+ + (theSizeXYZ.z() > 1 ? TCollection_AsciiString ("x") + theSizeXYZ.z() : TCollection_AsciiString())
+ " exceeds hardware limits (" + aMaxSize + "x" + aMaxSize + ")"
+ " [" + myResourceId +"]");
Release (theCtx.get());
// however some hardware (NV30 - GeForce FX, RadeOn 9xxx and Xxxx) supports GLSL but not NPOT!
// Trying to create NPOT textures on such hardware will not fail
// but driver will fall back into software rendering,
- const GLsizei aWidthP2 = OpenGl_Context::GetPowerOfTwo (theSizeXY.x(), aMaxSize);
- const GLsizei aHeightP2 = OpenGl_Context::GetPowerOfTwo (theSizeXY.y(), aMaxSize);
- if (theSizeXY.x() != aWidthP2
- || (theType != Graphic3d_TOT_1D && theSizeXY.y() != aHeightP2))
+ const Graphic3d_Vec2i aSizeP2 (OpenGl_Context::GetPowerOfTwo (theSizeXYZ.x(), aMaxSize),
+ OpenGl_Context::GetPowerOfTwo (theSizeXYZ.y(), aMaxSize));
+ if (theSizeXYZ.x() != aSizeP2.x()
+ || (theType != Graphic3d_TypeOfTexture_1D && theSizeXYZ.y() != aSizeP2.y()))
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Error: NPOT Textures (") + theSizeXY.x() + "x" + theSizeXY.y() + ")"
+ TCollection_AsciiString ("Error: NPOT Textures (") + theSizeXYZ.x() + "x" + theSizeXYZ.y() + ")"
" are not supported by hardware [" + myResourceId +"]");
Release (theCtx.get());
return false;
}
}
- else if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGLES
- && !theCtx->IsGlGreaterEqual (3, 0)
- && theType == Graphic3d_TOT_2D_MIPMAP)
- {
- // Mipmap NPOT textures are not supported by OpenGL ES 2.0.
- const GLsizei aWidthP2 = OpenGl_Context::GetPowerOfTwo (theSizeXY.x(), aMaxSize);
- const GLsizei aHeightP2 = OpenGl_Context::GetPowerOfTwo (theSizeXY.y(), aMaxSize);
- if (theSizeXY.x() != aWidthP2
- || theSizeXY.y() != aHeightP2)
- {
- theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Warning: Mipmap NPOT Textures (") + theSizeXY.x() + "x" + theSizeXY.y() + ")"
- " are not supported by OpenGL ES 2.0 [" + myResourceId +"]");
- myMaxMipLevel = 0;
- }
- }
GLint aTestWidth = 0, aTestHeight = 0;
GLvoid* aDataPtr = (theImage != NULL) ? (GLvoid* )theImage->Data() : NULL;
myTarget = aTarget;
switch (theType)
{
- case Graphic3d_TOT_1D:
+ case Graphic3d_TypeOfTexture_1D:
{
if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGLES)
{
if (toPatchExisting)
{
theCtx->core11fwd->glTexSubImage1D (GL_TEXTURE_1D, 0, 0,
- theSizeXY.x(), theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
- Unbind (theCtx);
- return true;
+ theSizeXYZ.x(), theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
+ break;
}
// use proxy to check texture could be created or not
theCtx->core11fwd->glTexImage1D (GL_PROXY_TEXTURE_1D, 0, anIntFormat,
- theSizeXY.x(), 0,
+ theSizeXYZ.x(), 0,
theFormat.PixelFormat(), theFormat.DataType(), NULL);
theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_1D, 0, GL_TEXTURE_WIDTH, &aTestWidth);
theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_1D, 0, GL_TEXTURE_INTERNAL_FORMAT, &mySizedFormat);
}
theCtx->core11fwd->glTexImage1D (GL_TEXTURE_1D, 0, anIntFormat,
- theSizeXY.x(), 0,
+ theSizeXYZ.x(), 0,
theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
if (theCtx->core11fwd->glGetError() != GL_NO_ERROR)
{
return false;
}
- mySizeX = theSizeXY.x();
- mySizeY = 1;
-
- Unbind (theCtx);
- return true;
+ mySize.SetValues (theSizeXYZ.x(), 1, 1);
+ break;
}
- case Graphic3d_TOT_2D:
+ case Graphic3d_TypeOfTexture_2D:
case Graphic3d_TOT_2D_MIPMAP:
{
Bind (theCtx);
{
theCtx->core11fwd->glTexSubImage2D (GL_TEXTURE_2D, 0,
0, 0,
- theSizeXY.x(), theSizeXY.y(),
+ theSizeXYZ.x(), theSizeXYZ.y(),
theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
-
- if (myMaxMipLevel > 0)
- {
- // generate mipmaps
- theCtx->arbFBO->glGenerateMipmap (GL_TEXTURE_2D);
- if (theCtx->core11fwd->glGetError() != GL_NO_ERROR)
- {
- myMaxMipLevel = 0;
- }
- }
-
- Unbind (theCtx);
- return true;
+ break;
}
if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGL)
{
// use proxy to check texture could be created or not
theCtx->core11fwd->glTexImage2D (GL_PROXY_TEXTURE_2D, 0, anIntFormat,
- theSizeXY.x(), theSizeXY.y(), 0,
+ theSizeXYZ.x(), theSizeXYZ.y(), 0,
theFormat.PixelFormat(), theFormat.DataType(), NULL);
theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &aTestWidth);
theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &aTestHeight);
}
theCtx->core11fwd->glTexImage2D (GL_TEXTURE_2D, 0, anIntFormat,
- theSizeXY.x(), theSizeXY.y(), 0,
+ theSizeXYZ.x(), theSizeXYZ.y(), 0,
theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
GLenum anErr = theCtx->core11fwd->glGetError();
if (anErr != GL_NO_ERROR)
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Error: 2D texture ") + theSizeXY.x() + "x" + theSizeXY.y()
+ TCollection_AsciiString ("Error: 2D texture ") + theSizeXYZ.x() + "x" + theSizeXYZ.y()
+ " IF: " + OpenGl_TextureFormat::FormatFormat (anIntFormat)
+ " PF: " + OpenGl_TextureFormat::FormatFormat (theFormat.PixelFormat())
+ " DT: " + OpenGl_TextureFormat::FormatDataType (theFormat.DataType())
return false;
}
- mySizeX = theSizeXY.x();
- mySizeY = theSizeXY.y();
+ mySize.SetValues (theSizeXYZ.xy(), 1);
+ break;
+ }
+ case Graphic3d_TypeOfTexture_3D:
+ {
+ if (theCtx->Functions()->glTexImage3D == nullptr)
+ {
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
+ "Error: three-dimensional textures are not supported by hardware.");
+ Unbind (theCtx);
+ Release (theCtx.get());
+ return false;
+ }
- if (myMaxMipLevel > 0)
+ Bind (theCtx);
+ applyDefaultSamplerParams (theCtx);
+ if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGL)
{
- // generate mipmaps
- //glHint (GL_GENERATE_MIPMAP_HINT, GL_NICEST);
- theCtx->arbFBO->glGenerateMipmap (GL_TEXTURE_2D);
- anErr = theCtx->core11fwd->glGetError();
- if (anErr != GL_NO_ERROR)
+ theCtx->Functions()->glTexImage3D (GL_PROXY_TEXTURE_3D, 0, anIntFormat,
+ theSizeXYZ.x(), theSizeXYZ.y(), theSizeXYZ.z(), 0,
+ theFormat.PixelFormat(), theFormat.DataType(), nullptr);
+
+ NCollection_Vec3<GLint> aTestSizeXYZ;
+ theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &aTestSizeXYZ.x());
+ theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_HEIGHT, &aTestSizeXYZ.y());
+ theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_DEPTH, &aTestSizeXYZ.z());
+ theCtx->core11fwd->glGetTexLevelParameteriv (GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_INTERNAL_FORMAT, &mySizedFormat);
+ if (aTestSizeXYZ.x() == 0 || aTestSizeXYZ.y() == 0 || aTestSizeXYZ.z() == 0)
{
- myMaxMipLevel = 0;
- if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGLES
- && (theFormat.InternalFormat() == GL_RGB8
- || theFormat.InternalFormat() == GL_SRGB8))
- {
- theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Warning: generating mipmaps requires color-renderable format, while giving ")
- + OpenGl_TextureFormat::FormatFormat (anIntFormat) + " [" + myResourceId +"]");
- }
- else
- {
- theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Warning: generating mipmaps has failed [") + myResourceId +"]");
- }
+ Unbind (theCtx);
+ Release (theCtx.get());
+ return false;
}
}
- Unbind (theCtx);
- return true;
+ theCtx->Functions()->glTexImage3D (GL_TEXTURE_3D, 0, anIntFormat,
+ theSizeXYZ.x(), theSizeXYZ.y(), theSizeXYZ.z(), 0,
+ theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
+ GLenum anErr = theCtx->core11fwd->glGetError();
+ if (anErr != GL_NO_ERROR)
+ {
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
+ TCollection_AsciiString ("Error: 3D texture ") + theSizeXYZ.x() + "x" + theSizeXYZ.y() + "x" + theSizeXYZ.z()
+ + " IF: " + OpenGl_TextureFormat::FormatFormat (anIntFormat)
+ + " PF: " + OpenGl_TextureFormat::FormatFormat (theFormat.PixelFormat())
+ + " DT: " + OpenGl_TextureFormat::FormatDataType (theFormat.DataType())
+ + " can not be created with error " + OpenGl_Context::FormatGlError (anErr)
+ + " [" + myResourceId +"]");
+ Unbind (theCtx);
+ Release (theCtx.get());
+ return false;
+ }
+
+ mySize = theSizeXYZ;
+ break;
}
- case Graphic3d_TOT_CUBEMAP:
+ case Graphic3d_TypeOfTexture_CUBEMAP:
{
Unbind (theCtx);
Release (theCtx.get());
}
}
- Release (theCtx.get());
- return false;
+ Unbind (theCtx);
+ return true;
+}
+
+// =======================================================================
+// function : GenerateMipmaps
+// purpose :
+// =======================================================================
+bool OpenGl_Texture::GenerateMipmaps (const Handle(OpenGl_Context)& theCtx)
+{
+ if (theCtx->arbFBO == nullptr
+ || !IsValid())
+ {
+ return false;
+ }
+
+ myMaxMipLevel = computeUpperMipMapLevel (mySize.maxComp());
+
+ const Standard_Integer aMaxSize = theCtx->MaxTextureSize();
+ if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGLES
+ && !theCtx->IsGlGreaterEqual (3, 0))
+ {
+ // Mipmap NPOT textures are not supported by OpenGL ES 2.0.
+ const Graphic3d_Vec2i aSizeP2 (OpenGl_Context::GetPowerOfTwo (mySize.x(), aMaxSize),
+ OpenGl_Context::GetPowerOfTwo (mySize.y(), aMaxSize));
+ if (mySize.xy() != aSizeP2)
+ {
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
+ TCollection_AsciiString ("Warning: Mipmap NPOT Textures (") + mySize.x() + "x" + mySize.y() + ")"
+ " are not supported by OpenGL ES 2.0 [" + myResourceId +"]");
+ myMaxMipLevel = 0;
+ }
+ }
+
+ if (myMaxMipLevel <= 0)
+ {
+ return false;
+ }
+
+ //glHint (GL_GENERATE_MIPMAP_HINT, GL_NICEST);
+ Bind (theCtx);
+ if (theCtx->HasTextureBaseLevel()
+ && !mySampler->isValidSampler())
+ {
+ const Standard_Integer aMaxLevel = Min (myMaxMipLevel, mySampler->Parameters()->MaxLevel());
+ mySampler->SetParameter (theCtx, myTarget, GL_TEXTURE_MAX_LEVEL, aMaxLevel);
+ }
+ theCtx->arbFBO->glGenerateMipmap (myTarget);
+ GLenum anErr = theCtx->core11fwd->glGetError();
+ if (anErr != GL_NO_ERROR)
+ {
+ myMaxMipLevel = 0;
+ if (theCtx->HasTextureBaseLevel()
+ && !mySampler->isValidSampler())
+ {
+ mySampler->SetParameter (theCtx, myTarget, GL_TEXTURE_MAX_LEVEL, 0);
+ }
+
+ if (theCtx->GraphicsLibrary() == Aspect_GraphicsLibrary_OpenGLES
+ && (mySizedFormat == GL_RGB8
+ || mySizedFormat == GL_SRGB8))
+ {
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
+ TCollection_AsciiString ("Warning: generating mipmaps requires color-renderable format, while giving ")
+ + OpenGl_TextureFormat::FormatFormat (mySizedFormat) + " [" + myResourceId +"]");
+ }
+ else
+ {
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
+ TCollection_AsciiString ("Warning: generating mipmaps has failed [") + myResourceId +"]");
+ }
+ }
+
+ applyDefaultSamplerParams (theCtx);
+ Unbind (theCtx);
+ return true;
}
// =======================================================================
return false;
}
- return Init (theCtx, aFormat, Graphic3d_Vec2i ((Standard_Integer)theImage.SizeX(), (Standard_Integer)theImage.SizeY()),
- theType, &theImage);
+ return Init (theCtx, aFormat, Graphic3d_Vec3i (theImage.SizeXYZ()), theType, &theImage);
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
-bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
- const Handle(Graphic3d_TextureMap)& theTextureMap)
+bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
+ const Handle(Graphic3d_TextureRoot)& theTextureMap)
{
if (theTextureMap.IsNull())
{
switch (theTextureMap->Type())
{
- case Graphic3d_TOT_CUBEMAP:
+ case Graphic3d_TypeOfTexture_CUBEMAP:
{
return InitCubeMap (theCtx, Handle(Graphic3d_CubeMap)::DownCast(theTextureMap),
0, Image_Format_RGB, false, theTextureMap->IsColorMap());
{
return false;
}
- return Init (theCtx, *anImage, theTextureMap->Type(), theTextureMap->IsColorMap());
+ if (!Init (theCtx, *anImage, theTextureMap->Type(), theTextureMap->IsColorMap()))
+ {
+ return false;
+ }
+ if (theTextureMap->HasMipmaps())
+ {
+ GenerateMipmaps (theCtx);
+ }
+ return true;
}
}
}
myTextFormat = aFormat.Format();
mySizedFormat = aFormat.Internal();
myIsTopDown = theImage.IsTopDown();
- mySizeX = theImage.SizeX();
- mySizeY = theImage.SizeY();
+ mySize.SetValues (theImage.SizeX(), theImage.SizeY(), 1);
myMaxMipLevel = Max (theImage.MipMaps().Size() - 1, 0);
if (myMaxMipLevel > 0
&& !theImage.IsCompleteMipMapSet())
{
- const Graphic3d_Vec2i aMipSize = computeSmallestMipMapSize (Graphic3d_Vec2i (mySizeX, mySizeY), myMaxMipLevel);
+ const Graphic3d_Vec2i aMipSize = computeSmallestMipMapSize (mySize.xy(), myMaxMipLevel);
if (!theCtx->HasTextureBaseLevel())
{
myMaxMipLevel = 0;
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 0, GL_DEBUG_SEVERITY_MEDIUM,
- TCollection_AsciiString ("Warning: compressed 2D texture ") + myResourceId + " " + mySizeX + "x" + mySizeY
+ TCollection_AsciiString ("Warning: compressed 2D texture ") + myResourceId + " " + mySize.x() + "x" + mySize.y()
+ " has smallest mipmap " + aMipSize.x() + "x" + aMipSize.y() + "; mipmaps will be ignored");
}
else
{
- Message::SendTrace (TCollection_AsciiString ("Warning: compressed 2D texture ") + myResourceId + " " + mySizeX + "x" + mySizeY
+ Message::SendTrace (TCollection_AsciiString ("Warning: compressed 2D texture ") + myResourceId + " " + mySize.x() + "x" + mySize.y()
+ " has smallest mipmap " + aMipSize.x() + "x" + aMipSize.y());
}
}
return false;
}
- mySizeX = theSizeX;
- mySizeY = theSizeY;
+ mySize.SetValues (theSizeX, theSizeY, 1);
Unbind (theCtx);
return true;
return false;
}
- mySizeX = aSizeX;
- mySizeY = aSizeY;
+ mySize.SetValues (aSizeX, aSizeY, 1);
Unbind (theCtx);
return true;
}
return false;
}
- mySizeX = aSizeXYZ.x();
- mySizeY = aSizeXYZ.y();
- mySizeZ = aSizeXYZ.z();
+ mySize = aSizeXYZ;
Unbind (theCtx);
return true;
Handle(Image_PixMap) anImage;
Handle(Image_CompressedPixMap) aCompImage;
OpenGl_TextureFormat aFormat;
+ myMaxMipLevel = 0;
if (!theCubeMap.IsNull())
{
theCubeMap->Reset();
theSize = anImage->SizeX();
theFormat = anImage->Format();
theToGenMipmap = theCubeMap->HasMipmaps();
- myMaxMipLevel = theToGenMipmap ? computeUpperMipMapLevel ((Standard_Integer )theSize) : 0;
}
myIsTopDown = theCubeMap->IsTopDown();
}
- else
- {
- myMaxMipLevel = theToGenMipmap ? computeUpperMipMapLevel ((Standard_Integer )theSize) : 0;
- }
if (!aFormat.IsValid())
{
myTarget = GL_TEXTURE_CUBE_MAP;
myNbSamples = 1;
- mySizeX = (GLsizei )theSize;
- mySizeY = (GLsizei )theSize;
+ mySize.SetValues ((GLsizei )theSize, (GLsizei )theSize, 1);
myTextFormat = aFormat.Format();
mySizedFormat = aFormat.Internal();
}
if (!aCompImage.IsNull())
{
- Graphic3d_Vec2i aMipSizeXY (mySizeX, mySizeY);
+ Graphic3d_Vec2i aMipSizeXY = mySize.xy();
aData = aCompImage->FaceData()->Data();
for (Standard_Integer aMipIter = 0; aMipIter <= myMaxMipLevel; ++aMipIter)
{
if (theToGenMipmap && theCtx->arbFBO != NULL)
{
- theCtx->arbFBO->glGenerateMipmap (myTarget);
- const GLenum anErr = theCtx->core11fwd->glGetError();
- if (anErr != GL_NO_ERROR)
- {
- theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
- TCollection_AsciiString ("Unable to generate mipmap of cubemap with format ")
- + OpenGl_TextureFormat::FormatFormat (anIntFormat)
- + ", error " + OpenGl_Context::FormatGlError (anErr));
- myMaxMipLevel = 0;
- }
+ GenerateMipmaps (theCtx);
}
Unbind (theCtx.get());
return 0;
}
- Standard_Size aSize = PixelSizeOfPixelFormat (mySizedFormat) * mySizeX * myNbSamples;
- if (mySizeY != 0)
+ Standard_Size aSize = PixelSizeOfPixelFormat (mySizedFormat) * mySize.x() * myNbSamples;
+ if (mySize.y() != 0)
{
- aSize *= Standard_Size(mySizeY);
+ aSize *= Standard_Size(mySize.y());
}
- if (mySizeZ != 0)
+ if (mySize.z() != 0)
{
- aSize *= Standard_Size(mySizeZ);
+ aSize *= Standard_Size(mySize.z());
}
if (myTarget == GL_TEXTURE_CUBE_MAP)
{
}
GLenum aTarget = myTarget;
- Graphic3d_Vec2i aSize (mySizeX, mySizeY);
+ Graphic3d_Vec2i aSize = mySize.xy();
if (myTarget == GL_TEXTURE_CUBE_MAP)
{
aTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + theCubeSide;
//! @return target to which the texture is bound (GL_TEXTURE_1D, GL_TEXTURE_2D)
unsigned int GetTarget() const { return myTarget; }
- //! @return texture width (0 LOD)
- GLsizei SizeX() const { return mySizeX; }
+ //! Return texture dimensions (0 LOD)
+ const Graphic3d_Vec3i& Size() const { return mySize; }
- //! @return texture height (0 LOD)
- GLsizei SizeY() const { return mySizeY; }
+ //! Return texture width (0 LOD)
+ Standard_Integer SizeX() const { return mySize.x(); }
+
+ //! Return texture height (0 LOD)
+ Standard_Integer SizeY() const { return mySize.y(); }
+
+ //! Return texture depth (0 LOD)
+ Standard_Integer SizeZ() const { return mySize.z(); }
//! @return texture ID
unsigned int TextureId() const { return myTextureId; }
//! Notice that texture will be unbound after this call.
Standard_EXPORT bool Init (const Handle(OpenGl_Context)& theCtx,
const OpenGl_TextureFormat& theFormat,
- const Graphic3d_Vec2i& theSizeXY,
+ const Graphic3d_Vec3i& theSizeXYZ,
const Graphic3d_TypeOfTexture theType,
const Image_PixMap* theImage = NULL);
+ //! Initialize the 2D texture with specified format, size and texture type.
+ //! If theImage is empty the texture data will contain trash.
+ //! Notice that texture will be unbound after this call.
+ bool Init (const Handle(OpenGl_Context)& theCtx,
+ const OpenGl_TextureFormat& theFormat,
+ const Graphic3d_Vec2i& theSizeXY,
+ const Graphic3d_TypeOfTexture theType,
+ const Image_PixMap* theImage = NULL)
+ {
+ return Init (theCtx, theFormat, Graphic3d_Vec3i (theSizeXY, 1), theType, theImage);
+ }
+
//! Initialize the texture with Graphic3d_TextureMap.
//! It is an universal way to initialize.
//! Suitable initialization method will be chosen.
- Standard_EXPORT bool Init (const Handle(OpenGl_Context)& theCtx,
- const Handle(Graphic3d_TextureMap)& theTextureMap);
+ Standard_EXPORT bool Init (const Handle(OpenGl_Context)& theCtx,
+ const Handle(Graphic3d_TextureRoot)& theTextureMap);
+
+ //! Generate mipmaps.
+ Standard_EXPORT bool GenerateMipmaps (const Handle(OpenGl_Context)& theCtx);
//! Initialize the texture with Image_CompressedPixMap.
Standard_EXPORT bool InitCompressed (const Handle(OpenGl_Context)& theCtx,
Standard_Size myRevision; //!< revision of associated data source
unsigned int myTextureId; //!< GL resource ID
unsigned int myTarget; //!< GL_TEXTURE_1D/GL_TEXTURE_2D/GL_TEXTURE_3D
- Standard_Integer mySizeX; //!< texture width
- Standard_Integer mySizeY; //!< texture height
- Standard_Integer mySizeZ; //!< texture depth
+ Graphic3d_Vec3i mySize; //!< texture width x height x depth
unsigned int myTextFormat; //!< texture format - GL_RGB, GL_RGBA,...
Standard_Integer mySizedFormat;//!< internal (sized) texture format
Standard_Integer myNbSamples; //!< number of MSAA samples
if (!theOffsetsTexture->Init (theContext,
OpenGl_TextureFormat::FindSizedFormat (theContext, GL_RG32I),
Graphic3d_Vec2i ((int )anOffsets.SizeX, (int )anOffsets.SizeY),
- Graphic3d_TOT_2D))
+ Graphic3d_TypeOfTexture_2D))
{
hasErrors = true;
}
}
Handle(OpenGl_Texture) aTextureEnv = new OpenGl_Texture (myTextureEnvData->GetId(), myTextureEnvData->GetParams());
- if (Handle(Image_PixMap) anImage = myTextureEnvData->GetImage (theContext->SupportedTextureFormats()))
- {
- aTextureEnv->Init (theContext, *anImage, myTextureEnvData->Type(), true);
- }
+ aTextureEnv->Init (theContext, myTextureEnvData);
+
myTextureEnv = new OpenGl_TextureSet (aTextureEnv);
myTextureEnv->ChangeTextureSetBits() = Graphic3d_TextureSetBits_BaseColor;
}
aParams->SetTextureUnit (aCtx->PBREnvLUTTexUnit());
anEnvLUT = new OpenGl_Texture(THE_SHARED_ENV_LUT_KEY, aParams);
if (!aTexFormat.IsValid()
- || !anEnvLUT->Init (aCtx, aTexFormat, Graphic3d_Vec2i((Standard_Integer)Textures_EnvLUTSize), Graphic3d_TOT_2D, aPixMap.get()))
+ || !anEnvLUT->Init (aCtx, aTexFormat, Graphic3d_Vec2i((Standard_Integer)Textures_EnvLUTSize), Graphic3d_TypeOfTexture_2D, aPixMap.get()))
{
aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, "Failed allocation of LUT for PBR");
anEnvLUT.Nullify();
myRaytraceVisualErrorTexture[aViewIter]->Init (theGlContext,
OpenGl_TextureFormat::FindSizedFormat (theGlContext, GL_R32I),
Graphic3d_Vec2i (myTileSampler.NbTilesX(), myTileSampler.NbTilesY()),
- Graphic3d_TOT_2D);
+ Graphic3d_TypeOfTexture_2D);
if (!myRaytraceParameters.AdaptiveScreenSamplingAtomic)
{
myRaytraceTileSamplesTexture[aViewIter]->Init (theGlContext,
OpenGl_TextureFormat::FindSizedFormat (theGlContext, GL_R32I),
Graphic3d_Vec2i (myTileSampler.NbTilesX(), myTileSampler.NbTilesY()),
- Graphic3d_TOT_2D);
+ Graphic3d_TypeOfTexture_2D);
}
}
else // non-adaptive mode
const Handle(Graphic3d_AspectFillArea3d)& anAspect = aPrs->Attributes()->ShadingAspect()->Aspect();
anAspect->SetShadingModel (Graphic3d_TypeOfShadingModel_Unlit);
anAspect->SetTextureMapOn (true);
- anAspect->SetTextureMap (new Graphic3d_Texture2Dmanual (anImage));
+ anAspect->SetTextureMap (new Graphic3d_Texture2D (anImage));
if (anImage->IsTopDown())
{
anAspect->TextureMap()->GetParams()->SetTranslation(Graphic3d_Vec2 (0.0f, -1.0f));
const Aspect_FillMethod theFillStyle,
const Standard_Boolean theToUpdate)
{
- Handle(Graphic3d_Texture2D) aTextureMap = new Graphic3d_Texture2Dmanual (theFileName);
+ Handle(Graphic3d_Texture2D) aTextureMap = new Graphic3d_Texture2D (theFileName);
aTextureMap->DisableModulate();
SetBackgroundImage (aTextureMap, theFillStyle, theToUpdate);
}
#include <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_CStructure.hxx>
-#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_Texture2D.hxx>
+#include <Graphic3d_Texture3D.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <Graphic3d_MediaTextureSet.hxx>
#include <Image_AlienPixMap.hxx>
return 1;
}
- int toModulate = -1;
- int toSetSRgb = -1;
- bool toSetFilter = false;
- bool toSetAniso = false;
- bool toSetTrsfAngle = false;
- bool toSetTrsfTrans = false;
- bool toSetTrsfScale = false;
+ int toModulate = -1, toSetSRgb = -1;
+ bool toSetFilter = false, toSetAniso = false, toSetTrsfAngle = false, toSetTrsfTrans = false, toSetTrsfScale = false;
Standard_ShortReal aTrsfRotAngle = 0.0f;
Graphic3d_Vec2 aTrsfTrans (0.0f, 0.0f);
Graphic3d_Vec2 aTrsfScale (1.0f, 1.0f);
Handle(AIS_InteractiveObject) aTexturedIO;
Handle(AIS_Shape) aTexturedShape;
Handle(Graphic3d_TextureSet) aTextureSetOld;
- NCollection_Vector<Handle(Graphic3d_Texture2Dmanual)> aTextureVecNew;
- bool toSetGenRepeat = false;
- bool toSetGenScale = false;
- bool toSetGenOrigin = false;
- bool toSetImage = false;
- bool toComputeUV = false;
+ NCollection_Vector<Handle(Graphic3d_TextureMap)> aTextureVecNew;
+ bool toSetGenRepeat = false, toSetGenScale = false, toSetGenOrigin = false, toSetImage = false, toComputeUV = false;
const TCollection_AsciiString aCommandName (theArgVec[0]);
bool toSetDefaults = aCommandName == "vtexdefault";
aTexturedIO->Attributes()->ShadingAspect()->Aspect()->SetTextureSet (aMedia);
aTextureSetOld.Nullify();
}
+ else if (aCommandName == "vtexture"
+ && aTextureVecNew.IsEmpty()
+ && aNameCase == "-3d")
+ {
+ TColStd_SequenceOfAsciiString aSlicesSeq;
+ for (; anArgIter + 1 < theArgsNb; ++anArgIter)
+ {
+ TCollection_AsciiString aSlicePath (theArgVec[anArgIter + 1]);
+ if (aSlicePath.StartsWith ("-"))
+ {
+ break;
+ }
+
+ aSlicesSeq.Append (aSlicePath);
+ }
+
+ if (aSlicesSeq.Size() < 2)
+ {
+ Message::SendFail() << "Syntax error at '" << aNameCase << "'";
+ return 1;
+ }
+ NCollection_Array1<TCollection_AsciiString> aSlices;
+ aSlices.Resize (0, aSlicesSeq.Size() - 1, false);
+ Standard_Integer aSliceIndex = 0;
+ for (const TCollection_AsciiString& aSliceIter : aSlicesSeq)
+ {
+ aSlices[aSliceIndex++] = aSliceIter;
+ }
+
+ toSetImage = true;
+ aTextureVecNew.SetValue (0, new Graphic3d_Texture3D (aSlices));
+ }
else if (aCommandName == "vtexture"
&& (aTextureVecNew.IsEmpty()
|| aNameCase.StartsWith ("-tex")))
Message::SendFail() << "Syntax error: texture with ID " << aValue << " is undefined!";
return 1;
}
- aTextureVecNew.SetValue (aTexIndex, new Graphic3d_Texture2Dmanual (Graphic3d_NameOfTexture2D (aValue)));
+ aTextureVecNew.SetValue (aTexIndex, new Graphic3d_Texture2D (Graphic3d_NameOfTexture2D (aValue)));
}
else if (aTexName == "?")
{
Message::SendFail() << "Syntax error: non-existing image file has been specified '" << aTexName << "'.";
return 1;
}
- aTextureVecNew.SetValue (aTexIndex, new Graphic3d_Texture2Dmanual (aTexName));
+ aTextureVecNew.SetValue (aTexIndex, new Graphic3d_Texture2D (aTexName));
}
else
{
- aTextureVecNew.SetValue (aTexIndex, Handle(Graphic3d_Texture2Dmanual)());
+ aTextureVecNew.SetValue (aTexIndex, Handle(Graphic3d_TextureMap)());
}
if (aTextureVecNew.Value (aTexIndex))
aTextureSetNew = new Graphic3d_TextureSet (aTextureVecNew.Size());
for (Standard_Integer aTexIter = 0; aTexIter < aTextureSetNew->Size(); ++aTexIter)
{
- Handle(Graphic3d_Texture2Dmanual)& aTextureNew = aTextureVecNew.ChangeValue (aTexIter);
+ Handle(Graphic3d_TextureMap)& aTextureNew = aTextureVecNew.ChangeValue (aTexIter);
Handle(Graphic3d_TextureRoot) aTextureOld;
if (!aTextureSetOld.IsNull()
&& aTexIter < aTextureSetOld->Size())
&& !aTextureNew.IsNull())
{
*aTextureNew->GetParams() = *aTextureOld->GetParams();
- if (Handle(Graphic3d_Texture2Dmanual) anOldManualTex = Handle(Graphic3d_Texture2Dmanual)::DownCast (aTextureOld))
+
+ Handle(Graphic3d_Texture2D) aTex2dNew = Handle(Graphic3d_Texture2D)::DownCast (aTextureNew);
+ Handle(Graphic3d_Texture2D) aTex2dOld = Handle(Graphic3d_Texture2D)::DownCast (aTextureOld);
+ if (!aTex2dOld.IsNull()
+ && !aTex2dNew.IsNull())
{
TCollection_AsciiString aFilePathOld, aFilePathNew;
aTextureOld->Path().SystemName (aFilePathOld);
aTextureNew->Path().SystemName (aFilePathNew);
- if (aTextureNew->Name() == anOldManualTex->Name()
+ if (aTex2dNew->Name() == aTex2dOld->Name()
&& aFilePathOld == aFilePathNew
- && (!aFilePathNew.IsEmpty() || aTextureNew->Name() != Graphic3d_NOT_2D_UNKNOWN))
+ && (!aFilePathNew.IsEmpty() || aTex2dNew->Name() != Graphic3d_NOT_2D_UNKNOWN))
{
--aNbChanged;
- aTextureNew = anOldManualTex;
+ aTextureNew = aTex2dOld;
}
}
}
addCmd ("vtexture", VTexture, /* [vtexture] */ R"(
vtexture [-noupdate|-update] name [ImageFile|IdOfTexture|off]
[-tex0 Image0] [-tex1 Image1] [...]
+ [-3d Image0 Image1 ... ImageN]
[-origin {u v|off}] [-scale {u v|off}] [-repeat {u v|off}]
[-trsfTrans du dv] [-trsfScale su sv] [-trsfAngle Angle]
[-modulate {on|off}] [-srgb {on|off}]=on
-setFilter Setup texture filter
-setAnisoFilter Setup anisotropic filter for texture with mip-levels
-default Sets texture mapping default parameters
+ -3d Load 3D texture from the list of 2D image files
)" /* [vtexture] */);
addCmd ("vtexscale", VTexture, /* [vtexscale] */ R"(
}
aProgram->SetHeader (aHeader);
}
+ else if (!aProgram.IsNull()
+ && (anArg == "-defaultsampler"
+ || anArg == "-defampler"
+ || anArg == "-nodefaultsampler"
+ || anArg == "-nodefsampler"))
+ {
+ bool toUseDefSampler = Draw::ParseOnOffNoIterator (theArgNb, theArgVec, anArgIter);
+ aProgram->SetDefaultSampler (toUseDefSampler);
+ }
else if (!anArg.StartsWith ("-")
&& GetMapOfAIS().IsBound2 (theArgVec[anArgIter]))
{
[-header VersionHeader]
[-tessControl TessControlShader -tessEval TessEvaluationShader]
[-uniform Name FloatValue]
+ [-defaultSampler {0|1}]=1
Assign custom GLSL program to presentation aspects.
)" /* [vshader] */);
#include <Graphic3d_GraphicDriver.hxx>
#include <Graphic3d_GraphicDriverFactory.hxx>
#include <Graphic3d_NameOfTextureEnv.hxx>
-#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_Texture2D.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <Graphic3d_TypeOfTextureFilter.hxx>
if (!anImagePath.IsEmpty())
{
- Handle(Graphic3d_Texture2D) aTextureMap = new Graphic3d_Texture2Dmanual (anImagePath);
+ Handle(Graphic3d_Texture2D) aTextureMap = new Graphic3d_Texture2D (anImagePath);
aTextureMap->DisableModulate();
aTextureMap->SetColorMap (isSRgb);
if (!aTextureMap->IsDone())
aMat.SetSpecularColor (Quantity_NOC_BLACK);
aMat.SetEmissiveColor (Quantity_NOC_BLACK);
aFillAspect->SetFrontMaterial (aMat);
- aFillAspect->SetTextureMap (new Graphic3d_Texture2Dmanual (theImage));
+ aFillAspect->SetTextureMap (new Graphic3d_Texture2D (theImage));
aFillAspect->SetTextureMapOn();
}
{
}
TCollection_AsciiString aTextureName (aChangeArgs[1]);
- Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ Handle(Graphic3d_Texture2D) aTexture = new Graphic3d_Texture2D (aTextureName);
if (!aTexture->IsDone())
{
aClipPlane->SetCappingTexture (NULL);
#include <Graphic3d_TextureParams.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XCAFPrs_Texture, Graphic3d_Texture2Dmanual)
+IMPLEMENT_STANDARD_RTTIEXT(XCAFPrs_Texture, Graphic3d_Texture2D)
//=======================================================================
//function : XCAFPrs_Texture
//=======================================================================
XCAFPrs_Texture::XCAFPrs_Texture (const Image_Texture& theImageSource,
const Graphic3d_TextureUnit theUnit)
-: Graphic3d_Texture2Dmanual (""),
+: Graphic3d_Texture2D (""),
myImageSource (theImageSource)
{
if (!myImageSource.TextureId().IsEmpty())
#include <Image_Texture.hxx>
//! Texture holder.
-class XCAFPrs_Texture : public Graphic3d_Texture2Dmanual
+class XCAFPrs_Texture : public Graphic3d_Texture2D
{
- DEFINE_STANDARD_RTTIEXT(XCAFPrs_Texture, Graphic3d_Texture2Dmanual)
+ DEFINE_STANDARD_RTTIEXT(XCAFPrs_Texture, Graphic3d_Texture2D)
public:
//! Constructor.
vcamera -fovy 100
if { [checkplatform -windows] && [vdriver -default] == "TKOpenGles" } {
# Mipmaps cannot be generated for GL_SRGB8 texture format
- puts "TODO OCC30807 ALL: TKOpenGl | Type: Error"
- puts "TODO OCC30807 ALL: Unable to generate mipmap of cubemap"
}
vbackground -cubemap $aCubeMap_posx $aCubeMap_negx $aCubeMap_posy $aCubeMap_negy $aCubeMap_posz $aCubeMap_negz
--- /dev/null
+puts "========"
+puts "0032862: Visualization, Graphic3d_TextureMap - add 3D texture definition"
+puts "========"
+
+pload MODELING VISUALIZATION
+
+set aTex1 [locate_data_file SF_CubeMap_posx.jpg]
+set aTex2 [locate_data_file SF_CubeMap_negx.jpg]
+set aTex3 [locate_data_file SF_CubeMap_posy.jpg]
+set aTex4 [locate_data_file SF_CubeMap_negy.jpg]
+set aTex5 [locate_data_file SF_CubeMap_posz.jpg]
+set aTex6 [locate_data_file SF_CubeMap_negz.jpg]
+
+set aShaderVert "
+THE_SHADER_OUT vec3 TexCoord;
+uniform float uSlice;
+void main() {
+ float aNbSlices = 6.0;
+ TexCoord = occVertex.xyz;
+ if (uSlice >= 0.0) { TexCoord = vec3(occTexCoord.xy, uSlice * 1.0 / aNbSlices + 0.5 / aNbSlices); }
+ if (occTextureTrsf_Scale().y < 0.0) { TexCoord.y = 1.0 - TexCoord.y; }
+ gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;
+}"
+
+set aShaderFrag "
+#ifdef GL_ES
+ uniform mediump sampler3D occSampler0;
+#else
+ uniform sampler3D occSampler0;
+#endif
+THE_SHADER_IN vec3 TexCoord;
+void main() {
+ occFragColor = occTexture3D(occSampler0, TexCoord);
+}"
+
+set aGlslVer "#version 110"
+if { [vdriver -default] == "TKOpenGles" } { set aGlslVer "#version 300 es" }
+
+# draw a box
+box b 1.0 1.0 1.0
+vclear
+vclose ALL
+vinit View1
+vaxo
+vdisplay -dispMode 1 b
+vfit
+vrotate 0.2 0.0 0.0
+
+# load 3D texture
+vtexture b -3d $aTex1 $aTex2 $aTex3 $aTex4 $aTex5 $aTex6
+
+# texture slices
+foreach aSliceIter {0 1 2 3 4 5} {
+ vshaderprog b -vert $aShaderVert -frag $aShaderFrag -defaultSampler 0 -uniform "uSlice" ${aSliceIter} -header "$aGlslVer"
+ vdump $::imagedir/${::casename}_s${aSliceIter}.png
+}
+
+# texture interpolation
+vshaderprog b -vert $aShaderVert -frag $aShaderFrag -defaultSampler 0 -uniform "uSlice" -1 -header "$aGlslVer"
+vdump $::imagedir/${::casename}_def.png
projects / occt.git / commitdiff