示例#1
0
        public void init(string text)
        {
            TgcBox box = new TgcBox();

            box.setExtremes(new Vector3(0, 0, 0), new Vector3(400, 2, 1000));
            box.Color = Color.Blue;
            box.updateValues();
            TgcMesh temp = box.toMesh("water");

            TgcSceneLoader loader = new TgcSceneLoader();

            //Configurar MeshFactory customizado
            loader.MeshFactory = new ShadedMeshFactory();
            mesh             = (ShadedMesh)loader.MeshFactory.createNewMesh(temp.D3dMesh, "water", TgcMesh.MeshRenderType.VERTEX_COLOR);
            mesh.BoundingBox = box.BoundingBox;
            mesh.loadEffect("Shaders//water.fx", "Basic");
            mesh.AutoUpdateBoundingBox = false;

            TgcTexture t_temp = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "RenderizameLaBanera\\waterbump.dds");//"perlin_noise.jpg");//"waterbump.dds");

            noise       = t_temp.D3dTexture;
            t_temp      = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "RenderizameLaBanera\\" + text);
            riverBottom = t_temp.D3dTexture;

            mesh.Effect.SetValue("xNoiseTex", noise);
            mesh.Effect.SetValue("xRiverBottom", riverBottom);

            Surface renderTarget = GuiController.Instance.D3dDevice.GetRenderTarget(0);

            riverReflex = new Texture(GuiController.Instance.D3dDevice, renderTarget.Description.Width, renderTarget.Description.Height, 1, Usage.RenderTarget, renderTarget.Description.Format, Pool.Default);
        }
示例#2
0
        public override void Update()
        {
            PreUpdate();

            //Si hacen clic con el mouse, ver si hay colision con el suelo
            if (Input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT))
            {
                //primera vez
                if (!selecting)
                {
                    //Actualizar Ray de colisión en base a posición del mouse
                    pickingRay.updateRay();

                    //Detectar colisión Ray-AABB
                    if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, suelo.BoundingBox, out initSelectionPoint))
                    {
                        selecting = true;
                        modelosSeleccionados.Clear();
                    }
                }

                //Si se está seleccionado, generar box de seleccion
                else
                {
                    //Detectar nuevo punto de colision con el piso
                    pickingRay.updateRay();
                    Vector3 collisionPoint;
                    if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, suelo.BoundingBox, out collisionPoint))
                    {
                        //Obtener extremos del rectángulo de selección
                        var min = Vector3.Minimize(initSelectionPoint, collisionPoint);
                        var max = Vector3.Maximize(initSelectionPoint, collisionPoint);
                        min.Y = 0;
                        max.Y = SELECTION_BOX_HEIGHT;

                        //Configurar BOX
                        selectionBox.setExtremes(min, max);
                        selectionBox.updateValues();
                    }
                }
            }

            //Solto el clic del mouse, terminar la selección
            if (Input.buttonUp(TgcD3dInput.MouseButtons.BUTTON_LEFT))
            {
                selecting = false;

                //Ver que modelos quedaron dentro del area de selección seleccionados
                foreach (var mesh in modelos)
                {
                    //Colisión de AABB entre área de selección y el modelo
                    if (TgcCollisionUtils.testAABBAABB(selectionBox.BoundingBox, mesh.BoundingBox))
                    {
                        modelosSeleccionados.Add(mesh);
                    }
                }
            }
        }
示例#3
0
        public void init(int x, int y, int z)
        {
            TgcBox box = new TgcBox();

            box.setExtremes(new Vector3(0, 0, 0), new Vector3(x, y, z));
            box.Color = Color.Brown;
            box.updateValues();
            TgcMesh temp = box.toMesh("earth");

            TgcSceneLoader loader = new TgcSceneLoader();

            //Configurar MeshFactory customizado
            loader.MeshFactory = new ShadedMeshFactory();
            mesh             = (ShadedMesh)loader.MeshFactory.createNewMesh(temp.D3dMesh, "earth", TgcMesh.MeshRenderType.VERTEX_COLOR);
            mesh.BoundingBox = box.BoundingBox;
            mesh.loadEffect("Shaders//hoja.fx", "Basic");

            TgcTexture tex_temp = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "RenderizameLaBanera\\sand.jpg");

            earthTex = tex_temp.D3dTexture;
            mesh.Effect.SetValue("xLeafTex", earthTex);
            mesh.AutoUpdateBoundingBox = false;
        }
示例#4
0
        /// <summary>
        /// Construir caja
        /// </summary>
        public override void doCreation()
        {
            TgcD3dInput input = GuiController.Instance.D3dInput;

            switch (currentCreatingState)
            {
            case CreatingBoxState.DraggingSize:

                //Si hacen clic con el mouse, ver si hay colision con el suelo
                if (input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT))
                {
                    //Determinar el size en XZ del box
                    Vector3 collisionPoint = Control.Grid.getPicking();

                    //Obtener extremos del rectángulo de selección
                    Vector3 min = Vector3.Minimize(initSelectionPoint, collisionPoint);
                    Vector3 max = Vector3.Maximize(initSelectionPoint, collisionPoint);
                    min.Y = initSelectionPoint.Y;
                    max.Y = initSelectionPoint.Y + 0.2f;

                    //Configurar BOX
                    mesh.setExtremes(min, max);
                    mesh.updateValues();
                }
                //Solto el clic del mouse, pasar a configurar el Height del box
                else if (input.buttonUp(TgcD3dInput.MouseButtons.BUTTON_LEFT))
                {
                    //Tiene el tamaño minimo tolerado
                    Vector3 size = mesh.BoundingBox.calculateSize();
                    if (size.X > 1 && size.Z > 1)
                    {
                        currentCreatingState  = CreatingBoxState.DraggingHeight;
                        creatingBoxInitMouseY = input.Ypos;
                    }
                    //Sino, descartar
                    else
                    {
                        Control.CurrentState = MeshCreatorControl.State.CreatePrimitiveSelected;
                        mesh.dispose();
                        mesh = null;
                    }
                }

                break;

            case CreatingBoxState.DraggingHeight:

                //Si presiona clic, terminar de configurar la altura y generar box definitivo
                if (input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
                {
                    //Guardar size original del Box para hacer Scaling
                    originalSize = mesh.BoundingBox.calculateSize();

                    //Dejar cargado para que se pueda crear un nuevo box
                    Control.CurrentState      = MeshCreatorControl.State.CreatePrimitiveSelected;
                    Control.CreatingPrimitive = new BoxPrimitive(Control);

                    //Agregar box a la lista de modelos
                    Control.addMesh(this);

                    //Seleccionar Box
                    Control.SelectionRectangle.clearSelection();
                    Control.SelectionRectangle.selectObject(this);
                    Control.updateModifyPanel();
                }
                //Determinar altura en base a la posicion Y del mouse
                else
                {
                    float heightY         = creatingBoxInitMouseY - input.Ypos;
                    float adjustedHeightY = MeshCreatorUtils.getMouseIncrementHeightSpeed(Control.Camera, this.BoundingBox, heightY);

                    Vector3 min = mesh.BoundingBox.PMin;
                    min.Y = initSelectionPoint.Y;
                    Vector3 max = mesh.BoundingBox.PMax;
                    max.Y = initSelectionPoint.Y + adjustedHeightY;

                    //Configurar BOX
                    mesh.setExtremes(min, max);
                    mesh.updateValues();
                }

                break;
            }
        }