#ifndef _Geometry_h_
#define _Geometry_h_
class WrapGeo : public Geo {
public:
int CastMember(WrapGeo);
WrapGeo(Geo* pgeo);
WrapGeo(Geo* pgeo, Value* pvalue1);
void SetGeo(Geo* pvalue) { SetChild(0, pvalue); }
Geo* GetGeo() { return Geo::Cast(GetChild(0)); }
virtual TRef<WrapGeo> Duplicate(Geo* pgeo);
virtual Image* FindTexture();
void Render(Context* pcontext);
float GetRadius(const Matrix& mat = Matrix::GetIdentity());
void CallGroupGeoCallback(const Matrix& mat, GroupGeoCallback* pcallback);
TRef<Geo> FoldTexture();
TRef<Geo> RemoveMaterial();
TRef<Geo> ApplyTransform(Transform* ptrans);
int GetTriangleCount();
bool AnyChildGroups(bool bHead);
void RemoveCapture();
bool HitTest(const Vector& vecOrigin, const Vector& vecRay, HitData3D& hitData, bool bCaptured);
void MouseMove(const Vector& vec, bool bCaptured, bool bInside);
void MouseEnter(const Vector& vec);
void MouseLeave();
MouseResult Button(const Vector& vec, int button, bool bCaptured, bool bInside, bool bDown);
TRef<Value> Fold();
ZString GetFunctionName() { return "WrapGeo"; }
};
class DecalGeo : public Geo {
private:
Color m_color;
Vector m_vecPosition;
Vector m_vecForward;
Vector m_vecRight;
float m_scale;
float m_angle;
public:
DecalGeo(
Image* pimage,
const Color& color,
const Vector& position,
const Vector& forward,
const Vector& right,
float scale,
float angle
);
void SetImage(Image* pvalue) { SetChild(0, pvalue); }
Image* GetImage() { return Image::Cast(GetChild(0)); }
float GetAngle()
{
return m_angle;
}
void SetAngle(float angle)
{
m_angle = angle;
}
const Color& GetColor()
{
return m_color;
}
void SetColor(const Color& color)
{
m_color = color;
}
const Vector& GetPosition()
{
return m_vecPosition;
}
void SetPosition(const Vector& vec)
{
m_vecPosition = vec;
}
void SetForward(const Vector& vec)
{
m_vecForward = vec;
}
const Vector& GetForward()
{
return m_vecForward;
}
void SetRight(const Vector& vec)
{
m_vecRight = vec;
}
const Vector& GetRight()
{
return m_vecRight;
}
float GetScale()
{
return m_scale;
}
void SetScale(float scale)
{
m_scale = scale;
}
void Render(Context* pcontext);
int GetTriangleCount()
{
return 2;
}
ZString GetFunctionName() { return "DecalGeo"; }
};
class VisibleGeo : public WrapGeo {
private:
bool m_bVisible;
public:
DefineCastMember(VisibleGeo);
VisibleGeo(Geo* pgeo);
void SetVisible(bool bVisible);
bool IsVisible()
{
return m_bVisible;
}
TRef<WrapGeo> Duplicate(Geo* pgeo);
void Render(Context* pcontext);
ZString GetFunctionName() { return "VisibleGeo"; }
};
class ClipGeo : public WrapGeo {
private:
bool m_bClip;
public:
DefineCastMember(ClipGeo);
ClipGeo(Geo* pgeo);
bool GetClip()
{
return m_bClip;
}
void SetClip(bool bClip);
bool IsClip()
{
return m_bClip;
}
TRef<WrapGeo> Duplicate(Geo* pgeo);
void Render(Context* pcontext);
ZString GetFunctionName() { return "ClipGeo"; }
};
class ClipPlaneGeo : public WrapGeo {
private:
Plane m_plane;
public:
DefineCastMember(ClipPlaneGeo);
ClipPlaneGeo(Geo* pgeo, const Plane& plane);
void SetClipPlane(const Plane& plane);
virtual TRef<WrapGeo> Duplicate(Geo* pgeo);
void Render(Context* pcontext);
ZString GetFunctionName() { return "ClipPlaneGeo"; }
};
class TransformGeo : public WrapGeo {
public:
TransformGeo(Geo* pgeo, Transform* ptrans);
void SetTransform(Transform* pvalue) { SetChild(1, pvalue); }
Transform* GetTransform() { return Transform::Cast(GetChild(1)); }
virtual TRef<WrapGeo> Duplicate(Geo* pgeo);
void Render(Context* pcontext);
float GetRadius(const Matrix& mat = Matrix::GetIdentity());
void CallGroupGeoCallback(const Matrix& mat, GroupGeoCallback* pcallback);
TRef<Value> Fold();
ZString GetFunctionName() { return "TransformGeo"; }
};
class MaterialGeo : public WrapGeo {
private:
TRef<Material> m_pmaterial;
bool m_bOverride;
public:
MaterialGeo(Geo* pgeo, Material* pmaterial, bool bOverride = false);
void SetMaterial(Material* pvalue) { SetChild(1, pvalue); }
Material* GetMaterial() { return Material::Cast(GetChild(1)); }
virtual TRef<WrapGeo> Duplicate(Geo* pgeo);
void Render(Context* pcontext);
TRef<Geo> RemoveMaterial();
ZString GetFunctionName() { return "MaterialGeo"; }
};
class CullModeGeo : public WrapGeo {
private:
CullMode m_mode;
bool m_bOveride;
public:
CullModeGeo(Geo* pgeo, CullMode mode, bool bOveride = false) :
WrapGeo(pgeo),
m_mode(mode),
m_bOveride(bOveride)
{
}
void SetCullMode(CullMode mode) { m_mode = mode; }
CullMode GetCullMode() { return m_mode; }
TRef<WrapGeo> Duplicate(Geo* pgeo)
{
return new CullModeGeo(pgeo, m_mode, m_bOveride);
}
void Render(Context* pcontext)
{
pcontext->SetCullMode(m_mode, m_bOveride);
GetGeo()->Render(pcontext);
}
ZString GetFunctionName() { return "CullModeGeo"; }
};
class TextureGeo : public WrapGeo {
private:
bool m_bOverride;
public:
TextureGeo(Geo* pgeo, Image* pimageTexture, bool bOverride = false);
void SetTexture(Image* pvalue) { SetChild(1, pvalue); }
Image* GetTexture() { return Image::Cast(GetChild(1)); }
TRef<WrapGeo> Duplicate(Geo* pgeo);
TRef<Geo> FoldTexture();
virtual Image* FindTexture();
void Render(Context* pcontext);
TextureGeo* GetTextureGeo();
ZString GetFunctionName() { return "TextureGeo"; }
};
class TimedGeo : public WrapGeo, public EventSourceImpl {
private:
float m_lifespan;
void Evaluate();
Number* GetTime() { return Number::Cast(GetChild(1)); }
public:
TimedGeo(Geo* pgeo, Number* ptime, float lifespan);
virtual TRef<WrapGeo> Duplicate(Geo* pgeo);
};
class GroupGeo : public Geo {
protected:
GroupGeo() : Geo() {}
GroupGeo(Value* pvalue0) : Geo(pvalue0) {}
GroupGeo(Value* pvalue0, Value* pvalue1) : Geo(pvalue0, pvalue1) {}
public:
static TRef<GroupGeo> Create();
static TRef<GroupGeo> Create(Geo* pgeo);
static TRef<GroupGeo> Create(Geo* pgeo, Geo* pgeo2);
static TRef<GroupGeo> Create(Geo* pgeo, Geo* pgeo2, Geo* pgeo3);
virtual void SetName(const ZString& strName) = 0;
virtual const ZString& GetName() = 0;
virtual void AddGeo(Geo* pgeo) = 0;
virtual void RemoveGeo(Geo* pgeo) = 0;
virtual ValueList* GetList() = 0;
ZString GetFunctionName() { return "GroupGeo"; }
};
class LODGeo : public WrapGeo {
protected:
LODGeo(Geo* pgeo) : WrapGeo(pgeo) {}
public:
static TRef<LODGeo> Create(Geo* pgeo);
virtual void AddGeo(Geo* pgeo, float radius) = 0;
virtual ZString GetInfo() = 0;
ZString GetFunctionName() { return "LODGeo"; }
};
class CallbackGeo : public WrapGeo, IGeoCallback {
public:
CallbackGeo(Geo* pgeo);
virtual TRef<WrapGeo> Duplicate(Geo* pgeo);
void Render(Context* pcontext);
void RenderCallback(Context* pcontext);
};
TRef<Geo> CreateBlendGeo(Geo* pgeo, BlendMode blendMode);
#endif