/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2025 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
* Sample CreatePRCCubes
* file CreateModelFile.cpp
* This file is containing the data and function used to create PRC Model file.
*
***********************************************************************************************************************/
#include "CreateModelFile.h"

#include "CreateTessellatedCubes.h"

#include "modules/CreateMarkups.h"
#include "modules/CreateTextures.h"
#include "modules/CreateViews.h"


#include <cstdlib>
#include <string>
#include <vector>


//######################################################################################################################
A3DStatus createCubeTessellation(A3DTess3D** ppTess3D, A3DUns32* puiStyleIndex)
{
	A3DStatus iRet = A3D_SUCCESS;

	// create a cube tessellation
	A3DTess3DData sTess3DData;
	fillCubeTessData(sTess3DData, puiStyleIndex);
	CHECK_RET(A3DTess3DCreate(&sTess3DData, ppTess3D));
	freeTess3DData(sTess3DData);

	A3DTessBaseData sTessBaseData;
	fillCubeTessBaseData(sTessBaseData, CUBE_WIDTH, CUBE_HEIGHT, CUBE_LENGTH);
	CHECK_RET(A3DTessBaseSet(*ppTess3D, &sTessBaseData));
	freeTessBaseData(sTessBaseData);

	return iRet;
}


//######################################################################################################################
A3DStatus createPolyBREPModel(A3DRiPolyBrepModel** ppPolyBREP, A3DTess3D* pTess3D)
{
	A3DStatus iRet = A3D_SUCCESS;

	A3DRiPolyBrepModelData sPolyBrepModelData;
	A3D_INITIALIZE_DATA(A3DRiPolyBrepModelData, sPolyBrepModelData);
	sPolyBrepModelData.m_bIsClosed = TRUE;
	CHECK_RET(A3DRiPolyBrepModelCreate(&sPolyBrepModelData, ppPolyBREP));

	// assign the cube tessellation to the PolyBrepModel
	A3DRiRepresentationItemData sRiData;
	A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRiData);
	sRiData.m_pTessBase = pTess3D;
	sRiData.m_pCoordinateSystem = NULL;
	CHECK_RET(A3DRiRepresentationItemSet(*ppPolyBREP, &sRiData));

	return iRet;
}

A3DStatus createPart(A3DAsmPartDefinition** ppPartDef, A3DRiRepresentationItem** ppRIs, A3DUns32 uiRepItemsSize)
{
	A3DStatus iRet = A3D_SUCCESS;

	A3DAsmPartDefinitionData sPartDefinitionData;
	A3D_INITIALIZE_DATA(A3DAsmPartDefinitionData, sPartDefinitionData);
	sPartDefinitionData.m_uiRepItemsSize = uiRepItemsSize;
	sPartDefinitionData.m_ppRepItems = ppRIs;
	sPartDefinitionData.m_uiAnnotationsSize = 0;
	CHECK_RET(A3DAsmPartDefinitionCreate(&sPartDefinitionData, ppPartDef));

	return iRet;
}

//######################################################################################################################
// Create uiPrototypesSize prototypes of the instance PO pInstance.
A3DStatus createAssemblyTree(A3DAsmProductOccurrence* pInstance, A3DUns32 uiPrototypesSize, A3DAsmProductOccurrence*** pppPrototypes)
{
	A3DStatus iRet = A3D_SUCCESS;

	A3DAsmProductOccurrence** ppPrototypes = new A3DAsmProductOccurrence*[uiPrototypesSize];
	*pppPrototypes = ppPrototypes;

	setEntityName(pInstance, "Instance");
	A3DMiscAttribute* pAttribute = 0;
	A3DMiscAttributeData sAttributeData;
	A3D_INITIALIZE_DATA(A3DMiscAttributeData, sAttributeData);
	sAttributeData.m_pcTitle = (A3DUTF8Char *)"Instance PO, holding data.";
	CHECK_RET(A3DMiscAttributeCreate(&sAttributeData, &pAttribute));
	addEntityAttributes(pInstance, 1, &pAttribute);

    A3DEntityDelete(pAttribute);

	// New PO with prototype
	A3DAsmProductOccurrenceData sPrototypePOData;
	A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sPrototypePOData);
	sPrototypePOData.m_pPrototype = pInstance; // populating the PO Data Structure with the prototype

	for (A3DUns32 i = 0; i < uiPrototypesSize; ++i)
	{
		if (i > 0)
		{
			// create new location (color can also be modify)
			A3DMiscCartesianTransformation* newLocation = NULL;
			A3DMiscCartesianTransformationData newLocationData;
			A3D_INITIALIZE_DATA(A3DMiscCartesianTransformationData, newLocationData);
			newLocationData.m_sOrigin.m_dX = i * CUBE_SPACING;
			newLocationData.m_sOrigin.m_dY = i * CUBE_SPACING;
			newLocationData.m_sOrigin.m_dZ = i * CUBE_SPACING;

			newLocationData.m_sScale.m_dX = 1;
			newLocationData.m_sScale.m_dY = 1;
			newLocationData.m_sScale.m_dZ = 1;

			newLocationData.m_sXVector.m_dX = 1.0;
			newLocationData.m_sXVector.m_dY = 0.0;
			newLocationData.m_sXVector.m_dZ = 0.0;

			newLocationData.m_sYVector.m_dX = 0.0;
			newLocationData.m_sYVector.m_dY = 1.0;
			newLocationData.m_sYVector.m_dZ = 0.0;
			newLocationData.m_ucBehaviour = kA3DTransformationTranslate | kA3DTransformationRotate;

			A3DMiscCartesianTransformationCreate(&newLocationData, &newLocation);

			// populating the PO Data Structure with the location
			sPrototypePOData.m_pLocation = newLocation;
		}
		// create PO from PO Data structure
		A3DAsmProductOccurrenceCreate(&sPrototypePOData, &ppPrototypes[i]);

		// add Base Info to enable graphics behaviors.
		A3DRootBaseData sBaseData;
		A3D_INITIALIZE_DATA(A3DRootBaseData, sBaseData);
		CHECK_RET(A3DRootBaseSet(ppPrototypes[i], &sBaseData));

		// sample name
		CHECK_RET(setEntityName(ppPrototypes[i], "Prototype"));

		// sample attribute
		A3DMiscAttribute* pProtoAttribute=nullptr;
		A3DMiscAttributeData sProtoAttributeData;
		A3D_INITIALIZE_DATA(A3DMiscAttributeData, sProtoAttributeData);
		sProtoAttributeData.m_pcTitle = (A3DUTF8Char *)"Prototype PO to an instance PO.";
		CHECK_RET(A3DMiscAttributeCreate(&sProtoAttributeData, &pProtoAttribute));

		CHECK_RET(addEntityAttributes(ppPrototypes[i], 1, &pProtoAttribute));
        A3DEntityDelete(pProtoAttribute);
	}

	// we set the last cube blue, redefining the texture graphics
	setEntityColor(ppPrototypes[uiPrototypesSize - 1], BLUE, 0.5);

	return iRet;
}


//######################################################################################################################
A3DStatus createFileMarkups(A3DMkpAnnotationItem** ppOutAnnotationsSet,
                            A3DUns32 uiPrototypesSize, A3DAsmProductOccurrence** ppPrototypes,
                            A3DRiPolyBrepModel* pRiPolyBrepModel)
{
	A3DStatus iRet = A3D_SUCCESS;

    std::vector<A3DMkpAnnotationItem*> vpAnnotations;

    A3DMkpAnnotationItem* pNewAnnotation = 0;

    A3DAsmProductOccurrence* pCurrentPO = 0;
	A3DUns32 uiPOCurrentIndex = 0;

    // ------------------------------------------------------------------
    // initialize markups position.
    A3DVector3dData sAnnotationLeaderPos;
    A3D_INITIALIZE_DATA(A3DVector3dData, sAnnotationLeaderPos);
    A3DVector3dData sAnnotationLeaderPosOffset;
    A3D_INITIALIZE_DATA(A3DVector3dData, sAnnotationLeaderPosOffset);
    sAnnotationLeaderPosOffset.m_dX = 0;
    sAnnotationLeaderPosOffset.m_dY = 0;
    sAnnotationLeaderPosOffset.m_dZ = CUBE_HEIGHT;

    A3DVector3dData sAnnotationFramePos;
    A3D_INITIALIZE_DATA(A3DVector3dData, sAnnotationFramePos);
    A3DVector3dData sAnnotationFramePosOffset;
    A3D_INITIALIZE_DATA(A3DVector3dData, sAnnotationFramePosOffset);
    sAnnotationFramePosOffset.m_dX = 1 * CUBE_WIDTH;
    sAnnotationFramePosOffset.m_dY = 1 * CUBE_LENGTH;
    sAnnotationFramePosOffset.m_dZ = 2 * CUBE_HEIGHT;


    // ------------------------------------------------------------------
    // simple markup
	A3DUTF8Char *pcTextSimpleMarkup = (A3DUTF8Char *)"Simple";

    pCurrentPO = ppPrototypes[uiPOCurrentIndex];
    ++uiPOCurrentIndex;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationLeaderPos));
    sAnnotationLeaderPos.m_dX += sAnnotationLeaderPosOffset.m_dX;
    sAnnotationLeaderPos.m_dY += sAnnotationLeaderPosOffset.m_dY;
    sAnnotationLeaderPos.m_dZ += sAnnotationLeaderPosOffset.m_dZ;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationFramePos));
    sAnnotationFramePos.m_dX += sAnnotationFramePosOffset.m_dX;
    sAnnotationFramePos.m_dY += sAnnotationFramePosOffset.m_dY;
    sAnnotationFramePos.m_dZ += sAnnotationFramePosOffset.m_dZ;

    CHECK_RET(createMarkup(&pNewAnnotation,
                           pcTextSimpleMarkup,
                           1,
                           &pRiPolyBrepModel,
                           &pCurrentPO,
                           &sAnnotationFramePos,
                           &sAnnotationLeaderPos));

    vpAnnotations.push_back(pNewAnnotation);

    // ------------------------------------------------------------------
	// Markup on a face
	A3DUTF8Char *pcTextOnFace = (A3DUTF8Char *)"Face";

    pCurrentPO = ppPrototypes[uiPOCurrentIndex];
    ++uiPOCurrentIndex;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationLeaderPos));
    sAnnotationLeaderPos.m_dX += sAnnotationLeaderPosOffset.m_dX;
    sAnnotationLeaderPos.m_dY += sAnnotationLeaderPosOffset.m_dY;
    sAnnotationLeaderPos.m_dZ += sAnnotationLeaderPosOffset.m_dZ;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationFramePos));
    sAnnotationFramePos.m_dX += sAnnotationFramePosOffset.m_dX;
    sAnnotationFramePos.m_dY += sAnnotationFramePosOffset.m_dY;
    sAnnotationFramePos.m_dZ += sAnnotationFramePosOffset.m_dZ;

    A3DUns32 uiFaceIndex = 0;
    CHECK_RET(createMarkupOnFace(&pNewAnnotation,
                                 pcTextOnFace,
                                 1,
                                 &pRiPolyBrepModel,
                                 &pCurrentPO,
                                 &uiFaceIndex,
                                 &sAnnotationFramePos,
                                 &sAnnotationLeaderPos));

    vpAnnotations.push_back(pNewAnnotation);

    // ------------------------------------------------------------------
	// Markup parrallel to screen
	A3DUTF8Char *pcTextParallel = (A3DUTF8Char *)"Parallel";

    pCurrentPO = ppPrototypes[uiPOCurrentIndex];
    ++uiPOCurrentIndex;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationFramePos));
    sAnnotationFramePos.m_dX += sAnnotationFramePosOffset.m_dX;
    sAnnotationFramePos.m_dY += sAnnotationFramePosOffset.m_dY;
    sAnnotationFramePos.m_dZ += sAnnotationFramePosOffset.m_dZ;

    CHECK_RET(createMarkupFaceToScreen(&pNewAnnotation,
                                       pcTextParallel,
                                       1,
                                       &pRiPolyBrepModel,
                                       &pCurrentPO,
                                       &sAnnotationFramePos));

    vpAnnotations.push_back(pNewAnnotation);

    // ------------------------------------------------------------------
	// Markup non Zoomable
    A3DUTF8Char *pcTextZoomable = (A3DUTF8Char *)"Non zoomable";

    pCurrentPO = ppPrototypes[uiPOCurrentIndex];
    ++uiPOCurrentIndex;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationFramePos));
    sAnnotationFramePos.m_dX += sAnnotationFramePosOffset.m_dX;
    sAnnotationFramePos.m_dY += sAnnotationFramePosOffset.m_dY;
    sAnnotationFramePos.m_dZ += sAnnotationFramePosOffset.m_dZ;

    CHECK_RET(createMarkupFaceToScreen(&pNewAnnotation,
                                       pcTextZoomable,
                                       1,
                                       &pRiPolyBrepModel,
                                       &pCurrentPO,
                                       &sAnnotationFramePos,
                                       FlatToScreenNonZoomable));

    vpAnnotations.push_back(pNewAnnotation);

    // ------------------------------------------------------------------
	// Markup non Zoomable
    A3DUTF8Char *pcTextAttached = (A3DUTF8Char *)"OnTop";

    pCurrentPO = ppPrototypes[uiPOCurrentIndex];
    ++uiPOCurrentIndex;

    CHECK_RET(getPOLocationOrigin(pCurrentPO, &sAnnotationFramePos));
    sAnnotationFramePos.m_dX += sAnnotationFramePosOffset.m_dX;
    sAnnotationFramePos.m_dY += sAnnotationFramePosOffset.m_dY;
    sAnnotationFramePos.m_dZ += sAnnotationFramePosOffset.m_dZ;

    CHECK_RET(createMarkupFaceToScreen(&pNewAnnotation,
                                       pcTextAttached,
                                       1,
                                       &pRiPolyBrepModel,
                                       &pCurrentPO,
                                       &sAnnotationFramePos,
                                       FlatToScreenAlwaysOnTop));

    vpAnnotations.push_back(pNewAnnotation);

    // ------------------------------------------------------------------
    // Highlight all prototypes passed
    A3DUTF8Char *pcTextHighlightAll = (A3DUTF8Char *)"Highlight All";
    A3DVector3dData sHighlightAllPos;
    A3D_INITIALIZE_DATA(A3DVector3dData, sHighlightAllPos);
    sHighlightAllPos.m_dX = -4 * CUBE_WIDTH;
    sHighlightAllPos.m_dY = -4 * CUBE_LENGTH;
    sHighlightAllPos.m_dZ = -4 * CUBE_HEIGHT;

    std::vector<A3DEntity*> vpLinkedEntity;
    std::vector<A3DAsmProductOccurrence*> vpPOTarget;
    for (A3DUns32 i = 0; i < uiPrototypesSize; ++i)
    {
        vpLinkedEntity.push_back(pRiPolyBrepModel);
        vpPOTarget.push_back(ppPrototypes[i]);
    }

    CHECK_RET(createMarkupFaceToScreen(&pNewAnnotation,
                                       pcTextHighlightAll,
                                       uiPrototypesSize,
                                       &vpLinkedEntity[0],
                                       &vpPOTarget[0],
                                       &sHighlightAllPos));
    
    vpAnnotations.push_back(pNewAnnotation);
    vpLinkedEntity.clear();
    vpPOTarget.clear();


    // ------------------------------------------------------------------
	// Create a Markup Set and add markups in it
	A3DMkpAnnotationSetData sAnnotationSetData;
	A3D_INITIALIZE_DATA(A3DMkpAnnotationSetData, sAnnotationSetData);
	sAnnotationSetData.m_uiAnnotationsSize = (A3DUns32)vpAnnotations.size();
	sAnnotationSetData.m_ppAnnotations = &(vpAnnotations[0]);
	CHECK_RET(A3DMkpAnnotationSetCreate(&sAnnotationSetData, ppOutAnnotationsSet));
    vpAnnotations.clear();

	return iRet;
}

//######################################################################################################################
A3DStatus createFileViews(A3DUns32* puiOutMkpViewSize, A3DMkpView*** pppOutMkpViews,
    A3DUns32 uiPrototypesSize, A3DAsmProductOccurrence** ppPrototypes,
    A3DUns32 uiAnnotationSize, A3DMkpAnnotationItem** ppMkpAnnotationItem,
    A3DRiPolyBrepModel* pRiPolyBrepModel)
{
    A3DStatus iRet = A3D_SUCCESS;

    std::vector<A3DMkpView*> vpMkpViews;
    *puiOutMkpViewSize = 0;

    A3DVector3dData sCameraPos;
    A3DVector3dData sCameraLookAt;

    // ------------------------------------------------------------------
    // "A View With A Camera"
    A3D_INITIALIZE_DATA(A3DVector3dData, sCameraPos);
    sCameraPos.m_dX = stCameraPosDefault.m_dX;
    sCameraPos.m_dY = stCameraPosDefault.m_dY;
    sCameraPos.m_dZ = stCameraPosDefault.m_dZ;

    A3D_INITIALIZE_DATA(A3DVector3dData, sCameraLookAt);
    sCameraLookAt.m_dX = stCameraLookAtDefault.m_dX;
    sCameraLookAt.m_dY = stCameraLookAtDefault.m_dY;
    sCameraLookAt.m_dZ = stCameraLookAtDefault.m_dZ;

    A3DMkpView* pMkpViewWithCamera = 0;
    A3DMkpViewData sMkpViewWithCamera;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewWithCamera);
    CHECK_RET(setViewCameraPlacement(&sMkpViewWithCamera, &sCameraPos, &sCameraLookAt, -1, -1));

    CHECK_RET(createView(&pMkpViewWithCamera, &sMkpViewWithCamera, "Define New Camera"));

    vpMkpViews.push_back(pMkpViewWithCamera);

    // ------------------------------------------------------------------
    // "A View That Hide Objects"
    A3DAsmProductOccurrence* ppPOsToHide[3];
    ppPOsToHide[0] = ppPrototypes[0];
    ppPOsToHide[1] = ppPrototypes[2];
    ppPOsToHide[2] = ppPrototypes[4];

    A3DRootBaseWithGraphicsData sRootBaseWithGraphicsHiddenData;
    A3D_INITIALIZE_DATA(A3DRootBaseWithGraphicsData, sRootBaseWithGraphicsHiddenData);
    CHECK_RET(setGraphicsHidden(&sRootBaseWithGraphicsHiddenData));

    A3DMkpViewData sMkpViewHidingObjects;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewHidingObjects);
    CHECK_RET(setViewEntitiesGraphics(&sMkpViewHidingObjects, 3, ppPOsToHide, &sRootBaseWithGraphicsHiddenData));
    CHECK_RET(A3DGraphicsDelete(sRootBaseWithGraphicsHiddenData.m_pGraphics));

    A3DMkpView* pMkpViewHidingObjects = 0;
    CHECK_RET(createView(&pMkpViewHidingObjects, &sMkpViewHidingObjects, "Hide Objects"));
    vpMkpViews.push_back(pMkpViewHidingObjects);
    free(sMkpViewHidingObjects.m_ppLinkedItems);

    // ------------------------------------------------------------------
    // "A View That Change Objects Color"

    A3DAsmProductOccurrence* ppPOsToChangeColor[2];
    ppPOsToChangeColor[0] = ppPrototypes[1];
    ppPOsToChangeColor[1] = ppPrototypes[3];

    A3DRootBaseWithGraphicsData sRootBaseWithGraphicsYellowColorData;
    A3D_INITIALIZE_DATA(A3DRootBaseWithGraphicsData, sRootBaseWithGraphicsYellowColorData);
    CHECK_RET(setGraphicsColor(&sRootBaseWithGraphicsYellowColorData, YELLOW, 1.0));

    A3DMkpViewData sMkpViewChangingObjectColor;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewChangingObjectColor);
    CHECK_RET(setViewEntitiesGraphics(&sMkpViewChangingObjectColor, 2, ppPOsToChangeColor, &sRootBaseWithGraphicsYellowColorData));
    CHECK_RET(A3DGraphicsDelete(sRootBaseWithGraphicsYellowColorData.m_pGraphics));

    A3DMkpView* pMkpViewChangingObjectColor = 0;
    CHECK_RET(createView(&pMkpViewChangingObjectColor, &sMkpViewChangingObjectColor, "Change Objects Color"));
    vpMkpViews.push_back(pMkpViewChangingObjectColor);
    free(sMkpViewChangingObjectColor.m_ppLinkedItems);

    // ------------------------------------------------------------------
    // "A View That Change Face Color"
    A3DMiscMarkupLinkedItem* pMarkupLinkedItem = NULL;
    A3DUns32 faceindex[1];
    faceindex[0] = 0;
    CHECK_RET(createMarkupLinkedItemOnTess(pRiPolyBrepModel, kA3DTypeTessFace, 1, faceindex, ppPrototypes[2], &pMarkupLinkedItem));

    A3DMiscMarkupLinkedItem* ppLinkedItemsToChangeColorOnFace[1];
    ppLinkedItemsToChangeColorOnFace[0] = pMarkupLinkedItem;

    A3DRootBaseWithGraphicsData sRootBaseWithGraphicsGreenColorData;
    A3D_INITIALIZE_DATA(A3DRootBaseWithGraphicsData, sRootBaseWithGraphicsGreenColorData);
    CHECK_RET(setGraphicsColor(&sRootBaseWithGraphicsGreenColorData, GREEN, 1.0));
    CHECK_RET(A3DRootBaseWithGraphicsSet(ppLinkedItemsToChangeColorOnFace[0], &sRootBaseWithGraphicsGreenColorData));
    CHECK_RET(A3DGraphicsDelete(sRootBaseWithGraphicsGreenColorData.m_pGraphics));

    A3DMkpViewData sMkpViewChangingFaceColor;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewChangingFaceColor);
    CHECK_RET(addViewLinkedItem(&sMkpViewChangingFaceColor, 1, ppLinkedItemsToChangeColorOnFace));

    A3DMkpView* pMkpViewChangingFaceColor = 0;
    CHECK_RET(createView(&pMkpViewChangingFaceColor, &sMkpViewChangingFaceColor, "Change Face Color"));
    vpMkpViews.push_back(pMkpViewChangingFaceColor);
    free(sMkpViewChangingFaceColor.m_ppLinkedItems);

    // ------------------------------------------------------------------
    // "A View With Visible Annotation"
    A3DMkpAnnotationItem* ppAnnotations[2];
    ppAnnotations[0] = ppMkpAnnotationItem[1];
    ppAnnotations[1] = ppMkpAnnotationItem[2];

    A3DMkpViewData sMkpViewWithAnnotation;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewWithAnnotation);
    CHECK_RET(setViewAnnotations(&sMkpViewWithAnnotation, 2, ppAnnotations));

    A3DMkpView* pMkpViewWithAnnotation = 0;
    CHECK_RET(createView(&pMkpViewWithAnnotation, &sMkpViewWithAnnotation, "Visible Annotation"));
    vpMkpViews.push_back(pMkpViewWithAnnotation);

    // ------------------------------------------------------------------
    // "A View With That Change Object Position"
    A3DMiscCartesianTransformation* ppTransformations[3];
	A3DMiscCartesianTransformationData sTransformationData;
	A3D_INITIALIZE_DATA(A3DMiscCartesianTransformationData, sTransformationData);
	sTransformationData.m_sOrigin.m_dX = CUBE_SPACING + CUBE_SPACING;
	sTransformationData.m_sOrigin.m_dY = CUBE_SPACING;
	sTransformationData.m_sOrigin.m_dZ = CUBE_SPACING;
	sTransformationData.m_sXVector.m_dX = 1.;
	sTransformationData.m_sXVector.m_dY = 0.;
	sTransformationData.m_sXVector.m_dZ = 0.;
	sTransformationData.m_sYVector.m_dX = 0.;
	sTransformationData.m_sYVector.m_dY = 1.;
	sTransformationData.m_sYVector.m_dZ = 0.;
	sTransformationData.m_sScale.m_dX = 1.;
	sTransformationData.m_sScale.m_dY = 1.;
	sTransformationData.m_sScale.m_dZ = 1.;
	CHECK_RET(A3DMiscCartesianTransformationCreate(&sTransformationData, &ppTransformations[0]));
    CHECK_RET(A3DMiscCartesianTransformationCreate(&sTransformationData, &ppTransformations[1]));
    CHECK_RET(A3DMiscCartesianTransformationCreate(&sTransformationData, &ppTransformations[2]));

	A3DAsmProductOccurrence* ppPOsToChangePos[3];
	ppPOsToChangePos[0] = ppPrototypes[0];
	ppPOsToChangePos[1] = ppPrototypes[1];
	ppPOsToChangePos[2] = ppPrototypes[2];

    A3DMkpViewData sMkpViewChangeObjectPos;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewChangeObjectPos);
    CHECK_RET(setViewEntitiesOffsetPosition(&sMkpViewChangeObjectPos, 3, ppPOsToChangePos, ppTransformations));
    A3DEntityDelete(ppTransformations[0]);
    A3DEntityDelete(ppTransformations[1]);
    A3DEntityDelete(ppTransformations[2]);

    A3DMkpView* pMkpViewChangeObjectPos = 0;
    CHECK_RET(createView(&pMkpViewChangeObjectPos, &sMkpViewChangeObjectPos, "Change Object Position"));
    vpMkpViews.push_back(pMkpViewChangeObjectPos);
    free(sMkpViewChangeObjectPos.m_ppLinkedItems);

	// ------------------------------------------------------------------
	// "Default View with Camera and all annotations"
	A3D_INITIALIZE_DATA(A3DVector3dData, sCameraPos);
	sCameraPos.m_dX = 0;
	sCameraPos.m_dY = 0;
	sCameraPos.m_dZ = uiPrototypesSize * (CUBE_LENGTH + CUBE_SPACING);

	A3D_INITIALIZE_DATA(A3DVector3dData, sCameraLookAt);
	sCameraLookAt.m_dX = uiPrototypesSize * (CUBE_WIDTH + CUBE_SPACING) / 2.;
	sCameraLookAt.m_dY = uiPrototypesSize * (CUBE_HEIGHT + CUBE_SPACING) / 2.;
	sCameraLookAt.m_dZ = uiPrototypesSize * CUBE_LENGTH;

	A3DDouble dXFovy = (uiPrototypesSize +1) * (CUBE_WIDTH + CUBE_SPACING) / 2.;
	A3DDouble dYFovy = (uiPrototypesSize +1) * (CUBE_HEIGHT + CUBE_SPACING) / 2.;

    A3DMkpViewData sMkpViewDefault;
    A3D_INITIALIZE_DATA(A3DMkpViewData, sMkpViewDefault);
    CHECK_RET(setViewCameraPlacement(&sMkpViewDefault, &sCameraPos, &sCameraLookAt, dXFovy, dYFovy));
    CHECK_RET(setViewAnnotations(&sMkpViewDefault, uiAnnotationSize, ppMkpAnnotationItem));

    A3DMkpView* pMkpViewDefault = 0;
    CHECK_RET(createView(&pMkpViewDefault, &sMkpViewDefault, "Default View"));
    vpMkpViews.push_back(pMkpViewDefault);


	// ------------------------------------------------------------------
	// copy view vector
	*puiOutMkpViewSize = (A3DUns32)vpMkpViews.size();
	A3DMkpView** ppMkpViews = new A3DMkpView*[vpMkpViews.size()];
	for (A3DUns32 i = 0; i < (A3DUns32)vpMkpViews.size(); ++i)
	{
		ppMkpViews[i] = vpMkpViews[i];
	}
	*pppOutMkpViews = ppMkpViews;


	return iRet;
}

//######################################################################################################################
A3DStatus createPRCCubesFile(A3DAsmModelFile** ppModelFile, const A3DUTF8Char* pcTextureFilePath = NULL)
{
	A3DStatus iRet = A3D_SUCCESS;

    // ------------------------------------------------------------------
    // create Texture if needed
	A3DUns32 uiStyleIndex = A3D_DEFAULT_STYLE_INDEX;		// will become the texture index

	if (pcTextureFilePath != NULL)
	{
		// the picture width and height are read from the image (for supported image types),
		// and since we don't know them, width and height can be 0
		iRet = createTexture(pcTextureFilePath, kA3DPictureJpg, 0, 0, uiStyleIndex); // JPG
																					 //iRet = createTexture(pcTextureFilePath, kA3DPicturePng, 0, 0, uiStyleIndex); // PNG
	}

    // ------------------------------------------------------------------
	// create a cube tessellation
	A3DTess3D* pTess3D = NULL;
	CHECK_RET(createCubeTessellation(&pTess3D, &uiStyleIndex));

    // ------------------------------------------------------------------
	// create a PolyBrepModel representation item
	A3DRiPolyBrepModel *pRiPolyBrepModel = NULL;
	CHECK_RET(createPolyBREPModel(&pRiPolyBrepModel, pTess3D));

    // ------------------------------------------------------------------
	// create a PartDefinition to hold the PolyBrepModel and markups
	A3DAsmPartDefinition *pPartDefinition = NULL;
	CHECK_RET(createPart(&pPartDefinition, &pRiPolyBrepModel, 1));

    // ------------------------------------------------------------------
	// create a ProductOccurrence to stock the Part Definition
	A3DAsmProductOccurrence* pPO = NULL;
	A3DAsmProductOccurrenceData sPOData;
	A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sPOData);
	sPOData.m_pPart = pPartDefinition;
	CHECK_RET(A3DAsmProductOccurrenceCreate(&sPOData, &pPO));

    // ------------------------------------------------------------------
	// Create Prototypes
	// Create N PO using previous PO as prototype
	A3DUns32 uiPOSize = 6;
	A3DAsmProductOccurrence** ppPOs = 0;

	CHECK_RET(createAssemblyTree(pPO, uiPOSize, &ppPOs));

    // ------------------------------------------------------------------
	// create Markups
	A3DMkpAnnotationItem* pMkpAnnotationSet = 0;
	CHECK_RET(createFileMarkups(&pMkpAnnotationSet, uiPOSize, ppPOs, pRiPolyBrepModel));

    // ------------------------------------------------------------------
	// create Views
	A3DUns32 uiMkpViewsSize = 0;
	A3DMkpView** ppMkpViews = 0;
    A3DMkpAnnotationSetData sAnnotationSetData;
    A3D_INITIALIZE_DATA(A3DMkpAnnotationSetData, sAnnotationSetData);
    CHECK_RET(A3DMkpAnnotationSetGet(pMkpAnnotationSet, &sAnnotationSetData));
	CHECK_RET(createFileViews(&uiMkpViewsSize, &ppMkpViews,
                              uiPOSize, ppPOs,
                              sAnnotationSetData.m_uiAnnotationsSize, sAnnotationSetData.m_ppAnnotations,
                              pRiPolyBrepModel));
    CHECK_RET(A3DMkpAnnotationSetGet(nullptr,&sAnnotationSetData));
    // ------------------------------------------------------------------
	// create the Root Product Occurrence.
	A3DAsmProductOccurrence* pSubAsm = NULL;
	A3DAsmProductOccurrenceData sSubAsmData;
	A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sSubAsmData);
	sSubAsmData.m_uiPOccurrencesSize = uiPOSize;
	sSubAsmData.m_ppPOccurrences = ppPOs;
	if (pMkpAnnotationSet)
	{
		sSubAsmData.m_uiAnnotationsSize = 1;
		sSubAsmData.m_ppAnnotations = &pMkpAnnotationSet;
	}
	sSubAsmData.m_uiViewsSize = uiMkpViewsSize;
	sSubAsmData.m_ppViews = ppMkpViews;
	CHECK_RET(A3DAsmProductOccurrenceCreate(&sSubAsmData, &pSubAsm));

	// delete allocated datas
	if (uiPOSize != 0) delete ppPOs;
	if (uiMkpViewsSize != 0) delete ppMkpViews;

    // ------------------------------------------------------------------
	// Insertion of the whole product structure in the modelfile
	A3DAsmModelFileData sData;
	A3D_INITIALIZE_DATA(A3DAsmModelFileData, sData);
	sData.m_uiPOccurrencesSize = 1;
	sData.m_dUnit = 1.0;
	sData.m_ppPOccurrences = &pSubAsm;
	CHECK_RET(A3DAsmModelFileCreate(&sData, ppModelFile));

	return iRet;
}