graytrace.h

一个非常有用的开源代码

	RenderMode m_eMode;
	GImage* m_pImage;
	GRayTraceReal* m_pDistanceMap;
	int m_nY;
	GRayTraceVector m_pixSide;
	GRayTraceVector m_pixDX;
	GRayTraceVector m_pixDY;

public:
	GRayTraceScene();
	~GRayTraceScene();

	// Specify whether to emphasize quality or speed
	void SetRenderMode(RenderMode eMode) { m_eMode = eMode; }

	// This method calls RenderBegin, then calls RenderLine until
	// the whole image has been rendered.
	void Render();

	// Call this before calling RenderLine(). It resets the image and
	// computes values necessary for rendering.
	void RenderBegin();

	// Call this to render a singe horizontal line of the image. Returns true if there's
	// still more rendering to do. Returns false if it's done. You must call RenderBegin()
	// once before you start calling this method.
	bool RenderLine();

	// This calls RenderBegine and then renders a single pixel. It's not efficient
	// to call this method for every pixel. The only purpose for this method is to
	// make debugging the ray tracer easier. Pick a pixel that isn't rendered the way
	// you want and step through the ray tracing process to see why.
	GColor RenderSinglePixel(int x, int y);

	// Returns the rendered image (or partially rendered image). Returns NULL if Render()
	// or RenderBegin() has not been called yet.
	GImage* GetImage() { return m_pImage; }

	GImage* DropImage()
	{
		GImage* pImage = m_pImage;
		m_pImage = NULL;
		return pImage;
	}

	void SetBackgroundColor(GRayTraceReal a, GRayTraceReal r, GRayTraceReal g, GRayTraceReal b)
	{
		m_backgroundColor.Set(a, r, g, b);
	}

	void SetAmbientLight(GRayTraceReal r, GRayTraceReal g, GRayTraceReal b)
	{
		m_ambientLight.Set(1, r, g, b);
	}

	GRayTraceColor* GetAmbientLight() { return &m_ambientLight; }

	GRayTraceCamera* GetCamera()
	{
		return m_pCamera;
	}

	void ActivateDistanceMap();
	GRayTraceReal* GetDistanceMap() { return m_pDistanceMap; }
	void AddMaterial(GRayTraceMaterial* pMaterial);
	void AddMesh(GRayTraceTriMesh* pMesh);
	void AddObject(GRayTraceObject* pObject);
	void AddLight(GRayTraceLight* pLight);
	int GetObjectCount();
	GRayTraceObject* GetObject(int n);
	int GetLightCount();
	GRayTraceLight* GetLight(int n);
	GRayTraceColor* GetBackgroundColor() { return &m_backgroundColor; }
	GRayTraceBoundingBoxBase* GetBoundingBoxTree() { return m_pBoundingBoxTree; }
	void SetToneMappingConstant(GRayTraceReal c) { m_toneMappingConstant = c; }

	GColor RenderPixel(GRayTraceRay* pRay, GRayTraceVector* pScreenPoint, GRayTraceReal* pDistance);
	GColor RenderPixelAntiAliassed(GRayTraceRay* pRay, GRayTraceVector* pScreenPoint, GRayTraceReal* pDistance);
	GColor RenderPixelPathTrace(GRayTraceRay* pRay, GRayTraceVector* pScreenPoint);
};




class GRayTraceLight
{
protected:
	GRayTraceColor m_color;

public:
	GRayTraceLight(GRayTraceReal r, GRayTraceReal g, GRayTraceReal b);
	virtual ~GRayTraceLight();

	virtual void ComputeColorContribution(GRayTraceScene* pScene, GRayTraceRay* pRay, GRayTraceMaterial* pMaterial, bool bSpecular) = 0;
};





class GRayTraceDirectionalLight : public GRayTraceLight
{
protected:
	GRayTraceVector m_direction;
	GRayTraceReal m_jitter;

public:
	GRayTraceDirectionalLight(GRayTraceReal dx, GRayTraceReal dy, GRayTraceReal dz, GRayTraceReal r, GRayTraceReal g, GRayTraceReal b, GRayTraceReal jitter);
	virtual ~GRayTraceDirectionalLight();

	virtual void ComputeColorContribution(GRayTraceScene* pScene, GRayTraceRay* pRay, GRayTraceMaterial* pMaterial, bool bSpecular);
};




class GRayTracePointLight : public GRayTraceLight
{
protected:
	GRayTraceVector m_position;
	GRayTraceReal m_jitter;

public:
	GRayTracePointLight(GRayTraceReal x, GRayTraceReal y, GRayTraceReal z, GRayTraceReal r, GRayTraceReal g, GRayTraceReal b, GRayTraceReal jitter);
	virtual ~GRayTracePointLight();

	virtual void ComputeColorContribution(GRayTraceScene* pScene, GRayTraceRay* pRay, GRayTraceMaterial* pMaterial, bool bSpecular);
};




class GRayTraceAreaLight : public GRayTraceLight
{
protected:
	GRayTraceObject* m_pObject;

public:
	GRayTraceAreaLight(GRayTraceObject* pObject, GRayTraceReal r, GRayTraceReal g, GRayTraceReal b);
	virtual ~GRayTraceAreaLight();

	virtual void ComputeColorContribution(GRayTraceScene* pScene, GRayTraceRay* pRay, GRayTraceMaterial* pMaterial, bool bSpecular);
};




class GRayTraceMaterial
{
public:
	enum ColorType
	{
		Diffuse = 0,
		Specular,
		Reflective,
		Transmissive,
		Ambient,
		Emissive, // for object lights or flourescent objects
		Texture, // used internally to handle texture mapping
	};

protected:
	GRayTraceColor m_colors[7];
	GRayTraceReal m_indexOfRefraction;
	GRayTraceReal m_specularExponent;
	GRayTraceReal m_glossiness;
	GRayTraceReal m_cloudiness;
	GImage* m_pTextureImage;
	bool m_bDeleteTextureImage;

public:
	GRayTraceMaterial();
	GRayTraceMaterial(GRayTraceMaterial* pThat);
	~GRayTraceMaterial();

	GRayTraceColor* GetColor(ColorType eType, GRayTraceRay* pRay);
	void SetColor(ColorType eType, GRayTraceReal r, GRayTraceReal g, GRayTraceReal b);
	void SetColor(ColorType eType, GRayTraceColor* pCol);
	GRayTraceReal GetIndexOfRefraction() { return m_indexOfRefraction; }
	GRayTraceReal GetSpecularExponent() { return m_specularExponent; }
	GRayTraceReal GetGlossiness() { return m_glossiness; }
	GRayTraceReal GetCloudiness() { return m_cloudiness; }
	void SetIndexOfRefraction(GRayTraceReal val) { m_indexOfRefraction = val; }
	void SetSpecularExponent(GRayTraceReal val) { m_specularExponent = val; }
	void SetGlossiness(GRayTraceReal val) { m_glossiness = val; }
	void SetCloudiness(GRayTraceReal val) { m_cloudiness = val; }

	void ComputeColor(GRayTraceScene* pScene, GRayTraceRay* pRay, bool bAmbient, bool bSpecular);

	void SetTextureImage(GImage* pImage, bool bDeleteImage)
	{
		m_pTextureImage = pImage;
		m_bDeleteTextureImage = bDeleteImage;
	}
	GImage* GetTextureImage() { return m_pTextureImage; }
};



#define MAX_OBJECTS_PER_BOUNDING_BOX 5

class GRayTraceBoundingBoxBase
{
public:
	GRayTraceVector m_min;
	GRayTraceVector m_max;

public:
	GRayTraceBoundingBoxBase() {}
	virtual ~GRayTraceBoundingBoxBase() {}

	static GRayTraceBoundingBoxBase* MakeBoundingBoxTree(GPointerArray* pObjects);
	virtual bool IsLeaf() = 0;
	virtual GRayTraceObject* FindClosestIntersection(GRayTraceVector* pRayOrigin, GRayTraceVector* pDirectionVector, GRayTraceReal* pOutDistance) = 0;

protected:
	static GRayTraceBoundingBoxBase* BuildTree(GPointerArray* pObjects);
	bool DoesRayHitBox(GRayTraceVector* pRayOrigin, GRayTraceVector* pDirectionVector);
};


class GRayTraceBoundingBoxInterior : public GRayTraceBoundingBoxBase
{
protected:
	GRayTraceBoundingBoxBase* m_pLesser;
	GRayTraceBoundingBoxBase* m_pGreater;

public:
	GRayTraceBoundingBoxInterior(GRayTraceBoundingBoxBase* pLesser, GRayTraceBoundingBoxBase* pGreater)
	: GRayTraceBoundingBoxBase()
	{
		m_pLesser = pLesser;
		m_pGreater = pGreater;
		m_min.m_vals[0] = MIN(pLesser->m_min.m_vals[0], pGreater->m_min.m_vals[0]);
		m_min.m_vals[1] = MIN(pLesser->m_min.m_vals[1], pGreater->m_min.m_vals[1]);
		m_min.m_vals[2] = MIN(pLesser->m_min.m_vals[2], pGreater->m_min.m_vals[2]);
		m_max.m_vals[0] = MAX(pLesser->m_max.m_vals[0], pGreater->m_max.m_vals[0]);
		m_max.m_vals[1] = MAX(pLesser->m_max.m_vals[1], pGreater->m_max.m_vals[1]);
		m_max.m_vals[2] = MAX(pLesser->m_max.m_vals[2], pGreater->m_max.m_vals[2]);
	}

	virtual ~GRayTraceBoundingBoxInterior()
	{
		delete(m_pLesser);
		delete(m_pGreater);
	}

	virtual bool IsLeaf() { return false; };
	GRayTraceBoundingBoxBase* GetLesser() { return m_pLesser; }
	GRayTraceBoundingBoxBase* GetGreater() { return m_pGreater; }
	virtual GRayTraceObject* FindClosestIntersection(GRayTraceVector* pRayOrigin, GRayTraceVector* pDirectionVector, GRayTraceReal* pOutDistance);
};


class GRayTraceBoundingBoxLeaf : public GRayTraceBoundingBoxBase
{
protected:
	int m_nObjectCount;
	GRayTraceObject** m_pObjects;

public:
	GRayTraceBoundingBoxLeaf(GPointerArray* pObjects);
	virtual ~GRayTraceBoundingBoxLeaf();

	virtual bool IsLeaf() { return true; }
	virtual GRayTraceObject* FindClosestIntersection(GRayTraceVector* pRayOrigin, GRayTraceVector* pDirectionVector, GRayTraceReal* pOutDistance);
};




class GRayTraceTriMesh
{
protected:
	GRayTraceMaterial* m_pMaterial;
	int m_nPoints;
	GRayTraceVector* m_pPoints;
	int m_nTriangles;
	int* m_pTriangles;
	GRayTraceVector* m_pNormals;
	GRayTraceReal* m_pTextureCoords;
	bool m_bCulling;

public:
	GRayTraceTriMesh(GRayTraceMaterial* pMaterial, int nPoints, int nTriangles, int nNormals, int nTextureCoords);
	~GRayTraceTriMesh();

	static GRayTraceTriMesh* MakeCylinder(GRayTraceMaterial* pMaterial, GRayTraceVector* pCenter1, GRayTraceVector* pCenter2, GRayTraceReal radius, int nSides, bool bEndCaps);

	// The vertices must go around the surface. Don't cut across corners.
	static GRayTraceTriMesh* MakeQuadSurface(GRayTraceMaterial* pMaterial, GRayTraceVector* p1, GRayTraceVector* p2, GRayTraceVector* p3, GRayTraceVector* p4);

	static GRayTraceTriMesh* MakeSingleTriangle(GRayTraceMaterial* pMaterial, GRayTraceVector* p1, GRayTraceVector* p2, GRayTraceVector* p3);

	GRayTraceReal ComputeRayDistanceToTriangle(int nTriangle, GRayTraceVector* pRayOrigin, GRayTraceVector* pRayDirection);
	void ComputeNormalVector(GRayTraceRay* pRay, int nIndex);
	bool IsCulled() { return m_bCulling; }
	void ActivateCulling() { m_bCulling = true; }
	void SetPoint(int nIndex, GRayTraceVector* pPoint);
	void SetTriangle(int nIndex, int v1, int v2, int v3);
	void SetNormal(int nIndex, GRayTraceVector* pNormal);
	void SetTextureCoord(int nIndex, GRayTraceReal x, GRayTraceReal y);
	void GetCenter(GRayTraceVector* pOutPoint, int nIndex);
	int GetTriangleCount() { return m_nTriangles; }
	GRayTraceMaterial* GetMaterial() { return m_pMaterial; }
	void AdjustBoundingBox(int nIndex, GRayTraceVector* pMin, GRayTraceVector* pMax);
	GRayTraceVector* GetVertex(int nIndex, int nVertex);

	// Automatically compute phong normals at the vertices to make the object appear smooth
	void ComputePhongNormals();

protected:
	bool IsPointWithinPlanarPolygon(GRayTraceVector* pPoint, GRayTraceVector** ppVertices, int nVertices);
	void ComputeTriangleNeighborSides(GPointerQueue* pQ, GNodeHashTable* pEdges, int* pFaces, int i);
};





class GRayTraceObject
{
public:
	enum ObjectType
	{
		Sphere,
		Triangle,
	};

	GRayTraceObject()
	{
	}

	virtual ~GRayTraceObject()
	{
	}

	virtual ObjectType GetType() = 0;
	virtual GRayTraceMaterial* GetMaterial() = 0;
	virtual GRayTraceReal ComputeRayDistance(GRayTraceVector* pRayOrigin, GRayTraceVector* pRayDirection) = 0;
	virtual void ComputeNormalVector(GRayTraceRay* pRay) = 0;
	virtual bool IsCulled() = 0;
	virtual void GetCenter(GRayTraceVector* pOutPoint) = 0;
	virtual void AdjustBoundingBox(GRayTraceVector* pMin, GRayTraceVector* pMax) = 0;
};




class GRayTraceSphere : public GRayTraceObject
{
protected:
	GRayTraceMaterial* m_pMaterial;
	GRayTraceVector m_center;
	GRayTraceReal m_radius;

public:
	GRayTraceSphere::GRayTraceSphere(GRayTraceMaterial* pMaterial, GRayTraceReal x, GRayTraceReal y, GRayTraceReal z, GRayTraceReal radius)
	: GRayTraceObject(), m_pMaterial(pMaterial), m_center(x, y, z), m_radius(radius)
	{
	}
	
	virtual GRayTraceSphere::~GRayTraceSphere()
	{
	}

	virtual ObjectType GetType() { return Sphere; }
	virtual GRayTraceMaterial* GetMaterial() { return m_pMaterial; }
	virtual GRayTraceReal ComputeRayDistance(GRayTraceVector* pRayOrigin, GRayTraceVector* pRayDirection);
	virtual void ComputeNormalVector(GRayTraceRay* pRay);
	virtual bool IsCulled() { return false; }
	virtual void GetCenter(GRayTraceVector* pOutPoint) { memcpy(pOutPoint, &m_center, sizeof(GRayTraceVector)); }
	virtual void AdjustBoundingBox(GRayTraceVector* pMin, GRayTraceVector* pMax);
	GRayTraceVector* GetCenter() { return &m_center; }
	GRayTraceReal GetRadius() { return m_radius; }
};






class GRayTraceTriangle : public GRayTraceObject
{
protected:
	GRayTraceTriMesh* m_pMesh;
	int m_nIndex;

public:
	GRayTraceTriangle(GRayTraceTriMesh* pMesh, int nIndex)
	: GRayTraceObject(), m_pMesh(pMesh), m_nIndex(nIndex)
	{
	}

	virtual ~GRayTraceTriangle()
	{
	}

	virtual ObjectType GetType() { return Triangle; }
	virtual GRayTraceReal ComputeRayDistance(GRayTraceVector* pRayOrigin, GRayTraceVector* pRayDirection);
	virtual void ComputeNormalVector(GRayTraceRay* pRay);
	virtual bool IsCulled() { return m_pMesh->IsCulled(); }
	virtual GRayTraceMaterial* GetMaterial() { return m_pMesh->GetMaterial(); }
	virtual void GetCenter(GRayTraceVector* pOutPoint);
	virtual void AdjustBoundingBox(GRayTraceVector* pMin, GRayTraceVector* pMax);
	GRayTraceVector* GetVertex(int nVertex);
};


#endif // __GRAYTRACE_H__