精华内容
下载资源
问答
  • Opengl绘制地图

    千次阅读 2017-09-12 17:53:31
    //地图名 fs >> p.longitude >> p.latitude; poly->points.push_back(p); } polygons.push_back(poly); } return polygons; } void display(void) { glClear(GL_COLOR_BUFFER_BIT)...
    #include<iostream>
    
    #include<fstream>//文本读写头文件
    #include<vector>//在C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。
    #include<GL/glut.h>
    using namespace std;
    class MapPoint//声明一个名为MapPoint的类
    {
    public:
    double longitude;//数据成员 经度
    double latitude;//纬度
    };
    class Polygon
    {
    public:
    vector<MapPoint>points; //多边形的顶点序列
    };
    vector<Polygon*> polys;  //多边形集合
    vector<Polygon*> ReadMapData(char* filename)//文件名
    {
    int PointCount;//计算点的个数
    vector<Polygon*>polygons;
    ifstream fs(filename);//寻找filename文件是否为空
    while (fs.eof() != true)
    {
    Polygon* poly = new Polygon;//定点个数
    fs >> PointCount;//定点个数赋值给fs
    cout << PointCount << endl;
    for (int i = 0; i < PointCount; i++)//做循环,定义p
    {
    MapPoint p;//地图名
    fs >> p.longitude >> p.latitude;
    poly->points.push_back(p);


    }
    polygons.push_back(poly);
    }
    return polygons;
    }
    void display(void)
    {
    glClear(GL_COLOR_BUFFER_BIT); //用蓝色色绘制各省边界
    glColor3f(0.0, 0.0, 1.0);//设置正面为填充模式
    glPolygonMode(GL_BACK, GL_LINE);
    for (int i = 0; i < polys.size(); i++)
    {
    vector<MapPoint>points = polys[i]->points;
    glBegin(GL_LINE_LOOP);//使用闭合曲线方式绘制各省边界
    for (int j = 0; j < points.size(); j++)
    {
    glVertex3f(points[j].longitude, points[j].latitude, 0.0);
    }
    glEnd();
    }
    glFlush();
    }
    void init(void)
    {
    glClearColor(1.0, 1.0, 1.0, 1.0);//设置背景颜色//初始化观察值
    glMatrixMode(GL_PROJECTION);//将矩阵模式设为投影
    glLoadIdentity();//对矩阵进行单位化
    glOrtho(70.0, 140.0, 0.0, 60.0, -1.0, 1.0); //构造平行投影矩阵


    }
    int main(int argc,char *argv[])
    {
    char*filename = "D:HENG.txt";//文件名与文件目录对应
    polys = ReadMapData(filename);//读定义的文件给polys
    glutInit(&argc, argv);//初始化
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//单缓存和RGB
    glutInitWindowSize(250, 250);//窗口大小
    glutInitWindowPosition(100, 100);//窗口位置
    glutCreateWindow("hello");//窗口标题
    init();
    glutDisplayFunc(display); //显示回调函数
    glutMainLoop();//进行消息循环
    return 0;


    }
    展开全文
  • OpenGL绘制简单地图

    2018-12-01 17:07:23
    使用OpenGL绘制简单的地图 https://blog.csdn.net/ME__WE/article/details/84675155
  • * 介绍如何使用OpenGL绘制地图中进行绘制 */ public class OpenglDemo extends Activity implements OnMapDrawFrameCallback { private static final String LTAG = OpenglDemo.class.getSimpleName(); // ...
    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" >
    
        <com.baidu.mapapi.map.MapView
            android:id="@+id/bmapView"
            android:layout_width="match_parent"
            android:layout_height="fill_parent" />
    
    </RelativeLayout>



    package baidumapsdk.demo;
    
    import java.nio.ByteBuffer;
    import java.nio.ByteOrder;
    import java.nio.FloatBuffer;
    import java.nio.ShortBuffer;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.microedition.khronos.opengles.GL10;
    
    import android.app.Activity;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.Color;
    import android.graphics.PointF;
    import android.opengl.GLUtils;
    import android.os.Bundle;
    import android.util.Log;
    
    import com.baidu.mapapi.map.BaiduMap;
    import com.baidu.mapapi.map.BaiduMap.OnMapDrawFrameCallback;
    import com.baidu.mapapi.map.MapStatus;
    import com.baidu.mapapi.map.MapView;
    import com.baidu.mapapi.model.LatLng;
    
    /**
     * 此demo用来展示如何在地图绘制的每帧中再额外绘制一些用户自己的内容
     * 
     * 介绍如何使用OpenGL绘制在地图中进行绘制
     */
    public class OpenglDemo extends Activity implements OnMapDrawFrameCallback {
    
    	private static final String LTAG = OpenglDemo.class.getSimpleName();
    
    	// 地图相关
    	MapView mMapView;
    	BaiduMap mBaiduMap;
    	Bitmap bitmap;
    	private LatLng latlng1 = new LatLng(39.97923, 116.357428);
    	LatLng latlng2 = new LatLng(39.94923, 116.397428);
    	LatLng latlng3 = new LatLng(39.96923, 116.437428);
    	private List<LatLng> latLngPolygon;
    	{
    		latLngPolygon = new ArrayList<LatLng>();
    		latLngPolygon.add(latlng1);
    		latLngPolygon.add(latlng2);
    		latLngPolygon.add(latlng3);
    	}
    
    	private float[] vertexs;
    	private FloatBuffer vertexBuffer;
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_opengl);
    		// 初始化地图
    		mMapView = (MapView) findViewById(R.id.bmapView);
    		mBaiduMap = mMapView.getMap();
    		//设置百度地图在每一帧绘制时的回调接口,该接口在绘制线程中调用
    		mBaiduMap.setOnMapDrawFrameCallback(this);
    		bitmap = BitmapFactory.decodeResource(this.getResources(),R.drawable.ground_overlay);
    	}
    
    	@Override
    	protected void onPause() {
    		mMapView.onPause();
    		super.onPause();
    	}
    
    	@Override
    	protected void onResume() {
    		mMapView.onResume();
    		// onResume 纹理失效
    		textureId = -1;
    		super.onResume();
    	}
    
    	@Override
    	protected void onDestroy() {
    		mMapView.onDestroy();
    		super.onDestroy();
    	}
    	
    	/**
    	 * onMapDrawFrame(GL10 gl, MapStatus drawingMapStatus)
    	 *  地图每一帧绘制结束后回调接口,在此你可以绘制自己的内容
    	 *  参数:
    	 *  gl - 地图 opengl引用
    	 *  drawingMapStatus - 地图当前正在绘制时的地图状态
    	 * */
    	public void onMapDrawFrame(GL10 gl, MapStatus drawingMapStatus) {
    		/**
    		 * public final Projection getProjection()
    		 * 获取地图投影坐标转换器, 当地图初始化完成之前返回 null,
    		 * 在 OnMapLoadedCallback.onMapLoaded() 之后才能正常
    		 * 返回:地图投影坐标转换器
    		 * */
    		if (mBaiduMap.getProjection() != null) {
    			calPolylinePoint(drawingMapStatus);
    			drawPolyline(gl, Color.argb(255, 255, 0, 0), vertexBuffer, 10, 3,drawingMapStatus);
    			drawTexture(gl, bitmap, drawingMapStatus);
    		}
    	}
    
    	public void calPolylinePoint(MapStatus mspStatus) {
    		PointF[] polyPoints = new PointF[latLngPolygon.size()];
    		vertexs = new float[3 * latLngPolygon.size()];
    		int i = 0;
    		for (LatLng xy : latLngPolygon) {
    			/**
    			 * public PointF toOpenGLLocation(LatLng location,MapStatus mapStatus)
    			 * 将地理坐标转换成openGL坐标,在 OnMapDrawFrameCallback 的 onMapDrawFrame 函数中使用。
    			 * @param location - 地理坐标 如果传入 null 则返回null
    			 * 		  mapStatus - 地图每一帧绘制时的地图状态 
    			 * @return openGL坐标
    			 * */
    			polyPoints[i] = mBaiduMap.getProjection().toOpenGLLocation(xy,mspStatus);
    			
    			vertexs[i * 3] = polyPoints[i].x;
    			vertexs[i * 3 + 1] = polyPoints[i].y;
    			vertexs[i * 3 + 2] = 0.0f;
    			i++;
    		}
    		for (int j = 0; j < vertexs.length; j++) {
    			Log.d(LTAG, "vertexs[" + j + "]: " + vertexs[j]);
    		}
    		vertexBuffer = makeFloatBuffer(vertexs);
    	}
    
    	private FloatBuffer makeFloatBuffer(float[] fs) {
    		ByteBuffer bb = ByteBuffer.allocateDirect(fs.length * 4);
    		bb.order(ByteOrder.nativeOrder());
    		FloatBuffer fb = bb.asFloatBuffer();
    		fb.put(fs);
    		fb.position(0);
    		return fb;
    	}
    
    	private void drawPolyline(GL10 gl, int color, FloatBuffer lineVertexBuffer,
    			float lineWidth, int pointSize, MapStatus drawingMapStatus) {
    
    		gl.glEnable(GL10.GL_BLEND);
    		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    
    		gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
    
    		float colorA = Color.alpha(color) / 255f;
    		float colorR = Color.red(color) / 255f;
    		float colorG = Color.green(color) / 255f;
    		float colorB = Color.blue(color) / 255f;
    
    		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, lineVertexBuffer);
    		gl.glColor4f(colorR, colorG, colorB, colorA);
    		gl.glLineWidth(lineWidth);
    		gl.glDrawArrays(GL10.GL_LINE_STRIP, 0, pointSize);
    
    		gl.glDisable(GL10.GL_BLEND);
    		gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    	}
    	int textureId = -1;
    	/**
    	 * 使用opengl坐标绘制
    	 * 
    	 * @param gl
    	 * @param bitmap
    	 * @param drawingMapStatus
    	 */
    	public void drawTexture(GL10 gl, Bitmap bitmap, MapStatus drawingMapStatus) {
    		PointF p1 = mBaiduMap.getProjection().toOpenGLLocation(latlng2,
    				drawingMapStatus);
    		PointF p2 = mBaiduMap.getProjection().toOpenGLLocation(latlng3,
    				drawingMapStatus);
    		ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4 * 3 * 4);
    		byteBuffer.order(ByteOrder.nativeOrder());
    		FloatBuffer vertices = byteBuffer.asFloatBuffer();
    		vertices.put(new float[] { p1.x, p1.y, 0.0f, p2.x, p1.y, 0.0f, p1.x,
    				p2.y, 0.0f, p2.x, p2.y, 0.0f });
    
    		ByteBuffer indicesBuffer = ByteBuffer.allocateDirect(6 * 2);
    		indicesBuffer.order(ByteOrder.nativeOrder());
    		ShortBuffer indices = indicesBuffer.asShortBuffer();
    		indices.put(new short[] { 0, 1, 2, 1, 2, 3 });
    
    		ByteBuffer textureBuffer = ByteBuffer.allocateDirect(4 * 2 * 4);
    		textureBuffer.order(ByteOrder.nativeOrder());
    		FloatBuffer texture = textureBuffer.asFloatBuffer();
    		texture.put(new float[] { 0, 1f, 1f, 1f, 0f, 0f, 1f, 0f });
    
    		indices.position(0);
    		vertices.position(0);
    		texture.position(0);
    
    		// 生成纹理
    		if (textureId == -1) {
    			int textureIds[] = new int[1];
    			gl.glGenTextures(1, textureIds, 0);
    			textureId = textureIds[0];
    			Log.d(LTAG, "textureId: " + textureId);
    			gl.glBindTexture(GL10.GL_TEXTURE_2D, textureId);
    			GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
    			gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER,
    					GL10.GL_NEAREST);
    			gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER,
    					GL10.GL_NEAREST);
    			gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);
    		}
    	
    		gl.glEnable(GL10.GL_TEXTURE_2D);
    		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    		gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
    		gl.glEnable(GL10.GL_BLEND);
    		gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
    		gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
    
    		// 绑定纹理ID
    		gl.glBindTexture(GL10.GL_TEXTURE_2D, textureId);
    		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertices);
    		gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texture);
    
    		gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 6, GL10.GL_UNSIGNED_SHORT,
    				indices);
    
    		gl.glDisable(GL10.GL_TEXTURE_2D);
    		gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    		gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
    		gl.glDisable(GL10.GL_BLEND);
    	}
    }
    


    展开全文
  • 绘制3D地图的时候,有个需求是物体的坐标变化,...但是OpenGL绘制的世界坐标系原点一直在屏幕中央,当改变了物体坐标时,视角不会跟随物体,请问有什么函数或者什么思路可以解决吗</p>
  • OpenGL绘制三维地形图

    2019-01-17 18:04:04
    根据高程数据,利用OpenGL绘制三维地形,高程数据为txt文件
  • OpenGL实现Google地图瓦片的绘制漫游视频培训课程:此次教程所涉及的内容有OpenGL绘制图片、FreeImage加载图片、墨卡托投影、瓦片的金字塔模型、FramebufferObject、地图的移动和缩放优化,采用屏幕瓦片绘制优化、...
  • OpenGL绘制矢量路径的思路

    千次阅读 2013-08-05 10:17:46
    如果使用OpenGL绘制矢量,对建模算法以及纹理都有要求,不同的建模算法决定了最终的视觉效果。OpenGL绘制路径,抗锯齿效果由纹理来实现。下面介绍两种不同效果的路径实现和绘制: 2. 纯色圆角路径 通过纹理方式实现...

    1. 引言

    软件方法绘制,如QT、Android(skia)都自带2D绘图引擎,支持矢量路径填充并且抗锯齿!如果使用OpenGL绘制矢量,对建模算法以及纹理都有要求,不同的建模算法决定了最终的视觉效果。OpenGL绘制路径,抗锯齿效果由纹理来实现。下面介绍两种不同效果的路径实现和绘制:

    2. 纯色圆角路径

    通过纹理方式实现抗锯齿单色路径绘制。

    建模算法非常简单:将一个polyline分解成一些列两点的线段,单独对每个线段建模,如下图0132和4576处贴两个半圆,2354用宽度为1的像素条放样生成。线段的末端是半圆,所以线段与线段之间能很好地衔接。



    思路来源:http://chimera.labs.oreilly.com/books/1234000001814/ch06.html#AaLinesWithTextures

    注意:如果贴图是半透明的,拐角处纹理会增强,效果不理想,如下图,所以该建模算法只适合单色不透明路径。


    3. 立体路径

    现在各家手机地图中路线都是立体纹理绘制,纹理效果如下图:


    实现立体路径绘制,建模算法的难点在拐角处处理,尤其锐角,角度很小的时候如何处理。经过一段时间的研究,实现了一种简单而且足够鲁邦的算法,思路非常简单:锐角的时候进行插值(使用的是三次样条插值),将锐角转化成钝角,钝角的时候建模算法如下图:


    如上图,一个建模处理单元由三个点组成,P0,P1,P2组成且夹角为钝角,路径宽度为2*radius,建模思路如下:

    T1 = normalize( P1-P0 );	// P0P1 单位向量
    N1 = Vec2f( -T1.y, T1.x);	// 法线向量可以直接写出
    v0 = P0 + radius * N1;		// 右手法则,v0方向为正
    v1 = p0 - radius * N1;
    v2 = P1 + radius * N1;
    v3 = P1 - radius * N1;
    
    T2 = normalize( P2-P1 );	// P0P1 单位向量
    N2 = Vec2f( -T2.y, T2.x);	// 法线向量可以直接写出
    v4 = P1 + radius * N2;
    v5 = p1 - radius * N2;
    v6 = P2 + radius * N2;
    v7 = P2 - radius * N2;
    
    verticesList: v0, v1, v2, v3, v4, v5, v6, v7
    triangleIndexList: 0,1,2,  2,1,3,  2,4,5, 2,5,4, 2,3,4, 2,4,3,	4,5,6	6,5,7
    拐角处可能会出现翻转情况,所以245和234三角形分别被CW和CCW各一个。


    插值算法

    如下图:


    原始顶点为P0,P1,P2,插值结果成五个顶点:P0, P1', P2', P3', P2。P1'和P3‘分别是P0P1线段和P1P2线段的中点;P2’为P0,P1,P2的加权平均值,权重分别为 1/8, 6/8, 1/8,代码如下:

        /**
         * 细分:3个顶点变换成5个顶点,起始顶点不变
         */
        private void cubicInterpolation(PointF p0, PointF p1, PointF p2, ArrayList<PointF> oPntList) {
            oPntList.add(p0);
            oPntList.add(new PointF((p0.x + p1.x) / 2, (p0.y + p1.y) / 2));
            oPntList.add(new PointF((p0.x + 6 * p1.x + p2.x) / 8, (p0.y + 6 * p1.y + p2.y) / 8));
            oPntList.add(new PointF((p1.x + p2.x) / 2, (p1.y + p2.y) / 2));
            oPntList.add(p2);
        }
    最终立体路径效果如下图:蓝线上面为直接建模的效果图,可以看出 拐角处有明显的填补瑕疵,蓝线下面为拐角处增加插值处理, 拐角处过度要柔和很多


    4. 零碎点

    Qt Examples and Demos中Demonstrations中的 Path Stroking 例子支持OpenGL渲染器,前段时间研究了下QT的OpenGL路径建模类也不太理想,只能实现单色的路径绘制如果使用立体纹理贴图拐角处效果不太好。


    图中三行分别为MiterJoin, RoundJoin, BevelJoin的填充图和线框图,线框模式下可以看出JOIN_ROUND下拐角处有明显的挤压现象。

    源码见:https://map-render.googlecode.com/svn/trunk/map-render目录下,road render目录中:

    qtriangulatingstroker.h
    qtriangulatingstroker.cpp
    qhelper.h
    qbase.h
    qbase.cpp
    road_render_app.cpp
    


    展开全文
  • OPENGL绘制三维地形图

    2017-05-31 14:49:31
    根据高程数据,绘制三维地形
  • 百度地图SDK为广大开发者开放了OpenGL绘制接口,帮助开发者在地图上实现更灵活的样式绘制,丰富地图使用效果体验。 二、运行截图 简介:介绍如何使用OpenGL在地图上实现自定义绘制。 详述: (1)利用OpenGL...

    分类:C#、Android、VS2015、百度地图应用; 创建日期:2016-02-04

    一、简介

    百度地图SDK为广大开发者开放了OpenGL绘制接口,帮助开发者在地图上实现更灵活的样式绘制,丰富地图使用效果体验。

     

    二、运行截图

    简介:介绍如何使用OpenGL在地图上实现自定义绘制。

    详述:

    (1)利用OpenGL绘制基本折线;

    (2)利用OpenGL在地图上进行纹理绘制;

    本示例运行截图如下:

    image

    三、设计步骤

    1、添加demo24_opengl.xml文件

    在layout文件夹下添加该文件,然后将代码改为下面的内容:

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" >
      <com.baidu.mapapi.map.TextureMapView
          android:id="@+id/bmapView"
          android:layout_width="match_parent"
          android:layout_height="fill_parent" />
    </RelativeLayout>

    2、添加Demo24OpenGL.cs文件

    在SrcSdkDemos文件夹下添加该文件,然后将代码改为下面的内容:

    using Android.App;
    using Android.OS;
    using Com.Baidu.Mapapi.Map;
    using Com.Baidu.Mapapi.Model;
    using Android.Graphics;
    using Android.Util;
    using System.Collections.Generic;
    using Javax.Microedition.Khronos.Opengles;
    using Java.Nio;
    using Android.Opengl;
    
    namespace BdMapV371Demos.SrcSdkDemos
    {
        /// <summary>
        /// 此demo用来展示如何在地图绘制的每帧中再额外绘制一些用户自己的内容
        /// </summary>
        [Activity(Label = "@string/demo_name_opengl")]
        public class Demo24OpenGL : Activity, BaiduMap.IOnMapDrawFrameCallback
        {
            // 地图相关
            private TextureMapView mMapView;
            private BaiduMap mBaiduMap;
            private Bitmap bitmap;
            private LatLng latlng1 = new LatLng(39.97923, 116.357428);
            private LatLng latlng2 = new LatLng(39.94923, 116.397428);
            private LatLng latlng3 = new LatLng(39.96923, 116.437428);
            private IList<LatLng> latLngPolygon;
            private float[] vertexs;
            private FloatBuffer vertexBuffer;
            private int textureId = -1;
            private readonly string LTAG = "Demo24OpenGL";
    
            protected override void OnCreate(Bundle savedInstanceState)
            {
                base.OnCreate(savedInstanceState);
                SetContentView(Resource.Layout.demo24_opengl);
                mMapView = FindViewById<TextureMapView>(Resource.Id.bmapView);
                mBaiduMap = mMapView.Map;
                latLngPolygon = new List<LatLng>()
                {
                    latlng1,latlng2,latlng3
                };
                mBaiduMap.SetOnMapDrawFrameCallback(this);
                bitmap = BitmapFactory.DecodeResource(Resources,
                    Resource.Drawable.ground_overlay);
            }
    
            protected override void OnPause()
            {
                mMapView.OnPause();
                base.OnPause();
            }
            protected override void OnResume()
            {
                mMapView.OnResume();
                textureId = -1;
                base.OnResume();
            }
    
            protected override void OnDestroy()
            {
                mMapView.OnDestroy();
                base.OnDestroy();
            }
    
            public void OnMapDrawFrame(IGL10 gl, MapStatus drawingMapStatus)
            {
                if (mBaiduMap.Projection != null)
                {
                    calPolylinePoint(drawingMapStatus);
                    drawPolyline(gl, Color.Argb(255, 255, 0, 0), vertexBuffer, 10, 3,
                            drawingMapStatus);
                    drawTexture(gl, bitmap, drawingMapStatus);
                }
            }
            public void calPolylinePoint(MapStatus mspStatus)
            {
                PointF[] polyPoints = new PointF[latLngPolygon.Count];
                vertexs = new float[3 * latLngPolygon.Count];
                int i = 0;
                foreach (LatLng xy in latLngPolygon)
                {
                    polyPoints[i] = mBaiduMap.Projection.ToOpenGLLocation(xy, mspStatus);
                    vertexs[i * 3] = polyPoints[i].X;
                    vertexs[i * 3 + 1] = polyPoints[i].Y;
                    vertexs[i * 3 + 2] = 0.0f;
                    i++;
                }
                for (int j = 0; j < vertexs.Length; j++)
                {
                    Log.Debug(LTAG, "vertexs[" + j + "]: " + vertexs[j]);
                }
                vertexBuffer = makeFloatBuffer(vertexs);
            }
    
            private FloatBuffer makeFloatBuffer(float[] fs)
            {
                ByteBuffer bb = ByteBuffer.AllocateDirect(fs.Length * 4);
                bb.Order(ByteOrder.NativeOrder());
                FloatBuffer fb = bb.AsFloatBuffer();
                fb.Put(fs);
                fb.Position(0);
                return fb;
            }
    
            private void drawPolyline(IGL10 gl, int color, FloatBuffer lineVertexBuffer,
                    float lineWidth, int pointSize, MapStatus drawingMapStatus)
            {
    
                gl.GlEnable(GL10.GlBlend);
                gl.GlEnableClientState(GL10.GlVertexArray);
    
                gl.GlBlendFunc(GL10.GlSrcAlpha, GL10.GlOneMinusSrcAlpha);
    
                float colorA = Color.GetAlphaComponent(color) / 255f;
                float colorR = Color.GetRedComponent(color) / 255f;
                float colorG = Color.GetGreenComponent(color) / 255f;
                float colorB = Color.GetBlueComponent(color) / 255f;
    
                gl.GlVertexPointer(3, GL10.GlFloat, 0, lineVertexBuffer);
                gl.GlColor4f(colorR, colorG, colorB, colorA);
                gl.GlLineWidth(lineWidth);
                gl.GlDrawArrays(GL10.GlLineStrip, 0, pointSize);
    
                gl.GlDisable(GL10.GlBlend);
                gl.GlDisableClientState(GL10.GlVertexArray);
            }
    
            /// <summary>
            /// 使用opengl坐标绘制
            /// </summary>
            /// <param name="gl"></param>
            /// <param name="bitmap"></param>
            /// <param name="drawingMapStatus"></param>
            public void drawTexture(IGL10 gl, Bitmap bitmap, MapStatus drawingMapStatus)
            {
                PointF p1 = mBaiduMap.Projection.ToOpenGLLocation(latlng2,
                        drawingMapStatus);
                PointF p2 = mBaiduMap.Projection.ToOpenGLLocation(latlng3,
                        drawingMapStatus);
                ByteBuffer byteBuffer = ByteBuffer.AllocateDirect(4 * 3 * 4);
                byteBuffer.Order(ByteOrder.NativeOrder());
                FloatBuffer vertices = byteBuffer.AsFloatBuffer();
                vertices.Put(new float[] { p1.X, p1.Y, 0.0f, p2.X, p1.Y, 0.0f, p1.X,
                    p2.Y, 0.0f, p2.X, p2.Y, 0.0f });
    
                ByteBuffer indicesBuffer = ByteBuffer.AllocateDirect(6 * 2);
                indicesBuffer.Order(ByteOrder.NativeOrder());
                ShortBuffer indices = indicesBuffer.AsShortBuffer();
                indices.Put(new short[] { 0, 1, 2, 1, 2, 3 });
    
                ByteBuffer textureBuffer = ByteBuffer.AllocateDirect(4 * 2 * 4);
                textureBuffer.Order(ByteOrder.NativeOrder());
                FloatBuffer texture = textureBuffer.AsFloatBuffer();
                texture.Put(new float[] { 0, 1f, 1f, 1f, 0f, 0f, 1f, 0f });
    
                indices.Position(0);
                vertices.Position(0);
                texture.Position(0);
    
                // 生成纹理
                if (textureId == -1)
                {
                    int[] textureIds = new int[1];
                    gl.GlGenTextures(1, textureIds, 0);
                    textureId = textureIds[0];
                    Log.Debug(LTAG, "textureId: " + textureId);
                    gl.GlBindTexture(GL10.GlTexture2d, textureId);
                    GLUtils.TexImage2D(GL10.GlTexture2d, 0, bitmap, 0);
                    gl.GlTexParameterf(GL10.GlTexture2d, GL10.GlTextureMinFilter, GL10.GlNearest);
                    gl.GlTexParameterf(GL10.GlTexture2d, GL10.GlTextureMagFilter, GL10.GlNearest);
                    gl.GlBindTexture(GL10.GlTexture2d, 0);
                }
    
                gl.GlEnable(GL10.GlTexture2d);
                gl.GlEnableClientState(GL10.GlVertexArray);
                gl.GlEnableClientState(GL10.GlTextureCoordArray);
                gl.GlEnable(GL10.GlBlend);
                gl.GlBlendFunc(GL10.GlSrcAlpha, GL10.GlOneMinusSrcAlpha);
                gl.GlColor4f(1.0f, 1.0f, 1.0f, 1.0f);
    
                // 绑定纹理ID
                gl.GlBindTexture(GL10.GlTexture2d, textureId);
                gl.GlVertexPointer(3, GL10.GlFloat, 0, vertices);
                gl.GlTexCoordPointer(2, GL10.GlFloat, 0, texture);
                gl.GlDrawElements(GL10.GlTriangleStrip, 6, GL10.GlUnsignedShort, indices);
                gl.GlDisable(GL10.GlTexture2d);
                gl.GlDisableClientState(GL10.GlVertexArray);
                gl.GlDisableClientState(GL10.GlTextureCoordArray);
                gl.GlDisable(GL10.GlBlend);
            }
        }
    }

    3、修改MainActivity.cs文件

    在MainActivity.cs文件的demos字段定义中,去掉【示例24】下面的注释。

    运行观察效果。

    转载于:https://www.cnblogs.com/rainmj/p/5181960.html

    展开全文
  • OpenGL出现的频率越来越高了,尽管目前我没有用到,但也记录下来,方便以后扩展!这个没什么好说的,直接上代码绘制! package cq.cake.chwl.ui; import android.app.ActivityManager; import android.content.pm....
  • qt + opengl 绘制地球

    千次阅读 2017-11-22 07:06:12
    方法: 先载入纹理图(pLoadTex函数); 再画建立一个二次曲面物体...在paintGL函数里,只要调用glBindTexture和gluSphere函数,即可绘制地球。 代码: pro文件: #-----------------------------------------
  • 需要制作一个Slam地图的3d显示,捣鼓了两个星期终于弄出来了,虽然效果没有达到预期,记录一下(图片随便找的) 首先是顶点着色器 #version 300 es layout (location = 0) in vec4 vPosition; layout (location...
  • 地理地图/游戏地图openGL

    千次阅读 2019-06-29 11:47:55
    -- 问题: OpenGL绘制三维地形图,...Opengl绘制地图,OpenGL实现地图编辑器,制作简易地图; OpenGL渲染地理路线 建筑物等。 路线 建筑物等的坐标或经纬度数据? > 地图与Opengl 使用opengles绘制灰度地形图- ...
  • opengl环境配置可参照上一篇博客:控制台+OPENGL配置说明[GLUT篇] 二、内容说明 1 功能 导入的obj飞机模型 实现光照效果:实现飞机模型的光照 实现天空盒:有6张图封闭成一个天空盒子 实现地形:根据地形图片,...
  • 计算顶点、法向量、绘制索引 public void setMapData(List points) { vertexPoints = new float[points.size() * 60]; cubeNormal = new float[points.size() * 60]; indices = new int[points.size() * 30]; for ...
  • OpenGL绘制地球

    万次阅读 2006-12-08 00:50:00
    本想用自动纹理坐标生成做的,可是红宝书上说...逛啊逛,让我找到了另一种方法,仅仅几行代码:// 画地球void OpenGL::DrawEarth(void)...{ GLUquadricObj *quadObj = gluNewQuadric();//创建一个二次曲面物体 
  • OpenGL实现Google地图瓦片的绘制漫游视频培训课程:此次教程所涉及的内容有OpenGL绘制图片、FreeImage加载图片、墨卡托投影、瓦片的金字塔模型、FramebufferObject、地图的移动和缩放优化,采用屏幕瓦片绘制优化、...
  • 我现在用的是opengl渲染地图地图的点要素往往会有特定的显示样式,如国家首通常都是用五角星表示。 以五角星为例,我现在有这个五角星的bmp图片,我的目的是将图片中的五角星部分抠出来绘制,将五角星外的 部分...
  • OpenGL实现Google地图瓦片的绘制漫游视频培训课程:此次教程所涉及的内容有OpenGL绘制图片、FreeImage加载图片、墨卡托投影、瓦片的金字塔模型、FramebufferObject、地图的移动和缩放优化,采用屏幕瓦片绘制优化、...
  • Opengl绘制世界地图,使用的是tesslation来绘制的,但是由于多边形较多,绘制的效率很低,有什么高效的绘制方法吗?
  • 使用opengles绘制灰度地形图
  • 将数据用OpenGL的方式进行绘制。  上述3方面只是完成初步的绘制,对于要完成一个复杂的地理信息系统还有很大的差距, 下面介绍我设计的简单的地理信息框架(用于交流,进步)。先上个图,根据图来说更加...
  • 课程采用C++进行编码教学,采用OpenGL实现基本的地理信息系统的矢量数据的读取,解析和绘制,实现地理坐标向屏幕坐标的转化,实现常用的WGS84以及墨卡托坐投影方式,实现重要也是基本的地图操作(放大和漫游功能),后介绍...
  •   地形本质上由一个个顶点(x,y,z)组成多个三角面连接...opengl 绘制网格 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 代码: 下面Terrain 类就是生成一个简单的平面地形网格。 Terrain.hpp #pragma once #incl
  • Android端使用OpenGL ES 绘制简易的地球,超简易,只是添加顶点和纹理数据给glsl绘制,没经过任何其他的加工,仅适合初学者查看流程。
  • OpenGL实现Google地图瓦片的绘制漫游视频教程 2004年毕业于西南...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,735
精华内容 1,894
关键字:

opengl绘制地图