Android OpenGL ES 2.0 内存中仅限制 16 个纹理？

2023-11-24

基本上，当我在 Android Studio 中使用 OpenGL ES 2.0 开发应用程序时，我遇到了一个无法解决的大问题，并且它已经困扰我大约一周了。

因此，每当我在内存中加载超过 16 个、可能是 17 个任意大小的纹理，并尝试通过 Genymotion 中的模拟器或华硕平板电脑以 2D 方式显示它们时，它要么开始显示与我当时绑定的图像不同的图像特定索引，或根本不显示。但如果我通过我的三星 Galaxy S6 运行它，它运行得很好。但是，如果我加载 16 个或更少的纹理，它可以在我测试的所有设备（包括模拟器）上正常工作。

这让我尝试了一个小实验，看看它是否会显示字母图像 a-z，每个字母都是 16x16 png，所有这些都在我的可绘制文件夹中。当每个字母显示出来时，它在屏幕上的大小将为 80x80，这样我就可以看到它们。所以我尝试让它运行“a”到“z”。在模拟器以及我的平板电脑上，它只显示“a”到“o”，在“p”应该在的末尾有一个“z”，然后就停在那里。在我的三星 Galaxy 上，它实际上显示了“a”到“z”，并且执行了预期的操作。考虑到我在常量中将纹理数量设置为 27 甚至更高，这对于为什么它无法在其他设备上正确加载没有任何意义。我希望我能很好地解释我的问题。我很确定它们都能够加载超过 16 个纹理，所以我的代码一定是出了问题。我不会展示整个项目，而是会向您展示问题可能存在的相关领域。感谢任何帮助并提前致谢。这是我的代码：

常数：

public class Constants
{
public static final int BYTES_PER_FLOAT = 4;
public static final int POSITION_COMPONENT_COUNT = 4;
public static final int NORMAL_COMPONENT_COUNT = 3;
public static final int COLOR_COMPONENT_COUNT = 4;
public static final int TEXTURE_COORDS_COMPONENT_COUNT = 2;

public static final String A_COLOR = "a_Color";
public static final String A_POSITION = "a_Position";
public static final String A_NORMAL = "a_Normal";
public static final String A_TEXTURECOORDS = "a_TextureCoords";
public static final String U_MVMATRIX = "u_MVMatrix";
public static final String U_MVPMATRIX = "u_MVPMatrix";
public static final String U_TEXTURE_UNIT = "u_Texture_Unit";
public static final String U_LIGHTPOS = "u_LightPos";
public static final String V_COLOR = "v_Color";
public static final String V_POSITION = "v_Position";
public static final String V_NORMAL = "v_Normal";

public static float SCREEN_WIDTH;
public static float SCREEN_HEIGHT;

public static int NUMBER_OF_TEXTURES = 27;
}

纹理.java:

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLUtils;

import static android.opengl.GLES20.*;

public class Texture
{
public static int[] texture;

public static void Load(Context context, int resourceId, int index)
{
    //glGenTextures(Constants.NUMBER_OF_TEXTURES, texture, starting_index);
    //int n: specifies the number of texture names to be generated
    //int[] textures: specifies an array in which the generated texture names are stored
    //int offset: the starting index of your array!

    Bitmap bitmap;
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inScaled = false;

    // loading texture
    bitmap = BitmapFactory.decodeResource(context.getResources(), resourceId, options);

    // ...and bind it to our array
    glActiveTexture(GL_TEXTURE0 + index);
    glBindTexture(GL_TEXTURE_2D, texture[index]);

    // create nearest filtered texture
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    // Use Android GLUtils to specify a two-dimensional texture image from our bitmap
    GLUtils.texImage2D(GL_TEXTURE_2D, 0, bitmap, 0);

    // Clean up
    bitmap.recycle();
}

public static void Delete(int[] texture, int starting_index)
{
    try
    {
        glDeleteTextures(1, texture, starting_index);
    }
    catch(Exception e)
    {
        return;
    }

}
}

四元组

import static android.opengl.GLES20.*;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

public class Quad
 {
public float vertices[];
public float colors[];
public float texture_coords[];

public FloatBuffer vertexBuffer;
public FloatBuffer textureBuffer;
public FloatBuffer colorBuffer;

public Quad(float x1, float y1, float z1, float w1,
            float x2, float y2, float z2, float w2,
            float x3, float y3, float z3, float w3,
            float x4, float y4, float z4, float w4,
            float red, float green, float blue, float alpha,
            float u1, float v1, float u2, float v2)
{
    vertices = new float[]{x1, y1, z1, w1,
            x2, y2, z2, w2,
            x3, y3, z3, w3,
            x4, y4, z4, w4};

    colors = new float[]{red, green, blue, alpha,
            red, green, blue, alpha,
            red, green, blue, alpha,
            red, green, blue, alpha};

    ByteBuffer vertexByteBuffer = ByteBuffer.allocateDirect(vertices.length * Constants.BYTES_PER_FLOAT);
    vertexByteBuffer.order(ByteOrder.nativeOrder());
    vertexBuffer = vertexByteBuffer.asFloatBuffer();
    vertexBuffer.put(vertices);
    vertexBuffer.position(0);

    ByteBuffer colorByteBuffer = ByteBuffer.allocateDirect(colors.length * Constants.BYTES_PER_FLOAT);
    colorByteBuffer.order(ByteOrder.nativeOrder());
    colorBuffer = colorByteBuffer.asFloatBuffer();
    colorBuffer.put(colors);
    colorBuffer.position(0);

    texture_coords = new float[]{u1, v1,
            u2, v1,
            u1, v2,
            u2, v2};
    ByteBuffer textureByteBuffer = ByteBuffer.allocateDirect(texture_coords.length * Constants.BYTES_PER_FLOAT);
    textureByteBuffer.order(ByteOrder.nativeOrder());
    textureBuffer = textureByteBuffer.asFloatBuffer();
    textureBuffer.put(texture_coords);
    textureBuffer.position(0);
}

public void Draw_Polygon(int index, int program, float[] modelview_projection_matrix, float[] modelview_matrix)
{
    int aPositionHandle = glGetAttribLocation(program, Constants.A_POSITION);
    glEnableVertexAttribArray(aPositionHandle);
    glVertexAttribPointer(aPositionHandle, Constants.POSITION_COMPONENT_COUNT, GL_FLOAT, false, 0, vertexBuffer);

    int aColorHandle = glGetAttribLocation(program, Constants.A_COLOR);
    glEnableVertexAttribArray(aColorHandle);
    glVertexAttribPointer(aColorHandle, Constants.COLOR_COMPONENT_COUNT, GL_FLOAT, false, 0, colorBuffer);

    int aTextureCoordsHandle = glGetAttribLocation(program, Constants.A_TEXTURECOORDS);
    glEnableVertexAttribArray(aTextureCoordsHandle);
    glVertexAttribPointer(aTextureCoordsHandle, Constants.TEXTURE_COORDS_COMPONENT_COUNT, GL_FLOAT, false, 0, textureBuffer);

    int uModelViewProjectionMatrixHandle = glGetUniformLocation(program, Constants.U_MVPMATRIX);
    glUniformMatrix4fv(uModelViewProjectionMatrixHandle, 1, false, modelview_projection_matrix, 0);

    int uModelViewMatrixHandle = glGetUniformLocation(program, Constants.U_MVMATRIX);
    glUniformMatrix4fv(uModelViewMatrixHandle, 1, false, modelview_matrix, 0);

    int uTextureUnit = glGetUniformLocation(program, Constants.U_TEXTURE_UNIT);
    glUniform1i(uTextureUnit, index);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    glDisableVertexAttribArray(aPositionHandle);
    glDisableVertexAttribArray(aColorHandle);
    glDisableVertexAttribArray(aTextureCoordsHandle);
}
}

文本.java:

import android.opengl.Matrix;

import static android.opengl.GLES20.*;

public class Text
{
public Quad[] poly = new Quad[1];
public String string;
public int char_width;
public int char_height;

void Draw()
{
    int texture_num = 0;
    int x_pos = 0;
    int y_pos = 0;
    for (int i = 0; i < string.length(); i++)
    {
        char character = string.charAt(i);

        switch(character)
        {
            case ' ':
            {
                texture_num = 0;
                break;
            }
            case 'a':
            {
                texture_num = 1;
                break;
            }
            case 'b':
            {
                texture_num = 2;
                break;
            }
            case 'c':
            {
                texture_num = 3;
                break;
            }
            case 'd':
            {
                texture_num = 4;
                break;
            }
            case 'e':
            {
                texture_num = 5;
                break;
            }
            case 'f':
            {
                texture_num = 6;
                break;
            }
            case 'g':
            {
                texture_num = 7;
                break;
            }
            case 'h':
            {
                texture_num = 8;
                break;
            }
            case 'i':
            {
                texture_num = 9;
                break;
            }
            case 'j':
            {
                texture_num = 10;
                break;
            }
            case 'k':
            {
                texture_num = 11;
                break;
            }
            case 'l':
            {
                texture_num = 12;
                break;
            }
            case 'm':
            {
                texture_num = 13;
                break;
            }
            case 'n':
            {
                texture_num = 14;
                break;
            }
            case 'o':
            {
                texture_num = 15;
                break;
            }
            case 'p':
            {
                texture_num = 16;
                break;
            }
            case 'q':
            {
                texture_num = 17;
                break;
            }
            case 'r':
            {
                texture_num = 18;
                break;
            }
            case 's':
            {
                texture_num = 19;
                break;
            }
            case 't':
            {
                texture_num = 20;
                break;
            }
            case 'u':
            {
                texture_num = 21;
                break;
            }
            case 'v':
            {
                texture_num = 22;
                break;
            }
            case 'w':
            {
                texture_num = 23;
                break;
            }
            case 'x':
            {
                texture_num = 24;
                break;
            }
            case 'y':
            {
                texture_num = 25;
                break;
            }
            case 'z':
            {
                texture_num = 26;
                break;
            }
        }

        Matrix.setIdentityM(OpenGL.model_matrix, 0);
        Matrix.translateM(OpenGL.model_matrix, 0, OpenGL.model_matrix, 0, 0.0f, 0.0f, 0.0f);
        Matrix.multiplyMM(OpenGL.matrix_ortho_projection_and_view, 0, OpenGL.matrix_ortho_projection, 0, OpenGL.model_matrix, 0);

        glUseProgram(Shader.textured_colored_shader_program);

        poly[0] = new Quad(x_pos + 0.0f, y_pos + 0.0f, 0.0f, 1.0f,
                x_pos + char_width, y_pos + 0.0f, 0.0f, 1.0f,
                x_pos + 0.0f, y_pos + char_height, 0.0f, 1.0f,
                x_pos + char_width, y_pos + char_height, 0.0f, 1.0f,
                1.0f, 1.0f, 1.0f, 1.0f,
                0.0f, 0.0f, 1.0f, 1.0f);

        poly[0].Draw_Polygon(texture_num, Shader.textured_colored_shader_program, OpenGL.matrix_ortho_projection_and_view, OpenGL.model_matrix);

        x_pos += char_width;

        if (x_pos >= Constants.SCREEN_WIDTH)
        {
            x_pos = 0;
            y_pos += char_height;
        }
    }
}
}

OpenGL.java:

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.content.Context;
import android.opengl.GLSurfaceView.Renderer;
import static android.opengl.GLES20.*;

import android.util.Log;
import android.opengl.Matrix;

public class OpenGL implements Renderer
{
public static Context context;

public static final float[] matrix_ortho_projection = new float[16];
public static float[] model_matrix = new float[16];
private final float[] matrix_view = new float[16];
public static final float[] matrix_ortho_projection_and_view = new float[16];
public int get_width, get_height;
public static boolean texture_loading_enabled = true;
Text text = new Text();

public OpenGL(Context context)
{
    this.context = context;
}

public static void Load_Textures()
{
    switch(State.game_state)
    {
        case State.LOGO:
        {
            Texture.Delete(Texture.texture, 0);

            glFlush();

            Texture.texture = new int[Constants.NUMBER_OF_TEXTURES];

            glGenTextures(Constants.NUMBER_OF_TEXTURES, Texture.texture, 0);

            Texture.Load(context, R.drawable.c64_space, 0);
            Texture.Load(context, R.drawable.c64_a, 1);
            Texture.Load(context, R.drawable.c64_b, 2);
            Texture.Load(context, R.drawable.c64_c, 3);
            Texture.Load(context, R.drawable.c64_d, 4);
            Texture.Load(context, R.drawable.c64_e, 5);
            Texture.Load(context, R.drawable.c64_f, 6);
            Texture.Load(context, R.drawable.c64_g, 7);
            Texture.Load(context, R.drawable.c64_h, 8);
            Texture.Load(context, R.drawable.c64_i, 9);
            Texture.Load(context, R.drawable.c64_j, 10);
            Texture.Load(context, R.drawable.c64_k, 11);
            Texture.Load(context, R.drawable.c64_l, 12);
            Texture.Load(context, R.drawable.c64_m, 13);
            Texture.Load(context, R.drawable.c64_n, 14);
            Texture.Load(context, R.drawable.c64_o, 15);
            Texture.Load(context, R.drawable.c64_p, 16);
            Texture.Load(context, R.drawable.c64_q, 17);
            Texture.Load(context, R.drawable.c64_r, 18);
            Texture.Load(context, R.drawable.c64_s, 19);
            Texture.Load(context, R.drawable.c64_t, 20);
            Texture.Load(context, R.drawable.c64_u, 21);
            Texture.Load(context, R.drawable.c64_v, 22);
            Texture.Load(context, R.drawable.c64_w, 23);
            Texture.Load(context, R.drawable.c64_x, 24);
            Texture.Load(context, R.drawable.c64_y, 25);
            Texture.Load(context, R.drawable.c64_z, 26);

            break;
        }

        case State.TITLE:
        {
            break;
        }

        case State.GAME:
        {
            break;
        }
    }

    texture_loading_enabled = false;
}

private void Controls()
{

    switch(State.game_state)
    {
        case State.LOGO:
        {
            break;
        }

        case State.TITLE:
        {
            break;
        }

        case State.GAME:
        {
            break;
        }
    }

}

@Override
public void onDrawFrame(GL10 glUnused)
{
    Controls();

    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    switch(State.game_state)
    {
        case State.LOGO:
        {
            text.Draw();
            break;
        }

        case State.TITLE:
        {
            break;
        }

        case State.GAME:
        {
            break;
        }
    }
}

@Override
public void onSurfaceChanged(GL10 glUnused, int width, int height)
{
    // Set the OpenGL viewport to the same size as the surface.
    Log.d("TAG", "onSurfaceChanged()");

    get_width = width;
    get_height = height;

    glViewport(0, 0, width, height);

    for(int i = 0; i < 16; i++)
    {
        matrix_ortho_projection[i] = 0.0f;
        matrix_view[i] = 0.0f;
        model_matrix[i] = 0.0f;
        matrix_ortho_projection_and_view[i] = 0.0f;
    }

    Matrix.orthoM(matrix_ortho_projection, 0, 0.0f, (float) get_width, (float) get_height, 0.0f, 0.0f, 1.0f);
}

@Override
public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
{
    Log.d("TAG", "onSurfaceCreated()");

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

    Shader.Create_Texture_Colored_Shader(context);
    Shader.Create_Colored_Shader(context);

    text.char_width = 80;
    text.char_height = 80;
    text.string = "abcdefghijklmnopqrstuvwxyz";

    switch(State.game_state)
    {
        case State.LOGO:
        {
            if (texture_loading_enabled == true)
                Load_Textures();
            break;
        }

        case State.TITLE:
        {
            break;
        }

        case State.GAME:
        {
            break;
        }
    }
}
}

着色器.java：

import android.content.Context;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import static android.opengl.GLES20.*;

public class Shader
{
public static int textured_colored_shader_program;
public static int colored_shader_program;

public static String readTextFileFromRawResource(final Context context, final int resourceId)
{
    final InputStream inputStream = context.getResources().openRawResource(resourceId);
    final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
    final BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    String nextLine;
    final StringBuilder body = new StringBuilder();

    try
    {
        while ((nextLine = bufferedReader.readLine()) != null)
        {
            body.append(nextLine);
            body.append('\n');
        }
    }
    catch (IOException e)
    {
        return null;
    }

    return body.toString();
}

public static int loadShader(int type, String shaderCode)
{
    int shader = glCreateShader(type);
    glShaderSource(shader, shaderCode);
    glCompileShader(shader);
    return shader;
}

public static void Create_Texture_Colored_Shader(Context context)
{
    int vertexShader = loadShader(GL_VERTEX_SHADER, readTextFileFromRawResource(context, R.raw.vertex_shader));
    int fragmentShader = loadShader(GL_FRAGMENT_SHADER, readTextFileFromRawResource(context, R.raw.fragment_shader));
    textured_colored_shader_program = glCreateProgram();
    glAttachShader(textured_colored_shader_program, vertexShader);
    glAttachShader(textured_colored_shader_program, fragmentShader);
    glLinkProgram(textured_colored_shader_program);
}

public static void Create_Colored_Shader(Context context)
{
    int vertexShader = loadShader(GL_VERTEX_SHADER, readTextFileFromRawResource(context, R.raw.vertex_shader_no_texture));
    int fragmentShader = loadShader(GL_FRAGMENT_SHADER, readTextFileFromRawResource(context, R.raw.fragment_shader_no_texture));
    colored_shader_program = glCreateProgram();
    glAttachShader(colored_shader_program, vertexShader);
    glAttachShader(colored_shader_program, fragmentShader);
    glLinkProgram(colored_shader_program);
}
}

纹理总数objects通常不受限制。至少不在任何合理的范围内，理论上您将运行可以由GLuint在某一点。但在那之前你就会耗尽内存。因此，唯一的实际限制通常是由用于纹理数据的内存量给出。

然而，纹理的数量units是非常有限的。快速查看您的代码，这就是您遇到的情况。从您的纹理加载代码：

glActiveTexture(GL_TEXTURE0 + index);
glBindTexture(GL_TEXTURE_2D, texture[index]);

您要做的就是保持所有纹理的绑定，为每个纹理使用不同的纹理单元。然后，当您绘制时，您可以选择着色器采样的纹理单元：

glUniform1i(uTextureUnit, index);

这是一个完全有效的方法......直到你用完纹理单元。这正是发生的情况。

纹理单元的最大数量取决于实现，可以通过以下方式查询：

GLint maxUnits = 0;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxUnits);

该值的最小值为 8。因此，除非您检查该值并找到更多值，否则您只能依赖 8 个纹理单元。

如果您需要超过 8 个纹理，并且希望您的代码能够跨设备可靠地运行，那么保持所有纹理绑定的有点非常规的方法将不起作用。

最简单的方法是按照大多数人的做法：在绘制之前绑定要使用的纹理。为此，您始终可以使用纹理单元 0。因此您可以删除对glActiveTexture()，然后简单地在Draw_Polygon()方法，而不是glUniform1i() call:

glBindTexture(GL_TEXTURE_2D, texture[index]);

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Android OpenGL ES 2.0 内存中仅限制 16 个纹理？的相关文章

斯坦福 NLP - 处理文件列表时 OpenIE 内存不足

我正在尝试使用斯坦福 CoreNLP 中的 OpenIE 工具从多个文件中提取信息当多个文件而不是一个传递到输入时它会给出内存不足错误 All files have been queued awaiting termination
Java按日期升序对列表对象进行排序[重复]

这个问题在这里已经有答案了我想按一个参数对对象列表进行排序其日期格式为 YYYY MM DD HH mm 按升序排列我找不到正确的解决方案在 python 中使用 lambda 很容易对其进行排序但在 Java 中我遇到了问题 f
如何默认在 ActionOpenDocument 意图中显示“内部存储”选项

我需要用户选择一个自定义文件类型的文件并将其从 Windows 文件资源管理器拖到 Android 设备上但默认情况下内部存储选项不可用当我使用以下命令启动意图时 var libraryIntent new Intent Intent
为什么HashMap不能保证map的顺序随着时间的推移保持不变

我在这里阅读有关 Hashmap 和 Hashtable 之间的区别 http javarevisited blogspot sg 2010 10 difference Between hashmap and html http javar
JRE 系统库 [WebSphere v6.1 JRE]（未绑定）

将项目导入 Eclipse 后我的构建路径中出现以下错误 JRE System Library WebSphere v6 1 JRE unbound 谁知道怎么修它右键单击项目特性 gt Java 构建路径 gt 图书馆 gt JRE
在 Mac 上正确运行基于 SWT 的跨平台 jar

我一直致力于一个基于 SWT 的项目该项目旨在部署为 Java Web Start 从而可以在多个平台上使用到目前为止我已经成功解决了由于 SWT 依赖的系统特定库而出现的导出问题请参阅相关thread https stackove
仅将 char[] 的一部分复制到 String 中

我有一个数组 char ch 我的问题如下如何将 ch 2 到 ch 7 的值合并到字符串中我想在不循环 char 数组的情况下实现这一点有什么建议么感谢您花时间回答我的问题 Use new String value offset
Google App Engine 如何预编译 Java？

App Engine 对应用程序的 Java 字节码使用预编译过程以增强应用程序在 Java 运行时环境中的性能预编译代码的功能与原始字节码相同有没有详细的信息这是做什么的我在一个中找到了这个谷歌群组消息 http groups
如何从终端运行处理应用程序

我目前正在使用加工 http processing org对于一个小项目但是我不喜欢它附带的文本编辑器我使用 vim 编写所有代码我找到了 pde 文件的位置并且我一直在从 vim 中编辑它们然后重新打开它们并运行它们重新加载脚
Android 中麦克风的后台访问

是否可以通过 Android 手机上的后台应用程序服务持续监控麦克风我想做的一些想法不断聆听背景中的声音信号收到有趣的音频信号后执行一些网络操作如果前台应用程序需要的话后台应用程序必须能够智能地放弃对麦克风的访问除非可
如何从泛型类调用静态方法？

我有一个包含静态创建方法的类 public class TestClass public static
simpleframework，将空元素反序列化为空字符串而不是 null

我使用简单框架 http simple sourceforge net http simple sourceforge net 在一个项目中满足我的序列化反序列化需求但在处理空空字符串值时它不能按预期工作好吧至少不是我所期望的如
编译器抱怨“缺少返回语句”，即使不可能达到缺少返回语句的条件

在下面的方法中编译器抱怨缺少退货声明即使该方法只有一条路径并且它包含一个return陈述抑制错误需要另一个return陈述 public int foo if true return 5 鉴于Java编译器可以识别无限循环 https
如何在Xamarin中删除ViewTreeObserver？

假设我需要获取并设置视图的高度在 Android 中众所周知只有在绘制视图之后才能获取视图高度如果您使用 Java 有很多答案最著名的方法之一如下取自这个答案 https stackoverflow com a 24035591
实现滚动选择 ListView 中的项目

我想使用 ListView 您可以在其中滚动列表来选择一个项目它应该像一个 Seekbar 但拇指应该是固定的并且您必须使用该栏来调整它我面临的一个问题是我不知道这种小部件是如何调用的这使得我很难搜索所以我制作了下面这张图片以
将 Intent 包装在 LabeledIntent 中以用于显示目的

要求我的应用程序中有一个共享按钮我需要通过 Facebook 分享我需要选择是否安装原生 Facebook 应用程序我们的决定是如果未安装该应用程序则将用户发送到 facebook com 进行分享当前状态我可以检测何时
捕获的图像分辨率太大

我在做什么我允许用户捕获图像将其存储到 SD 卡中并上传到服务器但捕获图像的分辨率为宽度 4608 像素和高度 2592 像素现在我想要什么如何在不影响质量的情况下获得小分辨率图像例如我可以获取或设置捕获的图像分辨率为原始图像分
如何修复 JNLP 应用程序中的“缺少代码库、权限和应用程序名称清单属性”？

随着最近的 Java 更新许多人都遇到了缺少 Java Web Start 应用程序的问题Codebase Permissions and Application name体现属性尽管有资源可以帮助您完成此任务但我找不到任何资源综合的
java.lang.IllegalStateException：驱动程序可执行文件的路径必须由 webdriver.chrome.driver 系统属性设置 - Similiar 不回答

尝试学习 Selenium 我打开了类似的问题但似乎没有任何帮助我的代码 package seleniumPractice import org openqa selenium WebDriver import org openqa s
节拍匹配算法

我最近开始尝试创建一个移动应用程序 iOS Android 它将自动击败比赛 http en wikipedia org wiki Beatmatching http en wikipedia org wiki Beatmatching 两

随机推荐

如何在 Visual Studio 中静态链接 VCPKG 生成的 .lib 文件

我使用 VCPKG 构建第三方库例如 libcurl 我有动态和静态构建显然导入 lib和对象 lib文件分别包含在两个不同的文件夹中 x64 windows和x64 windows static 我想将对象 libcurl lib
在 D3.js 中重新排序 SVG ( z-index ) 元素

我意识到这个问题以前已经被问过但我无法深入了解这是我的图表 http www gogeye com financialnews piechart index3 html 我想做的就是将硬币渲染在图表后面我知道 D3 渲染是按照附加顺序
如何查询pandas中的MultiIndex索引列值

代码示例 In 171 A np array 1 1 1 1 3 3 3 3 5 5 6 6 In 172 B np array 111 222 222 333 333 777 In 173 C randint 10 99 6 In 174
将图像转换为 Base64，反之亦然

我想将图像转换为 Base64 然后再次转换回图像这是我到目前为止尝试过的代码以及错误请问有什么建议吗 public void Base64ToImage string coded System Drawing Image finalI
在 Java 中构建 SQL 字符串的最简洁方法

我想构建一个 SQL 字符串来执行数据库操作更新删除插入选择之类的事情而不是使用数百万个和引号的糟糕的字符串连接方法这充其量是不可读的有一定是更好的方法我确实考虑过使用 MessageFormat 但它应该用于用户消息尽
PHP：MySQL 服务器消失了

我知道这个问题已经被问过很多次了但我已经尝试了一切我有一个 PHP 脚本它会迭代数千个图像根据需要执行调整大小然后插入数据库我收到此错误消息警告 mysql query function mysql query MySQL 服
后置和前置增量运算符

当我运行以下示例时我得到输出 0 2 1 class ZiggyTest2 static int f1 int i System out print i return 0 public static void main String ar
Android 中的 TTS 暂停

我正在开发一个应用程序它可以读出文档中的文本我想添加暂停和恢复功能但我在 TTS 中找不到任何暂停方法有什么办法可以让我暂停吗有一个方法可以暂停只需致电TextToSpeech playSilence 请参阅下面的代码here
跨源请求被阻止 Spring REST 服务 + AJAX

无法调用spring REST服务我的春季服务 RequestMapping value MAS authenticate method RequestMethod POST public ResponseEntity
将掩码应用于字符串

我正在从表中读取字符串 ID 值当用户输入 ID 时是使用用户定义的输入掩码完成的因此掩码可能类似于000 00 0000 AA 9999999等掩码会因用户而异因此必须在运行时进行评估鉴于表中仅存储字母数字文本那么应用该掩码
如何删除 Logstash 过滤器中所有具有 NULL 值的字段

我正在使用 Logstash 读取 csv 格式的检查点日志文件并且某些字段具有空值我想删除所有具有空值的字段我无法准确预见哪些字段键将具有空值因为我的 csv 文件中有 150 列并且我不想检查其中的每一列是否可以在log
如何按特定字段对 Spark DataFrame 中的结构类型数组进行排序？

给出以下代码 import java sql Date import org apache spark sql SparkSession import org apache spark sql functions object SortQu
在 LLDB 调试器中显示变量属性的值？

我正在使用 Log Message 操作的断点并且我想打印 NSIndexPath 的行所以我尝试 cell row indexPath row 但什么也没有打印出来我还尝试使用调试器命令 expr void NSLog indexP
psql：无法将主机名“somePostgres”转换为地址：名称或服务未知

我正在 docker 中构建 java spring mvc 应用程序并且 dokefile 构建涉及与 postgres 容器交互每当我跑步时docker compose updockerfile 中与 postrges 交互的步骤有
使用 lift-json 将 Json 值提取为 Map

lift json 的文档表明我应该能够调用 values 来获取当前的 JObject 结构作为普通的 Scala Map 这种方法对我来说不起作用因为值的返回类型是 json Values 而不是示例所示的 Map 我究竟做错了什
运算符“>=”不能应用于“string”和“string”类型的操作数

我在 C 中使用实体框架我的代码是 var result ef services Where entry gt entry tarikhservice gt textBoxX1 Text entry tarikhservice lt te
AWS Athena (Presto) OFFSET 支持

我想知道 AWS Athena 是否支持 OFFSET 对于 mysql 以下查询正在运行但在 athena 中它给了我错误任何例子都会有帮助从员工中选择其中 empSal gt 3000 LIMIT 300 OFFSET 20 A
如何自定义 Hibernate @Size 错误消息以指示输入字段的长度

我想自定义文本字段的错误消息以包含输入的实际字符数我已经能够做到这一点但对我的解决方案不满意所以我想知道其他人做了什么来实现这一目标春季4 1 2 休眠4 3 10 休眠验证器 5 1 3 字段注释出于测试目的仅限 10 个实
应用程序在 CoreData 保存时冻结

我有一个 iPhone 应用程序在保存 CoreData 时有时会冻结然后不会重新启动我确实有第二个线程使用数据库但我认为我已经遵循该模式为该线程创建单独的上下文这是重新启动后的崩溃报告有任何想法吗我尝试将其更改为仅使用一个线
Android OpenGL ES 2.0 内存中仅限制 16 个纹理？

基本上当我在 Android Studio 中使用 OpenGL ES 2 0 开发应用程序时我遇到了一个无法解决的大问题并且它已经困扰我大约一周了因此每当我在内存中加载超过 16 个可能是 17 个任意大小的纹理并尝试通过

Android OpenGL ES 2.0 内存中仅限制 16 个纹理？

Android OpenGL ES 2.0 内存中仅限制 16 个纹理？ 的相关文章

随机推荐

热门标签

Android OpenGL ES 2.0 内存中仅限制 16 个纹理？的相关文章