Given set of points that define faces of a convex solid is it possible to calculate its volume without any fancy stuff? (object can be defined aswell as set of planes that close the shape)

mhm that looks way too simpe i cant believe that would work.

 /** The implementation of this function is based on Graphics Gems 2, p. 170: "IV.1. Area of Planar Polygons and Volume of Polyhedra." */
 float Polyhedron::Volume() const
{
      float volume = 0.f;
        for(int i = 0; i < NumFaces(); ++i)
       {
                Polygon face = FacePolygon(i); ///@todo Optimize temporary copies.
                volume += face.Vertex(0).Dot(face.NormalCCW()) * face.Area();
       }
       return Abs(volume) / 3.f;
 }

i can't find for now any copy of this book but i have two questions first is

can i use NormalCW instead of NormalCCW (is this really a thing)

second thing why abs(volume) / 3 ? :P

The volume algorithm works by taking each face. Then we work in a space where the face is axis aligned. The dot product in this space gets the distance from the face plane to the origin (doesnt matter which vertex is used - theyre all on the same plane!).

The edge/area of the polygon is proportional to this origin-to-plane distance - its 0 at origin, full value at the plane end.

For 2D we integrate length of edge over this distance to get area. For 3D we integrate face area over the distance to get volume.

2D:

Integrate(0->1) edge*x dx (edge(x) = edge*x)

=> edge*x*x/2 (x = 1 for full area)

=> edge/2 (so in 2D youd divide by 2 instead of 3)

3D:

Integrate(0->1) area*x*x dx (area(x) = area*x*x because area grows/shrinks on 2 dimensions as x changes instead of just 1)

=> area*x*x*x/3 (x = 1 for full volume)

=> area/3 (so we divide by 3 in 3D)

I guess you can generalize it so it always divides by the amount of dimensions...

not sure if it works right but for 1x1x1 cube it gave me 1 so i assume its a good code

void CalculateFaceAreas()
{
 //call calc face center point
	FACE_AREA = new T[ FaceLength];
    for(int i = 0; i < FaceLength; ++i)
	{
		T area = T(0.0);
		
int ix 	= VBO_BE[ i ].INDEX_START;
int x 	= VBO_BE[ i ].INDEX_START + VBO_BE[ i ].length;
					   int len = VBO_BE[ i ].length;
					   int index1 	= ix;
for (int n = 0; n < len; n++)
	{
int index2 	= ix + n;
int index3 	= ix + n + 1;

if (n == len - 1) index3 = ix;

T a = n3ddistance( FACE_CENTER_POINT[i], AOS[ index2 ].v );
T b = n3ddistance( FACE_CENTER_POINT[i], AOS[ index3 ].v );
T c = n3ddistance( AOS[ index2 ].v, AOS[ index3 ].v );

T p = (a+b+c) / 2.0;

T r = sqrt(p*(p-a)*(p-b)*(p-c));

area = area + r;
if (n == len - 1) break;

	}

    	FACE_AREA[ i ] = T( int(area*10000.0) / 10000.0 );
    }

}

T CalculateVolume()
{
	//remember to call CalculateFaceAreas() before
     T volume = 0.f;
       for(int i = 0; i < FaceLength; ++i)
      {
int index = VBO_BE[ i ].INDEX_START;

float da = Dot( AOS[ index ].v, FACE_N[ i ] ) * FACE_AREA[ i ];

			   volume = volume + da;
      }
      return absnf(volume) / T(3.0);
}