1 /*
   2  * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.prism.es2;
  27 
  28 import java.io.InputStream;
  29 import java.util.Map;
  30 
  31 import com.sun.glass.ui.Screen;
  32 import com.sun.javafx.PlatformUtil;
  33 import com.sun.prism.Image;
  34 import com.sun.prism.MediaFrame;
  35 import com.sun.prism.Mesh;
  36 import com.sun.prism.MeshView;
  37 import com.sun.prism.PhongMaterial;
  38 import com.sun.prism.PixelFormat;
  39 import com.sun.prism.Presentable;
  40 import com.sun.prism.PresentableState;
  41 import com.sun.prism.RTTexture;
  42 import com.sun.prism.Texture;
  43 import com.sun.prism.Texture.Usage;
  44 import com.sun.prism.Texture.WrapMode;
  45 import com.sun.prism.impl.PrismSettings;
  46 import com.sun.prism.impl.TextureResourcePool;
  47 import com.sun.prism.impl.VertexBuffer;
  48 import com.sun.prism.impl.ps.BaseShaderFactory;
  49 import com.sun.prism.ps.Shader;
  50 import com.sun.prism.ps.ShaderFactory;
  51 import java.lang.reflect.Method;
  52 import java.util.HashMap;
  53 import java.util.WeakHashMap;
  54 
  55 public class ES2ResourceFactory extends BaseShaderFactory {
  56     private static final Map<Image,Texture> clampTexCache = new WeakHashMap<>();
  57     private static final Map<Image,Texture> repeatTexCache = new WeakHashMap<>();
  58     private static final Map<Image,Texture> mipmapTexCache = new WeakHashMap<>();
  59 
  60     private ES2Context context;
  61     // Maximum size of the texture
  62     private final int maxTextureSize;
  63 
  64     ES2ResourceFactory(Screen screen) {
  65         super(clampTexCache, repeatTexCache, mipmapTexCache);
  66         context = new ES2Context(screen, this);
  67         maxTextureSize = computeMaxTextureSize();
  68 
  69         if (PrismSettings.verbose) {
  70             System.out.println("Non power of two texture support = "
  71                     + context.getGLContext().canCreateNonPowTwoTextures());
  72             System.out.println("Maximum number of vertex attributes = "
  73                     + context.getGLContext().getIntParam(GLContext.GL_MAX_VERTEX_ATTRIBS));
  74             int maxVUC, maxFUC, maxVC;
  75             // We need this if-else block is because iMX6 doesn't support component queries 
  76             // and Mac  doesn't support vectors queries.
  77             if (PlatformUtil.isEmbedded()) {
  78                 // Multiply by 4 as it is documented that a vector has 4 components.
  79                 maxVUC = context.getGLContext().getIntParam(GLContext.GL_MAX_VERTEX_UNIFORM_VECTORS) * 4;
  80                 maxFUC = context.getGLContext().getIntParam(GLContext.GL_MAX_FRAGMENT_UNIFORM_VECTORS) * 4;
  81                 maxVC = context.getGLContext().getIntParam(GLContext.GL_MAX_VARYING_VECTORS) * 4;
  82             } else {
  83                 maxVUC = context.getGLContext().getIntParam(GLContext.GL_MAX_VERTEX_UNIFORM_COMPONENTS);
  84                 maxFUC = context.getGLContext().getIntParam(GLContext.GL_MAX_FRAGMENT_UNIFORM_COMPONENTS);
  85                 maxVC = context.getGLContext().getIntParam(GLContext.GL_MAX_VARYING_COMPONENTS);
  86             }
  87             System.out.println("Maximum number of uniform vertex components = " + maxVUC);
  88             System.out.println("Maximum number of uniform fragment components = " + maxFUC);
  89             System.out.println("Maximum number of varying components = " + maxVC);
  90             System.out.println("Maximum number of texture units usable in a vertex shader = "
  91                     + context.getGLContext().getIntParam(GLContext.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS));
  92             System.out.println("Maximum number of texture units usable in a fragment shader = "
  93                     + context.getGLContext().getIntParam(GLContext.GL_MAX_TEXTURE_IMAGE_UNITS));
  94         }
  95     }
  96 
  97     public TextureResourcePool getTextureResourcePool() {
  98         return ES2VramPool.instance;
  99     }
 100 
 101     public Presentable createPresentable(PresentableState pState) {
 102         return new ES2SwapChain(context, pState);
 103     }
 104 
 105     @Override
 106     public boolean isCompatibleTexture(Texture tex) {
 107         return tex instanceof ES2Texture;
 108     }
 109 
 110     @Override
 111     protected boolean canClampToZero() {
 112         return context.getGLContext().canClampToZero();
 113     }
 114 
 115     @Override
 116     protected boolean canRepeat() {
 117         // Actually, this depends on the size.  It works for pow2 textures...
 118         return context.getGLContext().canCreateNonPowTwoTextures();
 119     }
 120 
 121     @Override
 122     protected boolean canClampToEdge() {
 123         // Actually, this depends on the size.  It works for pow2 textures...
 124         return context.getGLContext().canCreateNonPowTwoTextures();
 125     }
 126 
 127     public Texture createTexture(PixelFormat formatHint,
 128                                  Usage usageHint,
 129                                  WrapMode wrapMode,
 130                                  int w, int h)
 131     {
 132         return createTexture(formatHint, usageHint, wrapMode, w, h, false);
 133     }
 134 
 135     @Override
 136     public Texture createTexture(PixelFormat formatHint, Usage usageHint,
 137             WrapMode wrapMode, int w, int h, boolean useMipmap) {
 138         return ES2Texture.create(context, formatHint, wrapMode, w, h, useMipmap);
 139     }
 140 
 141     public Texture createTexture(MediaFrame frame) {
 142         return ES2Texture.create(context, frame);
 143     }
 144 
 145     public int getRTTWidth(int w, WrapMode wrapMode) {
 146         return ES2RTTexture.getCompatibleDimension(context, w, wrapMode);
 147     }
 148 
 149     public int getRTTHeight(int h, WrapMode wrapMode) {
 150         return ES2RTTexture.getCompatibleDimension(context, h, wrapMode);
 151     }
 152 
 153     public RTTexture createRTTexture(int width, int height, WrapMode wrapMode) {
 154         return createRTTexture(width, height, wrapMode, false);
 155     }
 156 
 157     public RTTexture createRTTexture(int width, int height, WrapMode wrapMode, boolean msaa) {
 158         return ES2RTTexture.create(context, width, height, wrapMode, msaa);
 159     }
 160 
 161     public boolean isFormatSupported(PixelFormat format) {
 162         GLFactory glFactory = ES2Pipeline.glFactory;
 163         switch (format) {
 164             case BYTE_RGB:
 165             case BYTE_GRAY:
 166             case BYTE_ALPHA:
 167             case MULTI_YCbCr_420:
 168                 return true;
 169             case BYTE_BGRA_PRE:
 170             case INT_ARGB_PRE:
 171                 if (glFactory.isGL2() || PlatformUtil.isIOS()) {
 172                     return true;
 173                 } else {
 174                     // for OpenGLES, BGRA can be supported by extension - if
 175                     // we have it, use it
 176                     return glFactory.isGLExtensionSupported("GL_EXT_texture_format_BGRA8888");
 177                 }
 178             case FLOAT_XYZW:
 179                 return glFactory.isGL2()
 180                     // Unfortunately our support for float textures on GLES
 181                     // seems to be broken so we will defer use of this extension
 182                     // until we fix RT-26286.
 183 //                        || glFactory.isGLExtensionSupported("GL_OES_texture_float")
 184                         ;
 185             case BYTE_APPLE_422:
 186                 return glFactory.isGLExtensionSupported("GL_APPLE_ycbcr_422");
 187             default:
 188                 return false;
 189         }
 190     }
 191 
 192     private int computeMaxTextureSize() {
 193         int size = context.getGLContext().getMaxTextureSize();
 194         if (PrismSettings.verbose) {
 195             System.out.println("Maximum supported texture size: " + size);
 196         }
 197         if (size > PrismSettings.maxTextureSize) {
 198             size = PrismSettings.maxTextureSize;
 199             if (PrismSettings.verbose) {
 200                 System.out.println("Maximum texture size clamped to " + size);
 201             }
 202         }
 203         return size;
 204     }
 205 
 206     public int getMaximumTextureSize() {
 207         return maxTextureSize;
 208     }
 209 
 210     public Shader createShader(InputStream pixelShaderCode,
 211             Map<String, Integer> samplers,
 212             Map<String, Integer> params,
 213             int maxTexCoordIndex,
 214             boolean isPixcoordUsed,
 215             boolean isPerVertexColorUsed) {
 216         // figure out the appropriate vertex shader and minimal set of
 217         // vertex attributes to enable based on the given parameters
 218         Map<String, Integer> attributes =
 219                 getVertexAttributes(isPerVertexColorUsed, maxTexCoordIndex);
 220 
 221         // create the combined shader program
 222         ES2Shader shader;
 223         String vertexShaderCode =
 224                 createVertexShaderCode(isPerVertexColorUsed, maxTexCoordIndex);
 225         shader = ES2Shader.createFromSource(context, vertexShaderCode,
 226                 pixelShaderCode, samplers, attributes,
 227                 maxTexCoordIndex, isPixcoordUsed);
 228 
 229         return shader;
 230     }
 231 
 232     private static String createVertexShaderCode(boolean includePerVertexColor,
 233             int maxTexCoordIndex) {
 234         StringBuilder vsAttr = new StringBuilder();
 235         StringBuilder vsVary = new StringBuilder();
 236         StringBuilder vsMain = new StringBuilder();
 237         vsMain.append("void main() {\n");
 238 
 239         boolean includePosition = true;
 240         if (includePosition) {
 241             vsAttr.append("attribute vec2 positionAttr;\n");
 242             vsMain.append("    vec4 tmp = vec4(positionAttr, 0, 1);\n");
 243             vsMain.append("    gl_Position = mvpMatrix * tmp;\n");
 244         }
 245         if (includePerVertexColor) {
 246             vsAttr.append("attribute vec4 colorAttr;\n");
 247             vsVary.append("varying lowp vec4 perVertexColor;\n");
 248             vsMain.append("    perVertexColor = colorAttr;\n");
 249         }
 250         if (maxTexCoordIndex >= 0) {
 251             vsAttr.append("attribute vec2 texCoord0Attr;\n");
 252             vsVary.append("varying vec2 texCoord0;\n");
 253             vsMain.append("    texCoord0 = texCoord0Attr;\n");
 254         }
 255         if (maxTexCoordIndex >= 1) {
 256             vsAttr.append("attribute vec2 texCoord1Attr;\n");
 257             vsVary.append("varying vec2 texCoord1;\n");
 258             vsMain.append("    texCoord1 = texCoord1Attr;\n");
 259         }
 260 
 261         vsMain.append("}\n");
 262         StringBuilder vs = new StringBuilder();
 263 
 264         vs.append("#ifdef GL_ES\n");
 265         vs.append("#else\n");
 266         vs.append("#define lowp\n");
 267         vs.append("#endif\n");
 268         vs.append("uniform mat4 mvpMatrix;\n");
 269         vs.append(vsAttr);
 270         vs.append(vsVary);
 271         vs.append(vsMain);
 272 
 273         return vs.toString();
 274     }
 275 
 276     private Map<String, Integer> getVertexAttributes(boolean includePerVertexColor,
 277             int maxTexCoordIndex) {
 278         Map<String, Integer> attributes = new HashMap<String, Integer>();
 279 
 280         boolean includePosition = true;
 281         if (includePosition) {
 282             attributes.put("positionAttr", 0);
 283         }
 284         if (includePerVertexColor) {
 285             attributes.put("colorAttr", 1);
 286         }
 287         if (maxTexCoordIndex >= 0) {
 288             attributes.put("texCoord0Attr", 2);
 289         }
 290         if (maxTexCoordIndex >= 1) {
 291             attributes.put("texCoord1Attr", 3);
 292         }
 293 
 294         return attributes;
 295     }
 296 
 297     public Shader createStockShader(String name) {
 298         if (name == null) {
 299             throw new IllegalArgumentException("Shader name must be non-null");
 300         }
 301         try {
 302             InputStream stream =
 303                     ES2ResourceFactory.class.getResourceAsStream(
 304                     "glsl/" + name + ".frag");
 305             Class klass =
 306                     Class.forName("com.sun.prism.shader." + name + "_Loader");
 307             if (PrismSettings.verbose) {
 308                 System.out.println("ES2ResourceFactory: Prism - createStockShader: " + name + ".frag");
 309             }
 310             Method m =
 311                     klass.getMethod("loadShader", new Class[]{ShaderFactory.class,
 312                         InputStream.class});
 313             return (Shader) m.invoke(null, new Object[]{this, stream});
 314         } catch (Throwable e) {
 315             e.printStackTrace();
 316             throw new InternalError("Error loading stock shader " + name);
 317         }
 318     }
 319 
 320     public VertexBuffer createVertexBuffer(int maxQuads) {
 321         return new VertexBuffer(maxQuads);
 322     }
 323 
 324     public void dispose() {
 325         context.clearContext();
 326     }
 327 
 328     public PhongMaterial createPhongMaterial() {
 329         return ES2PhongMaterial.create(context);
 330 }
 331 
 332     public MeshView createMeshView(Mesh mesh) {
 333         return ES2MeshView.create(context, (ES2Mesh) mesh);
 334     }
 335 
 336     public Mesh createMesh() {
 337         return ES2Mesh.create(context);
 338     }
 339 }