Esempio n. 1
0
        private void generateGizmoParts()
        {
            //Translation Gizmo
            GMDL.Primitives.Arrow translation_x_axis = new GMDL.Primitives.Arrow(0.015f, 0.25f, new Vector3(1.0f, 0.0f, 0.0f), false, 20);
            //Move arrowhead up in place
            Matrix4 t = Matrix4.CreateRotationZ(MathUtils.radians(90));

            translation_x_axis.applyTransform(t);

            GMDL.Primitives.Arrow translation_y_axis = new GMDL.Primitives.Arrow(0.015f, 0.25f, new Vector3(0.0f, 1.0f, 0.0f), false, 20);
            GMDL.Primitives.Arrow translation_z_axis = new GMDL.Primitives.Arrow(0.015f, 0.25f, new Vector3(0.0f, 0.0f, 1.0f), false, 20);
            t = Matrix4.CreateRotationX(MathUtils.radians(90));
            translation_z_axis.applyTransform(t);

            //Generate Geom objects
            translation_x_axis.geom = translation_x_axis.getGeom();
            translation_y_axis.geom = translation_y_axis.getGeom();
            translation_z_axis.geom = translation_z_axis.getGeom();


            GLPrimitiveVaos["default_translation_gizmo_x_axis"] = translation_x_axis.getVAO();
            GLPrimitiveVaos["default_translation_gizmo_y_axis"] = translation_y_axis.getVAO();
            GLPrimitiveVaos["default_translation_gizmo_z_axis"] = translation_z_axis.getVAO();


            //Generate PrimitiveMeshVaos
            for (int i = 0; i < 3; i++)
            {
                string name = "";
                GMDL.Primitives.Primitive arr = null;
                switch (i)
                {
                case 0:
                    arr  = translation_x_axis;
                    name = "default_translation_gizmo_x_axis";
                    break;

                case 1:
                    arr  = translation_y_axis;
                    name = "default_translation_gizmo_y_axis";
                    break;

                case 2:
                    arr  = translation_z_axis;
                    name = "default_translation_gizmo_z_axis";
                    break;
                }

                GLPrimitiveMeshVaos[name]                        = new GLMeshVao();
                GLPrimitiveMeshVaos[name].type                   = TYPES.GIZMOPART;
                GLPrimitiveMeshVaos[name].metaData               = new MeshMetaData();
                GLPrimitiveMeshVaos[name].metaData.batchcount    = arr.geom.indicesCount;
                GLPrimitiveMeshVaos[name].metaData.indicesLength = DrawElementsType.UnsignedInt;
                GLPrimitiveMeshVaos[name].vao                    = GLPrimitiveVaos[name];
                GLPrimitiveMeshVaos[name].material               = GLmaterials["crossMat"];
            }
        }
Esempio n. 2
0
        public void generateMeshVao()
        {
            geom = getGeom();

            meshVao                        = new GLMeshVao();
            meshVao.type                   = TYPES.TEXT;
            meshVao.metaData               = new MeshMetaData();
            meshVao.metaData.batchcount    = geom.indicesCount;
            meshVao.metaData.indicesLength = DrawElementsType.UnsignedInt;
            meshVao.vao                    = geom.generateVAO();
            meshVao.material               = new Material(); //TODO use a material from the font

            //Add instance
            GLMeshBufferManager.addInstance(meshVao, null,
                                            Matrix4.Identity, Matrix4.Identity, Matrix4.Identity);
        }
Esempio n. 3
0
        public void addDefaultPrimitives()
        {
            //Setup Primitive Vaos

            //Default quad
            GMDL.Primitives.Quad q = new GMDL.Primitives.Quad(1.0f, 1.0f);
            GLPrimitiveVaos["default_quad"]         = q.getVAO();
            GLPrimitiveMeshVaos["default_quad"]     = new GLMeshVao();
            GLPrimitiveMeshVaos["default_quad"].vao = GLPrimitiveVaos["default_quad"];

            //Default render quad
            q = new GMDL.Primitives.Quad();
            GLPrimitiveVaos["default_renderquad"]         = q.getVAO();
            GLPrimitiveMeshVaos["default_renderquad"]     = new GLMeshVao();
            GLPrimitiveMeshVaos["default_renderquad"].vao = GLPrimitiveVaos["default_renderquad"];

            //Default cross
            GMDL.Primitives.Cross c = new GMDL.Primitives.Cross(0.1f, true);
            GLPrimitiveMeshVaos["default_cross"]                        = new GLMeshVao();
            GLPrimitiveVaos["default_cross"]                            = c.getVAO();
            GLPrimitiveMeshVaos["default_cross"].type                   = TYPES.GIZMO;
            GLPrimitiveMeshVaos["default_cross"].metaData               = new MeshMetaData();
            GLPrimitiveMeshVaos["default_cross"].metaData.batchcount    = c.geom.indicesCount;
            GLPrimitiveMeshVaos["default_cross"].metaData.AABBMIN       = new Vector3(-0.1f);
            GLPrimitiveMeshVaos["default_cross"].metaData.AABBMAX       = new Vector3(0.1f);
            GLPrimitiveMeshVaos["default_cross"].metaData.indicesLength = DrawElementsType.UnsignedInt;
            GLPrimitiveMeshVaos["default_cross"].vao                    = GLPrimitiveVaos["default_cross"];
            GLPrimitiveMeshVaos["default_cross"].material               = GLmaterials["crossMat"];


            //Default cube
            GMDL.Primitives.Box bx = new GMDL.Primitives.Box(1.0f, 1.0f, 1.0f, new Vector3(1.0f), true);
            GLPrimitiveVaos["default_box"]         = bx.getVAO();
            GLPrimitiveMeshVaos["default_box"]     = new GLMeshVao();
            GLPrimitiveMeshVaos["default_box"].vao = GLPrimitiveVaos["default_box"];


            //Default sphere
            GMDL.Primitives.Sphere sph = new GMDL.Primitives.Sphere(new Vector3(0.0f, 0.0f, 0.0f), 100.0f);
            GLPrimitiveVaos["default_sphere"]         = sph.getVAO();
            GLPrimitiveMeshVaos["default_sphere"]     = new GLMeshVao();
            GLPrimitiveMeshVaos["default_sphere"].vao = GLPrimitiveVaos["default_sphere"];

            generateGizmoParts();
        }
Esempio n. 4
0
    public GizmoPart(GIZMO_PART_TYPE t, Vector3 col)
    {
        type       = t;
        pick_color = col;
        switch (t)
        {
        case GIZMO_PART_TYPE.T_X:
            meshVao = MVCore.Common.RenderState.activeResMgr.GLPrimitiveMeshVaos["default_translation_gizmo_x_axis"];
            break;

        case GIZMO_PART_TYPE.T_Y:
            meshVao = MVCore.Common.RenderState.activeResMgr.GLPrimitiveMeshVaos["default_translation_gizmo_y_axis"];
            break;

        case GIZMO_PART_TYPE.T_Z:
            meshVao = MVCore.Common.RenderState.activeResMgr.GLPrimitiveMeshVaos["default_translation_gizmo_z_axis"];
            break;
        }
    }
Esempio n. 5
0
        public void render()
        {
            GL.Enable(EnableCap.Blend);
            GL.Disable(EnableCap.DepthTest);
            GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
            //Render info right on the 0 buffer

            GLSLShaderConfig shader = resMgr.GLShaders[SHADER_TYPE.TEXT_SHADER];

            GL.UseProgram(shader.program_id);

#if (DEBUG)
            //Upload test options to the shader
            //GL.Uniform1(shader.uniformLocations["edge"], RenderState.renderSettings.testOpt1);
            //GL.Uniform1(shader.uniformLocations["width"], RenderState.renderSettings.testOpt2);
#endif

            GL.Disable(EnableCap.CullFace);
            GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);

            //Render texts included in Text manager
            foreach (Text t in resMgr.txtMgr.texts)
            {
                GLMeshVao m = t.meshVao;

                //Render Start
                //GL.Uniform1(shader.uniformLocations["size"], m.material.CustomPerMaterialUniforms["size"].Vec.X);
                GL.Uniform1(shader.uniformLocations["fontSize"], (float)t.font.Size);
                GL.Uniform1(shader.uniformLocations["textSize"], t.lineHeight);
                GL.Uniform2(shader.uniformLocations["offset"], t.pos);
                GL.Uniform3(shader.uniformLocations["color"], t.color);
                //GL.Uniform2(shader.uniformLocations["textDim"], t.size);
                m.render(shader, RENDERPASS.FORWARD);
            }
            GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
            GL.Enable(EnableCap.CullFace);

            GL.PolygonMode(MaterialFace.FrontAndBack, RenderState.renderSettings.RENDERMODE);
            GL.Enable(EnableCap.DepthTest);
            GL.Disable(EnableCap.Blend);
        }