0001: /*
0002: * $RCSfile: NoopPipeline.java,v $
0003: *
0004: * Copyright 2006-2008 Sun Microsystems, Inc. All Rights Reserved.
0005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0006: *
0007: * This code is free software; you can redistribute it and/or modify it
0008: * under the terms of the GNU General Public License version 2 only, as
0009: * published by the Free Software Foundation. Sun designates this
0010: * particular file as subject to the "Classpath" exception as provided
0011: * by Sun in the LICENSE file that accompanied this code.
0012: *
0013: * This code is distributed in the hope that it will be useful, but WITHOUT
0014: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0015: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0016: * version 2 for more details (a copy is included in the LICENSE file that
0017: * accompanied this code).
0018: *
0019: * You should have received a copy of the GNU General Public License version
0020: * 2 along with this work; if not, write to the Free Software Foundation,
0021: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0022: *
0023: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0024: * CA 95054 USA or visit www.sun.com if you need additional information or
0025: * have any questions.
0026: *
0027: * $Revision: 1.8 $
0028: * $Date: 2008/02/28 20:17:27 $
0029: * $State: Exp $
0030: */
0031:
0032: package javax.media.j3d;
0033:
0034: import java.awt.GraphicsConfiguration;
0035: import java.awt.GraphicsDevice;
0036: import java.awt.GraphicsEnvironment;
0037:
0038: /**
0039: * Concrete implementation of Pipeline class for the noop rendering
0040: * pipeline.
0041: */
0042: class NoopPipeline extends Pipeline {
0043:
0044: // Flags indicating whether the Cg or GLSL libraries are available.
0045: private boolean cgLibraryAvailable = false;
0046:
0047: /**
0048: * Constructor for singleton NoopPipeline instance
0049: */
0050: protected NoopPipeline() {
0051: }
0052:
0053: /**
0054: * Initialize the pipeline
0055: */
0056: void initialize(Pipeline.Type pipelineType) {
0057: super .initialize(pipelineType);
0058:
0059: assert pipelineType == Pipeline.Type.NOOP;
0060: }
0061:
0062: /**
0063: * Load all of the required libraries
0064: */
0065: void loadLibraries(int globalShadingLanguage) {
0066: }
0067:
0068: /**
0069: * Returns true if the Cg library is loaded and available. Note that this
0070: * does not necessarily mean that Cg is supported by the graphics card.
0071: */
0072: boolean isCgLibraryAvailable() {
0073: return cgLibraryAvailable;
0074: }
0075:
0076: /**
0077: * Returns true if the GLSL library is loaded and available. Note that this
0078: * does not necessarily mean that GLSL is supported by the graphics card.
0079: */
0080: boolean isGLSLLibraryAvailable() {
0081: return true;
0082: }
0083:
0084: // ---------------------------------------------------------------------
0085:
0086: //
0087: // GeometryArrayRetained methods
0088: //
0089:
0090: // Used by D3D to free vertex buffer
0091: void freeD3DArray(GeometryArrayRetained geo, boolean deleteVB) {
0092: }
0093:
0094: // used for GeometryArrays by Copy or interleaved
0095: void execute(Context ctx, GeometryArrayRetained geo, int geo_type,
0096: boolean isNonUniformScale, boolean useAlpha,
0097: boolean ignoreVertexColors, int startVIndex, int vcount,
0098: int vformat, int texCoordSetCount, int[] texCoordSetMap,
0099: int texCoordSetMapLen, int[] texCoordSetOffset,
0100: int numActiveTexUnitState, int vertexAttrCount,
0101: int[] vertexAttrSizes, float[] varray, float[] cdata,
0102: int cdirty) {
0103: }
0104:
0105: // used by GeometryArray by Reference with java arrays
0106: void executeVA(Context ctx, GeometryArrayRetained geo,
0107: int geo_type, boolean isNonUniformScale,
0108: boolean ignoreVertexColors, int vcount, int vformat,
0109: int vdefined, int coordIndex, float[] vfcoords,
0110: double[] vdcoords, int colorIndex, float[] cfdata,
0111: byte[] cbdata, int normalIndex, float[] ndata,
0112: int vertexAttrCount, int[] vertexAttrSizes,
0113: int[] vertexAttrIndex, float[][] vertexAttrData,
0114: int texcoordmaplength, int[] texcoordoffset,
0115: int numActiveTexUnitState, int[] texIndex, int texstride,
0116: Object[] texCoords, int cdirty) {
0117: }
0118:
0119: // used by GeometryArray by Reference with NIO buffer
0120: void executeVABuffer(Context ctx, GeometryArrayRetained geo,
0121: int geo_type, boolean isNonUniformScale,
0122: boolean ignoreVertexColors, int vcount, int vformat,
0123: int vdefined, int coordIndex, Object vcoords,
0124: int colorIndex, Object cdataBuffer, float[] cfdata,
0125: byte[] cbdata, int normalIndex, Object ndata,
0126: int vertexAttrCount, int[] vertexAttrSizes,
0127: int[] vertexAttrIndex, Object[] vertexAttrData,
0128: int texcoordmaplength, int[] texcoordoffset,
0129: int numActiveTexUnitState, int[] texIndex, int texstride,
0130: Object[] texCoords, int cdirty) {
0131: }
0132:
0133: // used by GeometryArray by Reference in interleaved format with NIO buffer
0134: void executeInterleavedBuffer(Context ctx,
0135: GeometryArrayRetained geo, int geo_type,
0136: boolean isNonUniformScale, boolean useAlpha,
0137: boolean ignoreVertexColors, int startVIndex, int vcount,
0138: int vformat, int texCoordSetCount, int[] texCoordSetMap,
0139: int texCoordSetMapLen, int[] texCoordSetOffset,
0140: int numActiveTexUnitState, Object varray, float[] cdata,
0141: int cdirty) {
0142: }
0143:
0144: void setVertexFormat(Context ctx, GeometryArrayRetained geo,
0145: int vformat, boolean useAlpha, boolean ignoreVertexColors) {
0146: }
0147:
0148: void disableGlobalAlpha(Context ctx, GeometryArrayRetained geo,
0149: int vformat, boolean useAlpha, boolean ignoreVertexColors) {
0150: }
0151:
0152: // used for GeometryArrays
0153: void buildGA(Context ctx, GeometryArrayRetained geo, int geo_type,
0154: boolean isNonUniformScale, boolean updateAlpha,
0155: float alpha, boolean ignoreVertexColors, int startVIndex,
0156: int vcount, int vformat, int texCoordSetCount,
0157: int[] texCoordSetMap, int texCoordSetMapLen,
0158: int[] texCoordSetMapOffset, int vertexAttrCount,
0159: int[] vertexAttrSizes, double[] xform, double[] nxform,
0160: float[] varray) {
0161: }
0162:
0163: // used to Build Dlist GeometryArray by Reference with java arrays
0164: void buildGAForByRef(Context ctx, GeometryArrayRetained geo,
0165: int geo_type, boolean isNonUniformScale,
0166: boolean updateAlpha, float alpha,
0167: boolean ignoreVertexColors, int vcount, int vformat,
0168: int vdefined, int coordIndex, float[] vfcoords,
0169: double[] vdcoords, int colorIndex, float[] cfdata,
0170: byte[] cbdata, int normalIndex, float[] ndata,
0171: int vertexAttrCount, int[] vertexAttrSizes,
0172: int[] vertexAttrIndex, float[][] vertexAttrData,
0173: int texcoordmaplength, int[] texcoordoffset,
0174: int[] texIndex, int texstride, Object[] texCoords,
0175: double[] xform, double[] nxform) {
0176: }
0177:
0178: // ---------------------------------------------------------------------
0179:
0180: //
0181: // IndexedGeometryArrayRetained methods
0182: //
0183:
0184: // by-copy or interleaved, by reference, Java arrays
0185: void executeIndexedGeometry(Context ctx, GeometryArrayRetained geo,
0186: int geo_type, boolean isNonUniformScale, boolean useAlpha,
0187: boolean ignoreVertexColors, int initialIndexIndex,
0188: int indexCount, int vertexCount, int vformat,
0189: int vertexAttrCount, int[] vertexAttrSizes,
0190: int texCoordSetCount, int[] texCoordSetMap,
0191: int texCoordSetMapLen, int[] texCoordSetOffset,
0192: int numActiveTexUnitState, float[] varray, float[] cdata,
0193: int cdirty, int[] indexCoord) {
0194: }
0195:
0196: // interleaved, by reference, nio buffer
0197: void executeIndexedGeometryBuffer(Context ctx,
0198: GeometryArrayRetained geo, int geo_type,
0199: boolean isNonUniformScale, boolean useAlpha,
0200: boolean ignoreVertexColors, int initialIndexIndex,
0201: int indexCount, int vertexCount, int vformat,
0202: int texCoordSetCount, int[] texCoordSetMap,
0203: int texCoordSetMapLen, int[] texCoordSetOffset,
0204: int numActiveTexUnitState, Object varray, float[] cdata,
0205: int cdirty, int[] indexCoord) {
0206: }
0207:
0208: // non interleaved, by reference, Java arrays
0209: void executeIndexedGeometryVA(Context ctx,
0210: GeometryArrayRetained geo, int geo_type,
0211: boolean isNonUniformScale, boolean ignoreVertexColors,
0212: int initialIndexIndex, int validIndexCount,
0213: int vertexCount, int vformat, int vdefined,
0214: float[] vfcoords, double[] vdcoords, float[] cfdata,
0215: byte[] cbdata, float[] ndata, int vertexAttrCount,
0216: int[] vertexAttrSizes, float[][] vertexAttrData,
0217: int texcoordmaplength, int[] texcoordoffset,
0218: int numActiveTexUnitState, int texstride,
0219: Object[] texCoords, int cdirty, int[] indexCoord) {
0220: }
0221:
0222: // non interleaved, by reference, nio buffer
0223: void executeIndexedGeometryVABuffer(Context ctx,
0224: GeometryArrayRetained geo, int geo_type,
0225: boolean isNonUniformScale, boolean ignoreVertexColors,
0226: int initialIndexIndex, int validIndexCount,
0227: int vertexCount, int vformat, int vdefined, Object vcoords,
0228: Object cdataBuffer, float[] cfdata, byte[] cbdata,
0229: Object normal, int vertexAttrCount, int[] vertexAttrSizes,
0230: Object[] vertexAttrData, int texcoordmaplength,
0231: int[] texcoordoffset, int numActiveTexUnitState,
0232: int texstride, Object[] texCoords, int cdirty,
0233: int[] indexCoord) {
0234: }
0235:
0236: // by-copy geometry
0237: void buildIndexedGeometry(Context ctx, GeometryArrayRetained geo,
0238: int geo_type, boolean isNonUniformScale,
0239: boolean updateAlpha, float alpha,
0240: boolean ignoreVertexColors, int initialIndexIndex,
0241: int validIndexCount, int vertexCount, int vformat,
0242: int vertexAttrCount, int[] vertexAttrSizes,
0243: int texCoordSetCount, int[] texCoordSetMap,
0244: int texCoordSetMapLen, int[] texCoordSetMapOffset,
0245: double[] xform, double[] nxform, float[] varray,
0246: int[] indexCoord) {
0247: }
0248:
0249: // ---------------------------------------------------------------------
0250:
0251: //
0252: // GraphicsContext3D methods
0253: //
0254:
0255: void readRaster(Context ctx, int type, int xSrcOffset,
0256: int ySrcOffset, int width, int height, int hCanvas,
0257: int imageDataType, int imageFormat, Object imageBuffer,
0258: int depthFormat, Object depthBuffer) {
0259:
0260: }
0261:
0262: // ---------------------------------------------------------------------
0263:
0264: //
0265: // CgShaderProgramRetained methods
0266: //
0267:
0268: // ShaderAttributeValue methods
0269:
0270: ShaderError setCgUniform1i(Context ctx,
0271: ShaderProgramId shaderProgramId,
0272: ShaderAttrLoc uniformLocation, int value) {
0273: return null;
0274: }
0275:
0276: ShaderError setCgUniform1f(Context ctx,
0277: ShaderProgramId shaderProgramId,
0278: ShaderAttrLoc uniformLocation, float value) {
0279: return null;
0280: }
0281:
0282: ShaderError setCgUniform2i(Context ctx,
0283: ShaderProgramId shaderProgramId,
0284: ShaderAttrLoc uniformLocation, int[] value) {
0285: return null;
0286: }
0287:
0288: ShaderError setCgUniform2f(Context ctx,
0289: ShaderProgramId shaderProgramId,
0290: ShaderAttrLoc uniformLocation, float[] value) {
0291: return null;
0292: }
0293:
0294: ShaderError setCgUniform3i(Context ctx,
0295: ShaderProgramId shaderProgramId,
0296: ShaderAttrLoc uniformLocation, int[] value) {
0297: return null;
0298: }
0299:
0300: ShaderError setCgUniform3f(Context ctx,
0301: ShaderProgramId shaderProgramId,
0302: ShaderAttrLoc uniformLocation, float[] value) {
0303: return null;
0304: }
0305:
0306: ShaderError setCgUniform4i(Context ctx,
0307: ShaderProgramId shaderProgramId,
0308: ShaderAttrLoc uniformLocation, int[] value) {
0309: return null;
0310: }
0311:
0312: ShaderError setCgUniform4f(Context ctx,
0313: ShaderProgramId shaderProgramId,
0314: ShaderAttrLoc uniformLocation, float[] value) {
0315: return null;
0316: }
0317:
0318: ShaderError setCgUniformMatrix3f(Context ctx,
0319: ShaderProgramId shaderProgramId,
0320: ShaderAttrLoc uniformLocation, float[] value) {
0321: return null;
0322: }
0323:
0324: ShaderError setCgUniformMatrix4f(Context ctx,
0325: ShaderProgramId shaderProgramId,
0326: ShaderAttrLoc uniformLocation, float[] value) {
0327: return null;
0328: }
0329:
0330: // ShaderAttributeArray methods
0331:
0332: ShaderError setCgUniform1iArray(Context ctx,
0333: ShaderProgramId shaderProgramId,
0334: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0335: return null;
0336: }
0337:
0338: ShaderError setCgUniform1fArray(Context ctx,
0339: ShaderProgramId shaderProgramId,
0340: ShaderAttrLoc uniformLocation, int numElements,
0341: float[] value) {
0342: return null;
0343: }
0344:
0345: ShaderError setCgUniform2iArray(Context ctx,
0346: ShaderProgramId shaderProgramId,
0347: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0348: return null;
0349: }
0350:
0351: ShaderError setCgUniform2fArray(Context ctx,
0352: ShaderProgramId shaderProgramId,
0353: ShaderAttrLoc uniformLocation, int numElements,
0354: float[] value) {
0355: return null;
0356: }
0357:
0358: ShaderError setCgUniform3iArray(Context ctx,
0359: ShaderProgramId shaderProgramId,
0360: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0361: return null;
0362: }
0363:
0364: ShaderError setCgUniform3fArray(Context ctx,
0365: ShaderProgramId shaderProgramId,
0366: ShaderAttrLoc uniformLocation, int numElements,
0367: float[] value) {
0368: return null;
0369: }
0370:
0371: ShaderError setCgUniform4iArray(Context ctx,
0372: ShaderProgramId shaderProgramId,
0373: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0374: return null;
0375: }
0376:
0377: ShaderError setCgUniform4fArray(Context ctx,
0378: ShaderProgramId shaderProgramId,
0379: ShaderAttrLoc uniformLocation, int numElements,
0380: float[] value) {
0381: return null;
0382: }
0383:
0384: ShaderError setCgUniformMatrix3fArray(Context ctx,
0385: ShaderProgramId shaderProgramId,
0386: ShaderAttrLoc uniformLocation, int numElements,
0387: float[] value) {
0388: return null;
0389: }
0390:
0391: ShaderError setCgUniformMatrix4fArray(Context ctx,
0392: ShaderProgramId shaderProgramId,
0393: ShaderAttrLoc uniformLocation, int numElements,
0394: float[] value) {
0395: return null;
0396: }
0397:
0398: // interfaces for shader compilation, etc.
0399: ShaderError createCgShader(Context ctx, int shaderType,
0400: ShaderId[] shaderId) {
0401: return null;
0402: }
0403:
0404: ShaderError destroyCgShader(Context ctx, ShaderId shaderId) {
0405: return null;
0406: }
0407:
0408: ShaderError compileCgShader(Context ctx, ShaderId shaderId,
0409: String program) {
0410: return null;
0411: }
0412:
0413: ShaderError createCgShaderProgram(Context ctx,
0414: ShaderProgramId[] shaderProgramId) {
0415: return null;
0416: }
0417:
0418: ShaderError destroyCgShaderProgram(Context ctx,
0419: ShaderProgramId shaderProgramId) {
0420: return null;
0421: }
0422:
0423: ShaderError linkCgShaderProgram(Context ctx,
0424: ShaderProgramId shaderProgramId, ShaderId[] shaderIds) {
0425: return null;
0426: }
0427:
0428: void lookupCgVertexAttrNames(Context ctx,
0429: ShaderProgramId shaderProgramId, int numAttrNames,
0430: String[] attrNames, boolean[] errArr) {
0431: }
0432:
0433: void lookupCgShaderAttrNames(Context ctx,
0434: ShaderProgramId shaderProgramId, int numAttrNames,
0435: String[] attrNames, ShaderAttrLoc[] locArr, int[] typeArr,
0436: int[] sizeArr, boolean[] isArrayArr) {
0437: }
0438:
0439: ShaderError useCgShaderProgram(Context ctx,
0440: ShaderProgramId shaderProgramId) {
0441: return null;
0442: }
0443:
0444: // ---------------------------------------------------------------------
0445:
0446: //
0447: // GLSLShaderProgramRetained methods
0448: //
0449:
0450: // ShaderAttributeValue methods
0451:
0452: ShaderError setGLSLUniform1i(Context ctx,
0453: ShaderProgramId shaderProgramId,
0454: ShaderAttrLoc uniformLocation, int value) {
0455: return null;
0456: }
0457:
0458: ShaderError setGLSLUniform1f(Context ctx,
0459: ShaderProgramId shaderProgramId,
0460: ShaderAttrLoc uniformLocation, float value) {
0461: return null;
0462: }
0463:
0464: ShaderError setGLSLUniform2i(Context ctx,
0465: ShaderProgramId shaderProgramId,
0466: ShaderAttrLoc uniformLocation, int[] value) {
0467: return null;
0468: }
0469:
0470: ShaderError setGLSLUniform2f(Context ctx,
0471: ShaderProgramId shaderProgramId,
0472: ShaderAttrLoc uniformLocation, float[] value) {
0473: return null;
0474: }
0475:
0476: ShaderError setGLSLUniform3i(Context ctx,
0477: ShaderProgramId shaderProgramId,
0478: ShaderAttrLoc uniformLocation, int[] value) {
0479: return null;
0480: }
0481:
0482: ShaderError setGLSLUniform3f(Context ctx,
0483: ShaderProgramId shaderProgramId,
0484: ShaderAttrLoc uniformLocation, float[] value) {
0485: return null;
0486: }
0487:
0488: ShaderError setGLSLUniform4i(Context ctx,
0489: ShaderProgramId shaderProgramId,
0490: ShaderAttrLoc uniformLocation, int[] value) {
0491: return null;
0492: }
0493:
0494: ShaderError setGLSLUniform4f(Context ctx,
0495: ShaderProgramId shaderProgramId,
0496: ShaderAttrLoc uniformLocation, float[] value) {
0497: return null;
0498: }
0499:
0500: ShaderError setGLSLUniformMatrix3f(Context ctx,
0501: ShaderProgramId shaderProgramId,
0502: ShaderAttrLoc uniformLocation, float[] value) {
0503: return null;
0504: }
0505:
0506: ShaderError setGLSLUniformMatrix4f(Context ctx,
0507: ShaderProgramId shaderProgramId,
0508: ShaderAttrLoc uniformLocation, float[] value) {
0509: return null;
0510: }
0511:
0512: // ShaderAttributeArray methods
0513:
0514: ShaderError setGLSLUniform1iArray(Context ctx,
0515: ShaderProgramId shaderProgramId,
0516: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0517: return null;
0518: }
0519:
0520: ShaderError setGLSLUniform1fArray(Context ctx,
0521: ShaderProgramId shaderProgramId,
0522: ShaderAttrLoc uniformLocation, int numElements,
0523: float[] value) {
0524: return null;
0525: }
0526:
0527: ShaderError setGLSLUniform2iArray(Context ctx,
0528: ShaderProgramId shaderProgramId,
0529: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0530: return null;
0531: }
0532:
0533: ShaderError setGLSLUniform2fArray(Context ctx,
0534: ShaderProgramId shaderProgramId,
0535: ShaderAttrLoc uniformLocation, int numElements,
0536: float[] value) {
0537: return null;
0538: }
0539:
0540: ShaderError setGLSLUniform3iArray(Context ctx,
0541: ShaderProgramId shaderProgramId,
0542: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0543: return null;
0544: }
0545:
0546: ShaderError setGLSLUniform3fArray(Context ctx,
0547: ShaderProgramId shaderProgramId,
0548: ShaderAttrLoc uniformLocation, int numElements,
0549: float[] value) {
0550: return null;
0551: }
0552:
0553: ShaderError setGLSLUniform4iArray(Context ctx,
0554: ShaderProgramId shaderProgramId,
0555: ShaderAttrLoc uniformLocation, int numElements, int[] value) {
0556: return null;
0557: }
0558:
0559: ShaderError setGLSLUniform4fArray(Context ctx,
0560: ShaderProgramId shaderProgramId,
0561: ShaderAttrLoc uniformLocation, int numElements,
0562: float[] value) {
0563: return null;
0564: }
0565:
0566: ShaderError setGLSLUniformMatrix3fArray(Context ctx,
0567: ShaderProgramId shaderProgramId,
0568: ShaderAttrLoc uniformLocation, int numElements,
0569: float[] value) {
0570: return null;
0571: }
0572:
0573: ShaderError setGLSLUniformMatrix4fArray(Context ctx,
0574: ShaderProgramId shaderProgramId,
0575: ShaderAttrLoc uniformLocation, int numElements,
0576: float[] value) {
0577: return null;
0578: }
0579:
0580: // interfaces for shader compilation, etc.
0581: ShaderError createGLSLShader(Context ctx, int shaderType,
0582: ShaderId[] shaderId) {
0583: return null;
0584: }
0585:
0586: ShaderError destroyGLSLShader(Context ctx, ShaderId shaderId) {
0587: return null;
0588: }
0589:
0590: ShaderError compileGLSLShader(Context ctx, ShaderId shaderId,
0591: String program) {
0592: return null;
0593: }
0594:
0595: ShaderError createGLSLShaderProgram(Context ctx,
0596: ShaderProgramId[] shaderProgramId) {
0597: return null;
0598: }
0599:
0600: ShaderError destroyGLSLShaderProgram(Context ctx,
0601: ShaderProgramId shaderProgramId) {
0602: return null;
0603: }
0604:
0605: ShaderError linkGLSLShaderProgram(Context ctx,
0606: ShaderProgramId shaderProgramId, ShaderId[] shaderIds) {
0607: return null;
0608: }
0609:
0610: ShaderError bindGLSLVertexAttrName(Context ctx,
0611: ShaderProgramId shaderProgramId, String attrName,
0612: int attrIndex) {
0613: return null;
0614: }
0615:
0616: void lookupGLSLShaderAttrNames(Context ctx,
0617: ShaderProgramId shaderProgramId, int numAttrNames,
0618: String[] attrNames, ShaderAttrLoc[] locArr, int[] typeArr,
0619: int[] sizeArr, boolean[] isArrayArr) {
0620: }
0621:
0622: ShaderError useGLSLShaderProgram(Context ctx,
0623: ShaderProgramId shaderProgramId) {
0624: return null;
0625: }
0626:
0627: // ---------------------------------------------------------------------
0628:
0629: //
0630: // Renderer methods
0631: //
0632:
0633: void cleanupRenderer() {
0634: }
0635:
0636: // ---------------------------------------------------------------------
0637:
0638: //
0639: // ColoringAttributesRetained methods
0640: //
0641:
0642: void updateColoringAttributes(Context ctx, float dRed,
0643: float dGreen, float dBlue, float red, float green,
0644: float blue, float alpha, boolean lEnable, int shadeModel) {
0645: }
0646:
0647: // ---------------------------------------------------------------------
0648:
0649: //
0650: // DirectionalLightRetained methods
0651: //
0652:
0653: void updateDirectionalLight(Context ctx, int lightSlot, float red,
0654: float green, float blue, float x, float y, float z) {
0655: }
0656:
0657: // ---------------------------------------------------------------------
0658:
0659: //
0660: // PointLightRetained methods
0661: //
0662:
0663: void updatePointLight(Context ctx, int lightSlot, float red,
0664: float green, float blue, float ax, float ay, float az,
0665: float px, float py, float pz) {
0666: }
0667:
0668: // ---------------------------------------------------------------------
0669:
0670: //
0671: // SpotLightRetained methods
0672: //
0673:
0674: void updateSpotLight(Context ctx, int lightSlot, float red,
0675: float green, float blue, float ax, float ay, float az,
0676: float px, float py, float pz, float spreadAngle,
0677: float concentration, float dx, float dy, float dz) {
0678: }
0679:
0680: // ---------------------------------------------------------------------
0681:
0682: //
0683: // ExponentialFogRetained methods
0684: //
0685:
0686: void updateExponentialFog(Context ctx, float red, float green,
0687: float blue, float density) {
0688: }
0689:
0690: // ---------------------------------------------------------------------
0691:
0692: //
0693: // LinearFogRetained methods
0694: //
0695:
0696: void updateLinearFog(Context ctx, float red, float green,
0697: float blue, double fdist, double bdist) {
0698: }
0699:
0700: // ---------------------------------------------------------------------
0701:
0702: //
0703: // LineAttributesRetained methods
0704: //
0705:
0706: void updateLineAttributes(Context ctx, float lineWidth,
0707: int linePattern, int linePatternMask,
0708: int linePatternScaleFactor, boolean lineAntialiasing) {
0709: }
0710:
0711: // ---------------------------------------------------------------------
0712:
0713: //
0714: // MaterialRetained methods
0715: //
0716:
0717: void updateMaterial(Context ctx, float red, float green,
0718: float blue, float alpha, float ared, float agreen,
0719: float ablue, float ered, float egreen, float eblue,
0720: float dred, float dgreen, float dblue, float sred,
0721: float sgreen, float sblue, float shininess,
0722: int colorTarget, boolean enable) {
0723: }
0724:
0725: // ---------------------------------------------------------------------
0726:
0727: //
0728: // ModelClipRetained methods
0729: //
0730:
0731: void updateModelClip(Context ctx, int planeNum, boolean enableFlag,
0732: double A, double B, double C, double D) {
0733: }
0734:
0735: // ---------------------------------------------------------------------
0736:
0737: //
0738: // PointAttributesRetained methods
0739: //
0740:
0741: void updatePointAttributes(Context ctx, float pointSize,
0742: boolean pointAntialiasing) {
0743: }
0744:
0745: // ---------------------------------------------------------------------
0746:
0747: //
0748: // PolygonAttributesRetained methods
0749: //
0750:
0751: void updatePolygonAttributes(Context ctx, int polygonMode,
0752: int cullFace, boolean backFaceNormalFlip,
0753: float polygonOffset, float polygonOffsetFactor) {
0754: }
0755:
0756: // ---------------------------------------------------------------------
0757:
0758: //
0759: // RenderingAttributesRetained methods
0760: //
0761:
0762: void updateRenderingAttributes(Context ctx,
0763: boolean depthBufferWriteEnableOverride,
0764: boolean depthBufferEnableOverride,
0765: boolean depthBufferEnable, boolean depthBufferWriteEnable,
0766: int depthTestFunction, float alphaTestValue,
0767: int alphaTestFunction, boolean ignoreVertexColors,
0768: boolean rasterOpEnable, int rasterOp,
0769: boolean userStencilAvailable, boolean stencilEnable,
0770: int stencilFailOp, int stencilZFailOp, int stencilZPassOp,
0771: int stencilFunction, int stencilReferenceValue,
0772: int stencilCompareMask, int stencilWriteMask) {
0773: }
0774:
0775: // ---------------------------------------------------------------------
0776:
0777: //
0778: // TexCoordGenerationRetained methods
0779: //
0780:
0781: /**
0782: * This method updates the native context:
0783: * trans contains eyeTovworld transform in d3d
0784: * trans contains vworldToEye transform in ogl
0785: */
0786: void updateTexCoordGeneration(Context ctx, boolean enable,
0787: int genMode, int format, float planeSx, float planeSy,
0788: float planeSz, float planeSw, float planeTx, float planeTy,
0789: float planeTz, float planeTw, float planeRx, float planeRy,
0790: float planeRz, float planeRw, float planeQx, float planeQy,
0791: float planeQz, float planeQw, double[] trans) {
0792: }
0793:
0794: // ---------------------------------------------------------------------
0795:
0796: //
0797: // TransparencyAttributesRetained methods
0798: //
0799:
0800: void updateTransparencyAttributes(Context ctx, float alpha,
0801: int geometryType, int polygonMode, boolean lineAA,
0802: boolean pointAA, int transparencyMode,
0803: int srcBlendFunction, int dstBlendFunction) {
0804: }
0805:
0806: // ---------------------------------------------------------------------
0807:
0808: //
0809: // TextureAttributesRetained methods
0810: //
0811:
0812: void updateTextureAttributes(Context ctx, double[] transform,
0813: boolean isIdentity, int textureMode,
0814: int perspCorrectionMode, float red, float green,
0815: float blue, float alpha, int textureFormat) {
0816: }
0817:
0818: void updateRegisterCombiners(Context ctx, double[] transform,
0819: boolean isIdentity, int textureMode,
0820: int perspCorrectionMode, float red, float green,
0821: float blue, float alpha, int textureFormat,
0822: int combineRgbMode, int combineAlphaMode,
0823: int[] combineRgbSrc, int[] combineAlphaSrc,
0824: int[] combineRgbFcn, int[] combineAlphaFcn,
0825: int combineRgbScale, int combineAlphaScale) {
0826: }
0827:
0828: void updateTextureColorTable(Context ctx, int numComponents,
0829: int colorTableSize, int[] colorTable) {
0830: }
0831:
0832: void updateCombiner(Context ctx, int combineRgbMode,
0833: int combineAlphaMode, int[] combineRgbSrc,
0834: int[] combineAlphaSrc, int[] combineRgbFcn,
0835: int[] combineAlphaFcn, int combineRgbScale,
0836: int combineAlphaScale) {
0837: }
0838:
0839: // ---------------------------------------------------------------------
0840:
0841: //
0842: // TextureUnitStateRetained methods
0843: //
0844:
0845: void updateTextureUnitState(Context ctx, int unitIndex,
0846: boolean enableFlag) {
0847: }
0848:
0849: // ---------------------------------------------------------------------
0850:
0851: //
0852: // TextureRetained methods
0853: // Texture2DRetained methods
0854: //
0855:
0856: void bindTexture2D(Context ctx, int objectId, boolean enable) {
0857: }
0858:
0859: void updateTexture2DImage(Context ctx, int numLevels, int level,
0860: int textureFormat, int imageFormat, int width, int height,
0861: int boundaryWidth, int imageDataType, Object data,
0862: boolean useAutoMipMap) {
0863: }
0864:
0865: void updateTexture2DSubImage(Context ctx, int level, int xoffset,
0866: int yoffset, int textureFormat, int imageFormat,
0867: int imgXOffset, int imgYOffset, int tilew, int width,
0868: int height, int imageDataType, Object data,
0869: boolean useAutoMipMap) {
0870: }
0871:
0872: void updateTexture2DLodRange(Context ctx, int baseLevel,
0873: int maximumLevel, float minimumLod, float maximumLod) {
0874: }
0875:
0876: void updateTexture2DLodOffset(Context ctx, float lodOffsetX,
0877: float lodOffsetY, float lodOffsetZ) {
0878: }
0879:
0880: void updateTexture2DBoundary(Context ctx, int boundaryModeS,
0881: int boundaryModeT, float boundaryRed, float boundaryGreen,
0882: float boundaryBlue, float boundaryAlpha) {
0883: }
0884:
0885: void updateTexture2DFilterModes(Context ctx, int minFilter,
0886: int magFilter) {
0887: }
0888:
0889: void updateTexture2DSharpenFunc(Context ctx,
0890: int numSharpenTextureFuncPts, float[] sharpenTextureFuncPts) {
0891: }
0892:
0893: void updateTexture2DFilter4Func(Context ctx, int numFilter4FuncPts,
0894: float[] filter4FuncPts) {
0895: }
0896:
0897: void updateTexture2DAnisotropicFilter(Context ctx, float degree) {
0898: }
0899:
0900: // ---------------------------------------------------------------------
0901:
0902: //
0903: // Texture3DRetained methods
0904: //
0905:
0906: void bindTexture3D(Context ctx, int objectId, boolean enable) {
0907: }
0908:
0909: void updateTexture3DImage(Context ctx, int numLevels, int level,
0910: int textureFormat, int imageFormat, int width, int height,
0911: int depth, int boundaryWidth, int imageDataType,
0912: Object imageData, boolean useAutoMipMap) {
0913: }
0914:
0915: void updateTexture3DSubImage(Context ctx, int level, int xoffset,
0916: int yoffset, int zoffset, int textureFormat,
0917: int imageFormat, int imgXoffset, int imgYoffset,
0918: int imgZoffset, int tilew, int tileh, int width,
0919: int height, int depth, int imageTypeData, Object imageData,
0920: boolean useAutoMipMap) {
0921: }
0922:
0923: void updateTexture3DLodRange(Context ctx, int baseLevel,
0924: int maximumLevel, float minimumLod, float maximumLod) {
0925: }
0926:
0927: void updateTexture3DLodOffset(Context ctx, float lodOffsetX,
0928: float lodOffsetY, float lodOffsetZ) {
0929: }
0930:
0931: void updateTexture3DBoundary(Context ctx, int boundaryModeS,
0932: int boundaryModeT, int boundaryModeR, float boundaryRed,
0933: float boundaryGreen, float boundaryBlue, float boundaryAlpha) {
0934: }
0935:
0936: void updateTexture3DFilterModes(Context ctx, int minFilter,
0937: int magFilter) {
0938: }
0939:
0940: void updateTexture3DSharpenFunc(Context ctx,
0941: int numSharpenTextureFuncPts, float[] sharpenTextureFuncPts) {
0942: }
0943:
0944: void updateTexture3DFilter4Func(Context ctx, int numFilter4FuncPts,
0945: float[] filter4FuncPts) {
0946: }
0947:
0948: void updateTexture3DAnisotropicFilter(Context ctx, float degree) {
0949: }
0950:
0951: // ---------------------------------------------------------------------
0952:
0953: //
0954: // TextureCubeMapRetained methods
0955: //
0956:
0957: void bindTextureCubeMap(Context ctx, int objectId, boolean enable) {
0958: }
0959:
0960: void updateTextureCubeMapImage(Context ctx, int face,
0961: int numLevels, int level, int textureFormat,
0962: int imageFormat, int width, int height, int boundaryWidth,
0963: int imageDataType, Object imageData, boolean useAutoMipMap) {
0964: }
0965:
0966: void updateTextureCubeMapSubImage(Context ctx, int face, int level,
0967: int xoffset, int yoffset, int textureFormat,
0968: int imageFormat, int imgXOffset, int imgYOffset, int tilew,
0969: int width, int height, int imageDataType, Object imageData,
0970: boolean useAutoMipMap) {
0971: }
0972:
0973: void updateTextureCubeMapLodRange(Context ctx, int baseLevel,
0974: int maximumLevel, float minimumLod, float maximumLod) {
0975: }
0976:
0977: void updateTextureCubeMapLodOffset(Context ctx, float lodOffsetX,
0978: float lodOffsetY, float lodOffsetZ) {
0979: }
0980:
0981: void updateTextureCubeMapBoundary(Context ctx, int boundaryModeS,
0982: int boundaryModeT, float boundaryRed, float boundaryGreen,
0983: float boundaryBlue, float boundaryAlpha) {
0984: }
0985:
0986: void updateTextureCubeMapFilterModes(Context ctx, int minFilter,
0987: int magFilter) {
0988: }
0989:
0990: void updateTextureCubeMapSharpenFunc(Context ctx,
0991: int numSharpenTextureFuncPts, float[] sharpenTextureFuncPts) {
0992: }
0993:
0994: void updateTextureCubeMapFilter4Func(Context ctx,
0995: int numFilter4FuncPts, float[] filter4FuncPts) {
0996: }
0997:
0998: void updateTextureCubeMapAnisotropicFilter(Context ctx, float degree) {
0999: }
1000:
1001: // ---------------------------------------------------------------------
1002:
1003: //
1004: // MasterControl methods
1005: //
1006:
1007: // Method to return the AWT object
1008: long getAWT() {
1009: return 0L;
1010: }
1011:
1012: // Method to initialize the native J3D library
1013: boolean initializeJ3D(boolean disableXinerama) {
1014: return true;
1015: }
1016:
1017: // Maximum lights supported by the native API
1018: int getMaximumLights() {
1019: return 8;
1020: }
1021:
1022: // ---------------------------------------------------------------------
1023:
1024: //
1025: // Canvas3D methods - native wrappers
1026: //
1027:
1028: // This is the native method for creating the underlying graphics context.
1029: Context createNewContext(Canvas3D cv, long display,
1030: Drawable drawable, long fbConfig, Context shareCtx,
1031: boolean isSharedCtx, boolean offScreen,
1032: boolean glslLibraryAvailable, boolean cgLibraryAvailable) {
1033: return new NoopContext();
1034: }
1035:
1036: void createQueryContext(Canvas3D cv, long display,
1037: Drawable drawable, long fbConfig, boolean offScreen,
1038: int width, int height, boolean glslLibraryAvailable,
1039: boolean cgLibraryAvailable) {
1040: }
1041:
1042: // This is the native for creating offscreen buffer
1043: Drawable createOffScreenBuffer(Canvas3D cv, Context ctx,
1044: long display, long fbConfig, int width, int height) {
1045: return null;
1046: }
1047:
1048: void destroyOffScreenBuffer(Canvas3D cv, Context ctx, long display,
1049: long fbConfig, Drawable drawable) {
1050: }
1051:
1052: // This is the native for reading the image from the offscreen buffer
1053: void readOffScreenBuffer(Canvas3D cv, Context ctx, int format,
1054: int type, Object data, int width, int height) {
1055: }
1056:
1057: // The native method for swapBuffers
1058: int swapBuffers(Canvas3D cv, Context ctx, long dpy,
1059: Drawable drawable) {
1060: return 0;
1061: }
1062:
1063: // notify D3D that Canvas is resize
1064: int resizeD3DCanvas(Canvas3D cv, Context ctx) {
1065: return 0;
1066: }
1067:
1068: // notify D3D to toggle between FullScreen and window mode
1069: int toggleFullScreenMode(Canvas3D cv, Context ctx) {
1070: return 0;
1071: }
1072:
1073: // native method for setting Material when no material is present
1074: void updateMaterialColor(Context ctx, float r, float g, float b,
1075: float a) {
1076: }
1077:
1078: void destroyContext(long display, Drawable drawable, Context ctx) {
1079: }
1080:
1081: // This is the native method for doing accumulation.
1082: void accum(Context ctx, float value) {
1083: }
1084:
1085: // This is the native method for doing accumulation return.
1086: void accumReturn(Context ctx) {
1087: }
1088:
1089: // This is the native method for clearing the accumulation buffer.
1090: void clearAccum(Context ctx) {
1091: }
1092:
1093: // This is the native method for getting the number of lights the underlying
1094: // native library can support.
1095: int getNumCtxLights(Context ctx) {
1096: return 0;
1097: }
1098:
1099: // Native method for decal 1st child setup
1100: boolean decal1stChildSetup(Context ctx) {
1101: return false;
1102: }
1103:
1104: // Native method for decal nth child setup
1105: void decalNthChildSetup(Context ctx) {
1106: }
1107:
1108: // Native method for decal reset
1109: void decalReset(Context ctx, boolean depthBufferEnable) {
1110: }
1111:
1112: // Native method for decal reset
1113: void ctxUpdateEyeLightingEnable(Context ctx,
1114: boolean localEyeLightingEnable) {
1115: }
1116:
1117: // The following three methods are used in multi-pass case
1118:
1119: // native method for setting blend color
1120: void setBlendColor(Context ctx, float red, float green, float blue,
1121: float alpha) {
1122: }
1123:
1124: // native method for setting blend func
1125: void setBlendFunc(Context ctx, int src, int dst) {
1126: }
1127:
1128: // native method for setting fog enable flag
1129: void setFogEnableFlag(Context ctx, boolean enableFlag) {
1130: }
1131:
1132: // Setup the full scene antialising in D3D and ogl when GL_ARB_multisamle supported
1133: void setFullSceneAntialiasing(Context ctx, boolean enable) {
1134: }
1135:
1136: void setGlobalAlpha(Context ctx, float alpha) {
1137: }
1138:
1139: // Native method to update separate specular color control
1140: void updateSeparateSpecularColorEnable(Context ctx, boolean control) {
1141: }
1142:
1143: // Initialization for D3D when scene begin
1144: void beginScene(Context ctx) {
1145: }
1146:
1147: void endScene(Context ctx) {
1148: }
1149:
1150: // True under Solaris,
1151: // False under windows when display mode <= 8 bit
1152: boolean validGraphicsMode() {
1153: return true;
1154: }
1155:
1156: // native method for setting light enables
1157: void setLightEnables(Context ctx, long enableMask, int maxLights) {
1158: }
1159:
1160: // native method for setting scene ambient
1161: void setSceneAmbient(Context ctx, float red, float green, float blue) {
1162: }
1163:
1164: // native method for disabling fog
1165: void disableFog(Context ctx) {
1166: }
1167:
1168: // native method for disabling modelClip
1169: void disableModelClip(Context ctx) {
1170: }
1171:
1172: // native method for setting default RenderingAttributes
1173: void resetRenderingAttributes(Context ctx,
1174: boolean depthBufferWriteEnableOverride,
1175: boolean depthBufferEnableOverride) {
1176: }
1177:
1178: // native method for setting default texture
1179: void resetTextureNative(Context ctx, int texUnitIndex) {
1180: }
1181:
1182: // native method for activating a particular texture unit
1183: void activeTextureUnit(Context ctx, int texUnitIndex) {
1184: }
1185:
1186: // native method for setting default TexCoordGeneration
1187: void resetTexCoordGeneration(Context ctx) {
1188: }
1189:
1190: // native method for setting default TextureAttributes
1191: void resetTextureAttributes(Context ctx) {
1192: }
1193:
1194: // native method for setting default PolygonAttributes
1195: void resetPolygonAttributes(Context ctx) {
1196: }
1197:
1198: // native method for setting default LineAttributes
1199: void resetLineAttributes(Context ctx) {
1200: }
1201:
1202: // native method for setting default PointAttributes
1203: void resetPointAttributes(Context ctx) {
1204: }
1205:
1206: // native method for setting default TransparencyAttributes
1207: void resetTransparency(Context ctx, int geometryType,
1208: int polygonMode, boolean lineAA, boolean pointAA) {
1209: }
1210:
1211: // native method for setting default ColoringAttributes
1212: void resetColoringAttributes(Context ctx, float r, float g,
1213: float b, float a, boolean enableLight) {
1214: }
1215:
1216: /**
1217: * This native method makes sure that the rendering for this canvas
1218: * gets done now.
1219: */
1220: void syncRender(Context ctx, boolean wait) {
1221: }
1222:
1223: // The native method that sets this ctx to be the current one
1224: boolean useCtx(Context ctx, long display, Drawable drawable) {
1225: return true;
1226: }
1227:
1228: void clear(Context ctx, float r, float g, float b,
1229: boolean clearStencil) {
1230:
1231: }
1232:
1233: void textureFillBackground(Context ctx, float texMinU,
1234: float texMaxU, float texMinV, float texMaxV, float mapMinX,
1235: float mapMaxX, float mapMinY, float mapMaxY,
1236: boolean useBiliearFilter) {
1237:
1238: }
1239:
1240: void textureFillRaster(Context ctx, float texMinU, float texMaxU,
1241: float texMinV, float texMaxV, float mapMinX, float mapMaxX,
1242: float mapMinY, float mapMaxY, float mapZ, float alpha,
1243: boolean useBiliearFilter) {
1244:
1245: }
1246:
1247: void executeRasterDepth(Context ctx, float posX, float posY,
1248: float posZ, int srcOffsetX, int srcOffsetY,
1249: int rasterWidth, int rasterHeight, int depthWidth,
1250: int depthHeight, int depthType, Object depthData) {
1251:
1252: }
1253:
1254: // The native method for setting the ModelView matrix.
1255: void setModelViewMatrix(Context ctx, double[] viewMatrix,
1256: double[] modelMatrix) {
1257: }
1258:
1259: // The native method for setting the Projection matrix.
1260: void setProjectionMatrix(Context ctx, double[] projMatrix) {
1261: }
1262:
1263: // The native method for setting the Viewport.
1264: void setViewport(Context ctx, int x, int y, int width, int height) {
1265: }
1266:
1267: // used for display Lists
1268: void newDisplayList(Context ctx, int displayListId) {
1269: }
1270:
1271: void endDisplayList(Context ctx) {
1272: }
1273:
1274: void callDisplayList(Context ctx, int id, boolean isNonUniformScale) {
1275: }
1276:
1277: void freeDisplayList(Context ctx, int id) {
1278: }
1279:
1280: void freeTexture(Context ctx, int id) {
1281: }
1282:
1283: void texturemapping(Context ctx, int px, int py, int xmin,
1284: int ymin, int xmax, int ymax, int texWidth, int texHeight,
1285: int rasWidth, int format, int objectId, byte[] image,
1286: int winWidth, int winHeight) {
1287: }
1288:
1289: boolean initTexturemapping(Context ctx, int texWidth,
1290: int texHeight, int objectId) {
1291: return true;
1292: }
1293:
1294: // Set internal render mode to one of FIELD_ALL, FIELD_LEFT or
1295: // FIELD_RIGHT. Note that it is up to the caller to ensure that
1296: // stereo is available before setting the mode to FIELD_LEFT or
1297: // FIELD_RIGHT. The boolean isTRUE for double buffered mode, FALSE
1298: // foe single buffering.
1299: void setRenderMode(Context ctx, int mode, boolean doubleBuffer) {
1300: }
1301:
1302: // Set glDepthMask.
1303: void setDepthBufferWriteEnable(Context ctx, boolean mode) {
1304: }
1305:
1306: // ---------------------------------------------------------------------
1307:
1308: //
1309: // Canvas3D / GraphicsConfigTemplate3D methods - logic dealing with
1310: // native graphics configuration or drawing surface
1311: //
1312:
1313: // Return a graphics config based on the one passed in. Note that we can
1314: // assert that the input config is non-null and was created from a
1315: // GraphicsConfigTemplate3D.
1316: // This method must return a valid GraphicsConfig, or else it must throw
1317: // an exception if one cannot be returned.
1318: GraphicsConfiguration getGraphicsConfig(
1319: GraphicsConfiguration gconfig) {
1320: System.err.println("NoopPipeline.getGraphicsConfig()");
1321: return gconfig;
1322: }
1323:
1324: // Get the native FBconfig pointer
1325: long getFbConfig(GraphicsConfigInfo gcInfo) {
1326: return 0L;
1327: }
1328:
1329: // Get best graphics config from pipeline
1330: GraphicsConfiguration getBestConfiguration(
1331: GraphicsConfigTemplate3D gct, GraphicsConfiguration[] gc) {
1332:
1333: GraphicsConfiguration gc1 = GraphicsEnvironment
1334: .getLocalGraphicsEnvironment().getDefaultScreenDevice()
1335: .getDefaultConfiguration();
1336: // We need to cache the GraphicsTemplate3D
1337: synchronized (Canvas3D.graphicsConfigTable) {
1338: if (Canvas3D.graphicsConfigTable.get(gc1) == null) {
1339: GraphicsConfigInfo gcInfo = new GraphicsConfigInfo(gct);
1340: // gcInfo.setPrivateData(privateData);
1341: Canvas3D.graphicsConfigTable.put(gc1, gcInfo);
1342: }
1343: }
1344: return gc1;
1345: }
1346:
1347: // Determine whether specified graphics config is supported by pipeline
1348: boolean isGraphicsConfigSupported(GraphicsConfigTemplate3D gct,
1349: GraphicsConfiguration gc) {
1350: return true;
1351: }
1352:
1353: // Methods to get actual capabilities from Canvas3D
1354: boolean hasDoubleBuffer(Canvas3D cv) {
1355: return true;
1356: }
1357:
1358: boolean hasStereo(Canvas3D cv) {
1359: return false;
1360: }
1361:
1362: int getStencilSize(Canvas3D cv) {
1363: return 0;
1364: }
1365:
1366: boolean hasSceneAntialiasingMultisample(Canvas3D cv) {
1367: return false;
1368: }
1369:
1370: boolean hasSceneAntialiasingAccum(Canvas3D cv) {
1371: return false;
1372: }
1373:
1374: // Methods to get native WS display and screen
1375: long getDisplay() {
1376: return 0L;
1377: }
1378:
1379: int getScreen(GraphicsDevice graphicsDevice) {
1380: return 0;
1381: }
1382:
1383: // ---------------------------------------------------------------------
1384:
1385: //
1386: // DrawingSurfaceObject methods
1387: //
1388:
1389: // Method to construct a new DrawingSurfaceObject
1390: DrawingSurfaceObject createDrawingSurfaceObject(Canvas3D cv) {
1391: return new NoopDrawingSurfaceObject(cv);
1392: }
1393:
1394: // Method to free the drawing surface object
1395: void freeDrawingSurface(Canvas3D cv,
1396: DrawingSurfaceObject drawingSurfaceObject) {
1397: // This method is a no-op
1398: }
1399:
1400: // Method to free the native drawing surface object
1401: void freeDrawingSurfaceNative(Object o) {
1402: // This method is a no-op
1403: }
1404:
1405: /**
1406: * Dummy context for noop pipeline
1407: */
1408: static class NoopContext implements Context {
1409: }
1410:
1411: }
|