Initial

proto/source/SOBJECT.HPP

@@ -0,0 +1,157 @@
+#ifndef _PROTO_SIMPLEOBJECT_HPP_
+#define _PROTO_SIMPLEOBJECT_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_BITMAP_HPP_
+#include <common/bitmap.hpp>
+#endif
+#ifndef _ENGINE_VECTOR3D_HPP_
+#include <engine/vector3d.hpp>
+#endif
+#ifndef _ENGINE_TEXTURE_HPP_
+#include <engine/texture.hpp>
+#endif
+#ifndef _PROTO_PUREOBJECT_HPP_
+#include <proto/pureobj.hpp>
+#endif
+
+class SimpleObject : public PureObject
+{
+public:
+	SimpleObject(void);
+	SimpleObject(const Vector3D &vector3D,UINT id=0);
+	virtual ~SimpleObject();
+	Point3D &operator[](unsigned short index);
+	void setVector(const Vector3D &vector3D);
+	const Vector3D &getInitVector(void)const;
+	void setTexture(SmartPointer<Bitmap> &textureBitmap,bool ownIt=false);
+	const SmartPointer<Bitmap> &getTexture(void)const;
+	virtual void rotate(const PureAngle &pureAngle,RotationMatrix::Orientation orientation);
+	virtual void translate(const Point &uvPoint,TranslationMatrix::Orientation orientation);
+	virtual void map(SmartPointer<DIB3D> &displayBitmap);
+	virtual void normalize(void);
+	virtual bool isInView(SmartPointer<DIB3D> &displayBitmap);
+	virtual const Vector3D &getVector(void)const;
+private:
+	SimpleObject(const SimpleObject &someSimpleObject);
+	SimpleObject &operator=(const SimpleObject &someSimpleObject);
+
+  SmartPointer<Bitmap> mTextureBitmap;
+  Vector3D mVector3D;
+	Vector3D mInitVector3D;
+};
+
+inline
+SimpleObject::SimpleObject(void)
+{
+}
+
+inline
+SimpleObject::SimpleObject(const Vector3D &vector3D,UINT id)
+: PureObject(id), mVector3D(vector3D), mInitVector3D(vector3D)
+{
+}
+
+inline
+SimpleObject::SimpleObject(const SimpleObject &someSimpleObject)
+{ // private implementation
+  *this=someSimpleObject;
+}
+
+inline
+SimpleObject::~SimpleObject()
+{
+}
+
+inline
+Point3D &SimpleObject::operator[](unsigned short index)
+{
+  return mVector3D[index];
+}
+
+inline
+SimpleObject &SimpleObject::operator=(const SimpleObject &someSimpleObject)
+{
+  mVector3D=someSimpleObject.mVector3D;
+	mTextureBitmap=someSimpleObject.mTextureBitmap;
+	setState(someSimpleObject.getState());
+	setID(someSimpleObject.getID());
+	return *this;
+}
+
+inline
+void SimpleObject::setVector(const Vector3D &vector3D)
+{
+  mVector3D=vector3D;
+}
+
+inline
+const Vector3D &SimpleObject::getVector(void)const
+{
+  return mVector3D;
+}
+
+inline
+const Vector3D &SimpleObject::getInitVector(void)const
+{
+  return mInitVector3D;
+}
+
+inline
+void SimpleObject::setTexture(SmartPointer<Bitmap> &textureBitmap,bool ownIt)
+{
+  mTextureBitmap=textureBitmap;
+	if(ownIt)mTextureBitmap.disposition(PointerDisposition::Delete);
+}
+
+inline
+const SmartPointer<Bitmap> &SimpleObject::getTexture(void)const
+{
+  return mTextureBitmap;
+}
+// virtuals
+
+inline
+void SimpleObject::map(SmartPointer<DIB3D> &displayBitmap)
+{
+  Texture textureMapper(mVector3D,*mTextureBitmap,*displayBitmap);
+	textureMapper.mapTexture();
+}
+
+inline
+void SimpleObject::rotate(const PureAngle &pureAngle,RotationMatrix::Orientation orientation)
+{
+  RotationMatrix rotationMatrix;
+	rotationMatrix.orientation(orientation);
+	rotationMatrix.angle(pureAngle);
+	rotationMatrix.evaluate(mVector3D[0]);
+	rotationMatrix.evaluate(mVector3D[1]);
+	rotationMatrix.evaluate(mVector3D[2]);
+	rotationMatrix.evaluate(mVector3D[3]);
+}
+
+inline
+void SimpleObject::translate(const Point &uvPoint,TranslationMatrix::Orientation orientation)
+{
+  TranslationMatrix translationMatrix;
+	translationMatrix.orientation(orientation);
+	translationMatrix.uvPoint(uvPoint);
+	translationMatrix.evaluate(mVector3D[0]);
+	translationMatrix.evaluate(mVector3D[1]);
+	translationMatrix.evaluate(mVector3D[2]);
+	translationMatrix.evaluate(mVector3D[3]);
+}
+
+inline
+void SimpleObject::normalize(void)
+{
+  mVector3D.normalize();
+}
+
+inline
+bool SimpleObject::isInView(SmartPointer<DIB3D> &displayBitmap)
+{
+  return displayBitmap->isInView(mVector3D);
+}
+#endif