Function EndObject3D

source/graphics.cpp:621–763

// ***********************************************************************

void EndObject3D() {
    if (pRenderState->mode == ERenderMode::None)  // TODO Call errors when this is incorrect
        return;

	DrawCommand cmd;

	i32 numIndices;
	cmd.type = pRenderState->typeState;
	cmd.cullMode = pRenderState->cullMode;
	bool buffersFilled = false;
    switch (pRenderState->typeState) {
        case EPrimitiveType::Points:
		case EPrimitiveType::Lines:
		case EPrimitiveType::LineStrip:
			break;
        case EPrimitiveType::Triangles: {
            if (pRenderState->normalsModeState == ENormalsMode::Flat) {
                for (i64 i = 0; i < pRenderState->vertexState.count; i += 3) {
                    Vec3f v1 = pRenderState->vertexState[i + 1].pos - pRenderState->vertexState[i].pos;
                    Vec3f v2 = pRenderState->vertexState[i + 2].pos - pRenderState->vertexState[i].pos;
                    Vec3f faceNormal = Vec3f::Cross(v1, v2).GetNormalized();

                    pRenderState->vertexState[i].norm = faceNormal;
                    pRenderState->vertexState[i + 1].norm = faceNormal;
                    pRenderState->vertexState[i + 2].norm = faceNormal;
                }

				u32 numVertices = (u32)pRenderState->vertexState.count;
				VertexData* pDestBuffer = pRenderState->perFrameVertexBuffer.pData + pRenderState->perFrameVertexBuffer.count;
				if (pRenderState->perFrameVertexBuffer.count + numVertices > MAX_VERTICES_PER_FRAME)
					return;
				memcpy(pDestBuffer, pRenderState->vertexState.pData, numVertices * sizeof(VertexData));

				cmd.vertexBufferOffset = (i32)pRenderState->perFrameVertexBuffer.count * sizeof(VertexData);
				cmd.numElements = numVertices;
				pRenderState->perFrameVertexBuffer.count += numVertices;
				buffersFilled = true;
            } else if (pRenderState->normalsModeState == ENormalsMode::Smooth) {
				// the purpose of this is to make same vertices share the same normal vector that gets averaged from the nearby polygons
                // Convert to indexed list, loop through, saving verts into vector, each new one you search for in vector, if you find it, save index in index list.

                ResizableArray<VertexData> uniqueVerts(g_pArenaFrame);
                ResizableArray<u16> indices(g_pArenaFrame);
                for (i64 i = 0; i < pRenderState->vertexState.count; i++) {
                    VertexData* pVertData = uniqueVerts.Find(pRenderState->vertexState[i]);
                    if (pVertData == uniqueVerts.end()) {
                        // New vertex
                        uniqueVerts.PushBack(pRenderState->vertexState[i]);
                        indices.PushBack((u16)uniqueVerts.count - 1);
                    } else {
                        indices.PushBack((u16)uniqueVerts.IndexFromPointer(pVertData));
                    }
                }

                // Then run your flat shading algo on the list of vertices looping through index list. If you have a new normal for a vert, then average with the existing one
                for (i64 i = 0; i < indices.count; i += 3) {
                    Vec3f v1 = uniqueVerts[indices[i + 1]].pos - uniqueVerts[indices[i]].pos;
                    Vec3f v2 = uniqueVerts[indices[i + 2]].pos - uniqueVerts[indices[i]].pos;