com.hikky.vketcloudsdk 3.2.4

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CDualQuaternion.cpp

@@ -0,0 +1,116 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CDualQuaternion.cpp
+
+#include "CDualQuaternion.h"
+#include "S3D.h"
+#include "SMatrix.h"
+
+namespace math3d {
+
+CDualQuaternion::CDualQuaternion() :
+	m_RealPart(0.0f, 0.0f, 0.0f, 1.0f),
+	m_DualPart(0.0f, 0.0f, 0.0f, 0.0f)
+{
+}
+
+CDualQuaternion::CDualQuaternion(const SQuaternion& RealPart, const SQuaternion& DualPart) :
+	m_RealPart(RealPart),
+	m_DualPart(DualPart)
+{
+}
+
+CDualQuaternion::CDualQuaternion(const SQuaternion& Rotate, const S3D& Move) :
+	m_RealPart(Rotate),
+	m_DualPart(
+		0.5f * (Move.fX * Rotate.fW + Move.fY * Rotate.fZ - Move.fZ * Rotate.fY),
+		0.5f * (-Move.fX * Rotate.fZ + Move.fY * Rotate.fW + Move.fZ * Rotate.fX),
+		0.5f * (Move.fX * Rotate.fY - Move.fY * Rotate.fX + Move.fZ * Rotate.fW),
+		-0.5f * (Move.fX * Rotate.fX + Move.fY * Rotate.fY + Move.fZ * Rotate.fZ))
+{
+}
+
+CDualQuaternion::~CDualQuaternion()
+{
+}
+
+CDualQuaternion CDualQuaternion::operator+(const CDualQuaternion& Obj) const
+{
+	return CDualQuaternion(m_RealPart + Obj.m_RealPart, m_DualPart * Obj.m_DualPart);
+}
+
+CDualQuaternion CDualQuaternion::operator*(const CDualQuaternion& Obj) const
+{
+	return CDualQuaternion(
+		Obj.m_RealPart * m_RealPart,
+		Obj.m_RealPart * m_DualPart + Obj.m_DualPart * m_RealPart);
+}
+
+CDualQuaternion& CDualQuaternion::operator*=(const CDualQuaternion& Obj)
+{
+	*this = *this * Obj;
+
+	return *this;
+}
+
+//
+CDualQuaternion CDualQuaternion::GetInverse() const
+{
+	const SQuaternion InvReal = m_RealPart.GetInverse();
+
+	const float rd = -2.0f * (m_RealPart.fX * m_DualPart.fX + m_RealPart.fY * m_DualPart.fY +
+		m_RealPart.fZ * m_DualPart.fZ + m_RealPart.fW * m_DualPart.fW);
+
+	return CDualQuaternion(m_RealPart.GetInverse(), m_DualPart.GetInverse() +
+		SQuaternion(InvReal.fX * rd, InvReal.fY * rd, InvReal.fZ * rd, InvReal.fW * rd));
+}
+
+// ����
+const SQuaternion& CDualQuaternion::GetRealPart() const
+{
+	return m_RealPart;
+}
+
+// �����
+const SQuaternion& CDualQuaternion::GetDualPart() const
+{
+	return m_DualPart;
+}
+
+// �s��
+SMatrix CDualQuaternion::GetMatrix() const
+{
+	const float fXX = m_RealPart.fX * m_RealPart.fX;
+	const float fYY = m_RealPart.fY * m_RealPart.fY;
+	const float fZZ = m_RealPart.fZ * m_RealPart.fZ;
+
+	const float fXY = m_RealPart.fX * m_RealPart.fY;
+	const float fXZ = m_RealPart.fX * m_RealPart.fZ;
+	const float fXW = m_RealPart.fX * m_RealPart.fW;
+	const float fYZ = m_RealPart.fY * m_RealPart.fZ;
+	const float fYW = m_RealPart.fY * m_RealPart.fW;
+	const float fZW = m_RealPart.fZ * m_RealPart.fW;
+
+	return SMatrix(
+		1.0f - 2.0f * (fYY + fZZ),		// 00
+		2.0f * (fXY + fZW),		// 10
+		2.0f * (fXZ - fYW),		// 20
+		0.0f,
+
+		2.0f * (fXY - fZW),		// 01
+		1.0f - 2.0f * (fZZ + fXX),		// 11
+		2.0f * (fYZ + fXW),		// 21
+		0.0f,
+
+		2.0f * (fXZ + fYW),		// 02
+		2.0f * (fYZ - fXW),		// 12
+		1.0f - 2.0f * (fYY + fXX),		// 22
+		0.0f,
+
+		2.0f * (-m_DualPart.fW * m_RealPart.fX + m_RealPart.fW * m_DualPart.fX - m_DualPart.fY * m_RealPart.fZ + m_RealPart.fY * m_DualPart.fZ),
+		2.0f * (-m_DualPart.fW * m_RealPart.fY + m_RealPart.fZ * m_DualPart.fX - m_DualPart.fZ * m_RealPart.fX + m_RealPart.fW * m_DualPart.fY),
+		2.0f * (-m_DualPart.fW * m_RealPart.fZ + m_RealPart.fX * m_DualPart.fY + m_DualPart.fZ * m_RealPart.fW - m_RealPart.fY * m_DualPart.fX),
+		1.0f);							// 33
+}
+
+}
+

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CDualQuaternion.cpp.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: dc0ad2bbb61067540adcd24dc057eaac
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CDualQuaternion.h

@@ -0,0 +1,44 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CDualQuaternion.h
+
+#ifndef CDUALQUATERNION_H_
+#define CDUALQUATERNION_H_
+
+#include "SQuaternion.h"
+
+struct S3D;
+struct SMatrix;
+
+namespace math3d {
+
+class CDualQuaternion {
+	SQuaternion		m_RealPart,
+		m_DualPart;
+
+public:
+	CDualQuaternion();
+	CDualQuaternion(const SQuaternion& RealPart, const SQuaternion& DualPart);
+	CDualQuaternion(const SQuaternion& Rotate, const S3D& Move);
+	virtual ~CDualQuaternion();
+
+	CDualQuaternion		operator+(const CDualQuaternion& Obj) const;
+	CDualQuaternion		operator*(const CDualQuaternion& Obj) const;
+	CDualQuaternion&	operator*=(const CDualQuaternion& Obj);
+
+	//
+	CDualQuaternion		GetInverse() const;
+
+	// ����
+	const SQuaternion&	GetRealPart() const;
+
+	// �����
+	const SQuaternion&	GetDualPart() const;
+
+	// �s��
+	SMatrix		GetMatrix() const;
+};
+
+}
+
+#endif // CDUALQUATERNION_H_
+

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CDualQuaternion.h.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 4f6b0b2d5c7f5944e991c11363f493a3
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CProjection.cpp

@@ -0,0 +1,171 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CProjection.cpp
+
+#include "CCamera.h"
+#include "CProjection.h"
+
+namespace math3d {
+
+CProjection::CProjection(void) :
+m_Width(0),
+m_Height(0),
+m_fNear(0.0f),
+m_fFar(0.0f),
+m_Deg(0.0f)
+{
+}
+
+CProjection::~CProjection()
+{
+}
+
+void CProjection::Set(int nWidth, int nHeight, float fNear, float fFar, float fDeg)
+{
+	m_Width = nWidth;
+	m_Height = nHeight;
+	m_fNear = fNear;
+	m_fFar = fFar;
+	m_Deg = fDeg;
+
+	const double dN = m_fNear;
+	const double dF = m_fFar;
+
+	if (m_Deg > 0.0f) {
+		// �c���䗦�̏ꍇ�͎w��p�x�𐂒��p�x�Ƃ݂Ȃ�
+		if (nHeight > nWidth) {
+			fDeg = fDeg * nWidth / nHeight;
+		}
+
+		//
+		const double dPI = 3.1415926535897932384626433;
+		const double dHalfDeg = (double)fDeg * 0.5;
+		const double dTan = tan(dHalfDeg * dPI / 180.0);
+
+		const double dW = 1.0 / dTan;
+		const double dH = (double)m_Width / (dTan * (double)m_Height);
+
+		m_matProjection.Set(
+			(float)dW, 0, 0, 0,
+			0, (float)dH, 0, 0,
+			0, 0, float(dF / (dF - dN)), 1,
+			0, 0, float(-dN * dF / (dF - dN)), 0);
+	}
+	else {
+		const double dMag = -m_Deg;		// �g�嗦
+
+		m_matProjection.Set(
+			float(dMag), 0, 0, 0,
+			0, float(dMag * m_Width / m_Height), 0, 0,
+			0, 0, float(1.0 / (dF - dN)), 0,
+			0, 0, 0, 1);
+	}
+
+	// �e���ʂ̊O�����̖@�������߂�
+	m_NormalList.resize(6);
+
+	m_NormalList[0] = S3D(-m_matProjection.m[0][0], 0.0f, -1.0f).GetNormalize();	// Left
+	m_NormalList[1] = S3D( m_matProjection.m[0][0], 0.0f, -1.0f).GetNormalize();	// Right
+	m_NormalList[2] = S3D(0.0f,  m_matProjection.m[1][1], -1.0f).GetNormalize();	// Top
+	m_NormalList[3] = S3D(0.0f, -m_matProjection.m[1][1], -1.0f).GetNormalize();	// Bottom
+	m_NormalList[4] = S3D(0.0f, 0.0f, -1.0f);										// Near
+	m_NormalList[5] = S3D(0.0f, 0.0f,  1.0f);										// Far
+}
+
+void CProjection::Resize(int Width, int Height)
+{
+	Set(Width, Height, m_fNear, m_fFar, m_Deg);
+}
+
+int CProjection::GetWidth() const
+{
+	return m_Width;
+}
+
+int CProjection::GetHeight() const
+{
+	return m_Height;
+}
+
+float CProjection::GetNear() const
+{
+	return m_fNear;
+}
+
+float CProjection::GetFar() const
+{
+	return m_fFar;
+}
+
+float CProjection::GetDeg() const
+{
+	return m_Deg;
+}
+
+const SMatrix& CProjection::GetMatrix() const
+{
+	return m_matProjection;
+}
+
+const std::vector<S3D>& CProjection::GetNormalList() const
+{
+	return m_NormalList;
+}
+
+S3D CProjection::GetPosOnNearPlane(int X, int Y) const
+{
+	const float TanX = 1.0f / m_matProjection.m[0][0];
+	const float TanY = 1.0f / m_matProjection.m[1][1];
+
+	const float X0 = m_fNear * -TanX;
+	const float X1 = m_fNear *  TanX;
+	const float Y0 = m_fNear *  TanY;
+	const float Y1 = m_fNear * -TanY;
+
+	const float XRate = X / static_cast<float>(m_Width);
+	const float YRate = Y / static_cast<float>(m_Height);
+
+	return S3D(
+		X0 + (X1 - X0) * XRate,
+		Y0 + (Y1 - Y0) * YRate,
+		m_fNear);
+}
+
+// �r���[�t���X�^��
+std::vector<SPlane> CProjection::CalcViewFrustumPlaneList(const CCamera& Camera) const
+{
+	std::vector<SPlane> ViewFrustumPlaneList;
+	ViewFrustumPlaneList.resize(6);
+
+	const auto& ViewFrustumNormalList = GetNormalList();
+
+	for (int n = 0; n < 4; n++) {
+		ViewFrustumPlaneList[n] = SPlane(Camera.GetPos(), ViewFrustumNormalList[n].MulMatrixRot(Camera.GetRotInvMatrix()));
+	}
+
+	ViewFrustumPlaneList[4] = SPlane(Camera.GetPos() + Camera.GetViewVec() * GetNear(),
+		S3D(0.0f, 0.0f, -1.0f).MulMatrixRot(Camera.GetRotInvMatrix()));
+	ViewFrustumPlaneList[5] = SPlane(Camera.GetPos() + Camera.GetViewVec() * GetFar(),
+		S3D(0.0f, 0.0f, 1.0f).MulMatrixRot(Camera.GetRotInvMatrix()));
+
+	return ViewFrustumPlaneList;
+}
+
+//
+SMatrix CProjection::CalcFOVMatrix(float UpTan, float DownTan, float LeftTan, float RightTan, float Near, float Far)
+{
+	float XScale = 2.0f / ( LeftTan + RightTan );
+	float XOffset = ( LeftTan - RightTan ) * XScale * 0.5f;
+	float YScale = 2.0f / ( UpTan + DownTan );
+	float YOffset = ( UpTan - DownTan ) * YScale * 0.5f;
+
+	const float Hand = 1.0f;
+
+	return SMatrix(
+		XScale,				0.0f,				0.0f,							0.0f,
+		0.0f,				YScale,				0.0f,							0.0f,
+		XOffset * Hand,		Hand * -YOffset,	-Hand * Far / (Near - Far),		Hand,
+		0.0f,				0.0f,				(Far * Near) / (Near - Far),	0.0f);
+}
+
+}
+

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CProjection.cpp.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 6662df0b640876349b09eaca7505440f
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CProjection.h

@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CProjection.h
+
+#pragma once
+
+#include <vector>
+#include "S3D.h"
+#include "SMatrix.h"
+#include "SPlane.h"
+
+namespace math3d {
+
+class CCamera;
+
+class CProjection {
+	SMatrix		m_matProjection;
+
+	int			m_Width,
+				m_Height;
+
+	float		m_fNear,
+				m_fFar;
+
+	float		m_Deg;
+
+	std::vector<S3D>	m_NormalList;
+
+public:
+	CProjection(void);
+	virtual ~CProjection();
+
+	void	Set(int nWidth, int nHeight, float fNear, float fFar, float fDeg);
+
+	void	Resize(int Width, int Height);
+
+	int		GetWidth() const;
+	int		GetHeight() const;
+
+	float	GetNear() const;
+	float	GetFar() const;
+	float	GetDeg() const;
+
+	const SMatrix&	GetMatrix() const;
+
+	const std::vector<S3D>&		GetNormalList() const;
+
+	S3D		GetPosOnNearPlane(int X, int Y) const;
+
+	// �r���[�t���X�^��
+	std::vector<SPlane>		CalcViewFrustumPlaneList(const CCamera& Camera) const;
+
+	//
+	static SMatrix		CalcFOVMatrix(float UpTan, float DownTan, float LeftTan, float RightTan, float Near, float Far);
+};
+
+}
+

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CProjection.h.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: a72980b1f3e5c454a921a301956f46d9
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CSphere.cpp

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CSphere.cpp
+
+#include "CSphere.h"
+
+namespace math3d {
+
+CSphere::CSphere() :
+m_Radius(0.0f)
+{
+
+}
+
+CSphere::CSphere(const S3D& Pos, float Radius) :
+m_Pos(Pos),
+m_Radius(Radius)
+{
+
+}
+
+CSphere::~CSphere()
+{
+
+}
+
+void CSphere::Set(const S3D& Pos, float Radius)
+{
+	m_Pos = Pos;
+	m_Radius = Radius;
+
+}
+
+const S3D& CSphere::GetPos() const
+{
+	return m_Pos;
+
+}
+
+float CSphere::GetRadius() const
+{
+	return m_Radius;
+
+}
+
+// ���ƌ����̏Փ˔���
+bool CSphere::IsCollision(const S3D& RayPos, const S3D& RayVec) const
+{
+	const S3D m = RayPos - m_Pos;
+	const float b = S3D::DotProduct(m, RayVec);
+	const float c = S3D::DotProduct(m, m) - m_Radius * m_Radius;
+
+	if (c > 0.0f && b > 0.0f) return false;
+
+	const float discr = b * b - c;
+	if (discr < 0.0f) return false;
+
+//	float t = -b - sqrt(discr);
+//	if (t < 0.0f) t = 0.0f;
+
+	return true;
+
+}
+
+}
+

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CSphere.cpp.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 4ce0b8772ad73bb4ea841ae06acd2f37
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CSphere.h

@@ -0,0 +1,29 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CSphere.h
+
+#pragma once
+
+#include "S3D.h"
+
+namespace math3d {
+
+class CSphere {
+	S3D		m_Pos;
+	float	m_Radius;
+
+public:
+	CSphere();
+	CSphere(const S3D& Pos, float Radius);
+	virtual ~CSphere();
+
+	void	Set(const S3D& Pos, float Radius);
+
+	const S3D&	GetPos() const;
+	float		GetRadius() const;
+
+	// ���ƌ����̏Փ˔���
+	bool	IsCollision(const S3D& RayPos, const S3D& RayVec) const;
+};
+
+}
+

package/PackageResources/tools/HEOTexComp/Source/Independent/Math3D/CSphere.h.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 682522475ff261f4d81c9cefb50ba074
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: