summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/native/d3d/Attributes.cpp24
-rw-r--r--src/native/d3d/D3dCtx.cpp143
-rw-r--r--src/native/d3d/D3dCtx.hpp19
-rw-r--r--src/native/d3d/D3dDeviceInfo.cpp23
-rw-r--r--src/native/d3d/D3dDeviceInfo.hpp6
-rw-r--r--src/native/d3d/D3dDriverInfo.cpp40
-rw-r--r--src/native/d3d/D3dDriverInfo.hpp1
-rw-r--r--src/native/d3d/D3dUtil.cpp23
-rw-r--r--src/native/d3d/GeometryArrayRetained.cpp155
-rw-r--r--src/native/d3d/NativeConfigTemplate3D.cpp104
-rw-r--r--src/native/d3d/StdAfx.h12
11 files changed, 359 insertions, 191 deletions
diff --git a/src/native/d3d/Attributes.cpp b/src/native/d3d/Attributes.cpp
index c4fd82f..359ac22 100644
--- a/src/native/d3d/Attributes.cpp
+++ b/src/native/d3d/Attributes.cpp
@@ -345,7 +345,7 @@ void JNICALL Java_javax_media_j3d_Canvas3D_setLightEnables(
#pragma warning(disable:4244) // loss of data from __int64 to int
for (int i=nlights-1; i>=0; i--) {
- device->LightEnable(i, enable_mask & (1<<i));
+ device->LightEnable(i, enable_mask & (long)(1L<<i));
}
}
@@ -492,6 +492,28 @@ void JNICALL Java_javax_media_j3d_RenderingAttributesRetained_updateNative(
break;
}
+ if (userStencilAvailable == JNI_TRUE)
+ {
+ if (stencilEnable == JNI_TRUE)
+ {
+ /*
+ glEnable(GL_STENCIL_TEST);
+
+ glStencilOp( getStencilOpValue(stencilFailOp),
+ getStencilOpValue(stencilZFailOp),
+ getStencilOpValue(stencilZPassOp));
+
+ glStencilFunc(getFunctionValue(stencilFunction),
+ stencilReferenceValue, stencilCompareMask);
+ glStencilMask(stencilWriteMask);
+ */
+
+ } else
+ {
+ // glDisable(GL_STENCIL_TEST);
+ }
+ }
+
}
diff --git a/src/native/d3d/D3dCtx.cpp b/src/native/d3d/D3dCtx.cpp
index 85c81b6..7bd4362 100644
--- a/src/native/d3d/D3dCtx.cpp
+++ b/src/native/d3d/D3dCtx.cpp
@@ -67,13 +67,19 @@ D3dCtx::D3dCtx(JNIEnv* env, jobject obj, HWND _hwnd, BOOL _offScreen,
// this is the pixelFormat return from NativeConfigTemplate.
minZDepth = vid & 0x3fffffff;
- if (vid & 0x80000000) {
- antialiasing = REQUIRED;
- } else if (vid & 0x40000000) {
- antialiasing = PREFERRED;
- } else {
- antialiasing = UNNECESSARY;
- }
+ if (vid & 0x80000000)
+ {
+ antialiasing = REQUIRED;
+ }
+ else
+ if (vid & 0x40000000)
+ {
+ antialiasing = PREFERRED;
+ }
+ else
+ {
+ antialiasing = UNNECESSARY;
+ }
setFullScreenFromProperty(env);
@@ -385,7 +391,7 @@ BOOL D3dCtx::initialize(JNIEnv *env, jobject obj)
// It is possible that last time Emulation mode is used.
// If this is the case we will try Hardware mode first.
- deviceInfo = setDeviceInfo(driverInfo, &bFullScreen, minZDepth);
+ deviceInfo = setDeviceInfo(driverInfo, &bFullScreen, minZDepth, minZDepthStencil);
if ((pD3D == NULL) || (driverInfo == NULL)) {
return false;
@@ -512,7 +518,7 @@ else
warning(CREATEDEVICEFAIL, hr);
deviceInfo = driverInfo->d3dDeviceList[DEVICE_REF];
dwBehavior = findBehavior();
- deviceInfo->findDepthStencilFormat(minZDepth);
+ deviceInfo->findDepthStencilFormat(minZDepth,minZDepthStencil);
d3dPresent.AutoDepthStencilFormat =
deviceInfo->depthStencilFormat;
if (deviceInfo->depthStencilFormat == D3DFMT_UNKNOWN) {
@@ -833,7 +839,7 @@ INT D3dCtx::resetSurface(JNIEnv *env, jobject obj)
HRESULT hr;
- deviceInfo = setDeviceInfo(driverInfo, &bFullScreen, minZDepth);
+ deviceInfo = setDeviceInfo(driverInfo, &bFullScreen, minZDepth, minZDepthStencil);
if (deviceInfo == NULL) {
return NOCHANGE;
@@ -984,54 +990,68 @@ DWORD D3dCtx::getHeight()
}
D3dDeviceInfo* D3dCtx::selectDevice(int deviceID,
- D3dDriverInfo *driverInfo,
- BOOL *bFullScreen,
- int minZDepth)
+ D3dDriverInfo *driverInfo,
+ BOOL *bFullScreen,
+ int minZDepth,
+ int minZDepthStencil)
{
D3dDeviceInfo *pDevice;
- for (int i=0; i < numDeviceTypes; i++) {
+ for (int i=0; i < numDeviceTypes; i++)
+ {
pDevice = driverInfo->d3dDeviceList[i];
if ((((deviceID == DEVICE_HAL) || (deviceID == DEVICE_HAL_TnL)) &&
(pDevice->deviceType == D3DDEVTYPE_HAL)) ||
- (deviceID == DEVICE_REF) &&
- (pDevice->deviceType == D3DDEVTYPE_REF)) {
+ (deviceID == DEVICE_REF) &&
+ (pDevice->deviceType == D3DDEVTYPE_REF))
+ {
if ((*bFullScreen && !pDevice->fullscreenCompatible) ||
- (!*bFullScreen && !pDevice->desktopCompatible)) {
- if (pDevice->deviceType == D3DDEVTYPE_HAL) {
- d3dError(HALDEVICENOTFOUND);
- } else {
- // should not happen, REF device always support
- d3dError(DEVICENOTFOUND);
- }
- exit(1);
+ (!*bFullScreen && !pDevice->desktopCompatible))
+ {
+ if (pDevice->deviceType == D3DDEVTYPE_HAL)
+ {
+ d3dError(HALDEVICENOTFOUND);
+ }
+ else
+ {
+ // should not happen, REF device always support
+ d3dError(DEVICENOTFOUND);
+ }
+ exit(1);
}
- if (pDevice->maxZBufferDepthSize == 0) {
- if (pDevice->deviceType == D3DDEVTYPE_HAL) {
- d3dError(HALNOTCOMPATIBLE);
- } else {
+ if (pDevice->maxZBufferDepthSize == 0)
+ {
+ if (pDevice->deviceType == D3DDEVTYPE_HAL)
+ {
+ d3dError(HALNOTCOMPATIBLE);
+ }
+ else
+ {
// should not happen, REF device always support
d3dError(DEVICENOTFOUND);
- }
- exit(1);
+ }
+ exit(1);
}
- if (pDevice->deviceType == D3DDEVTYPE_HAL) {
- if ((deviceID == DEVICE_HAL_TnL) &&
- !pDevice->isHardwareTnL) {
+ if (pDevice->deviceType == D3DDEVTYPE_HAL)
+ {
+ if ((deviceID == DEVICE_HAL_TnL) &&
+ !pDevice->isHardwareTnL)
+ {
d3dError(TNLHALDEVICENOTFOUND);
exit(1);
- }
- }
- pDevice->findDepthStencilFormat(minZDepth);
- if (pDevice->depthStencilFormat == D3DFMT_UNKNOWN) {
- d3dError(DEPTHSTENCILNOTFOUND);
- exit(1);
+ }
+ }
+
+ pDevice->findDepthStencilFormat(minZDepth, minZDepthStencil);
+ if (pDevice->depthStencilFormat == D3DFMT_UNKNOWN)
+ {
+ d3dError(DEPTHSTENCILNOTFOUND);
+ exit(1);
}
return pDevice;
}
}
-
// should not happen
d3dError(DEVICENOTFOUND);
exit(1);
@@ -1040,19 +1060,25 @@ D3dDeviceInfo* D3dCtx::selectDevice(int deviceID,
D3dDeviceInfo* D3dCtx::selectBestDevice(D3dDriverInfo *driverInfo,
- BOOL *bFullScreen, int minZDepth)
+ BOOL *bFullScreen,
+ int minZDepth,
+ int minZDepthStencil)
{
D3dDeviceInfo *pDevice;
D3dDeviceInfo *bestDevice = NULL;
int i;
- for (i=0; i < numDeviceTypes; i++) {
+ for (i=0; i < numDeviceTypes; i++)
+ {
pDevice = driverInfo->d3dDeviceList[i];
- if (pDevice->maxZBufferDepthSize > 0) {
- pDevice->findDepthStencilFormat(minZDepth);
+ if (pDevice->maxZBufferDepthSize > 0)
+ {
+ pDevice->findDepthStencilFormat(minZDepth, minZDepthStencil);
- if (pDevice->depthStencilFormat == D3DFMT_UNKNOWN) {
- if (pDevice->deviceType == D3DDEVTYPE_REF) {
+ if (pDevice->depthStencilFormat == D3DFMT_UNKNOWN)
+ {
+ if (pDevice->deviceType == D3DDEVTYPE_REF)
+ {
d3dError(DEPTHSTENCILNOTFOUND);
return NULL;
} else {
@@ -1640,14 +1666,23 @@ HMONITOR D3dCtx::findMonitor()
D3dDeviceInfo* D3dCtx::setDeviceInfo(D3dDriverInfo *driverInfo,
BOOL *bFullScreen,
- int minZDepth)
+ int minZDepth,
+ int minZDepthStencil)
{
- if (requiredDeviceID >= 0) {
- return selectDevice(requiredDeviceID, driverInfo,
- bFullScreen, minZDepth);
- } else {
- return selectBestDevice(driverInfo, bFullScreen,
- minZDepth);
+ if (requiredDeviceID >= 0)
+ {
+ return selectDevice(requiredDeviceID,
+ driverInfo,
+ bFullScreen,
+ minZDepth,
+ minZDepthStencil);
+ }
+ else
+ {
+ return selectBestDevice(driverInfo,
+ bFullScreen,
+ minZDepth,
+ minZDepthStencil);
}
}
@@ -2037,6 +2072,8 @@ jboolean D3dCtx::getJavaBoolEnv(JNIEnv *env, char* envStr)
+
+
/**
// this routine is not safe using current D3D routines
VOID D3dCtx::getDXVersion(CHAR* strResult)
diff --git a/src/native/d3d/D3dCtx.hpp b/src/native/d3d/D3dCtx.hpp
index 96a111a..746d459 100644
--- a/src/native/d3d/D3dCtx.hpp
+++ b/src/native/d3d/D3dCtx.hpp
@@ -97,10 +97,10 @@ public:
BOOL inToggle; // in toggle fullscreen/window mode
RECT screenRect; // coordinate of window relative to
// the whole desktop in multiple monitor
- RECT windowRect; // coordinate of window relative to
- // the current monitor desktop only
- INT minZDepth; // min Z depth set in NativeConfigTemplate
-
+ RECT windowRect; // coordinate of window relative to
+ // the current monitor desktop only
+ INT minZDepth; // min Z depth set in NativeConfigTemplate
+ INT minZDepthStencil; // min Stencil depth set in NativeConfigTemplate
DEVMODE devmode; // current display mode
DWORD antialiasing; // PREFERRED, REQUIRED or UNNECESSARY
@@ -124,6 +124,8 @@ public:
DWORD softwareVertexProcessing;
DWORD zWriteEnable;
DWORD zEnable;
+ DWORD stencilWriteEnable; // new on 1.4
+ DWORD stencilEnable; // new on 1.4
// Ambient material used when coloring Attributes
D3DMATERIAL9 ambientMaterial;
@@ -286,7 +288,8 @@ public:
VOID setDriverInfo();
static D3dDeviceInfo* setDeviceInfo(D3dDriverInfo *driverInfo,
BOOL *bFullScreen,
- int minZDepth);
+ int minZDepth,
+ int minZDepthStencil);
DWORD findBehavior();
VOID setPresentParams();
INT resetSurface(JNIEnv *env, jobject obj);
@@ -304,10 +307,12 @@ public:
static D3dDeviceInfo* selectDevice(int deviceID,
D3dDriverInfo *driverInfo,
BOOL *bFullScreen,
- int minZDepth);
+ int minZDepth,
+ int minZDepthStencil);
static D3dDeviceInfo* selectBestDevice(D3dDriverInfo *driverInfo,
BOOL *bFullScreen,
- int minZDepth);
+ int minZDepth,
+ int minZDepthStencil);
static VOID setDeviceFromProperty(JNIEnv *env);
static BOOL getSystemProperty(JNIEnv *env, char *strName, char *strValue);
static VOID setDebugProperty(JNIEnv *env);
diff --git a/src/native/d3d/D3dDeviceInfo.cpp b/src/native/d3d/D3dDeviceInfo.cpp
index 7fffdf5..796889b 100644
--- a/src/native/d3d/D3dDeviceInfo.cpp
+++ b/src/native/d3d/D3dDeviceInfo.cpp
@@ -210,18 +210,25 @@ BOOL D3dDeviceInfo::supportAntialiasing() {
}
-void D3dDeviceInfo::findDepthStencilFormat(int minZDepth)
+void D3dDeviceInfo::findDepthStencilFormat(int minZDepth, int minZDepthStencil)
{
depthStencilFormat = D3DFMT_UNKNOWN;
- for (int i=0; i < D3DDEPTHFORMATSIZE; i++) {
- if (depthFormatSupport[i]) {
+ for (int i=0; i < D3DDEPTHFORMATSIZE; i++)
+ {
+ //printf("\ndepthFormatSupport %s, %b",getPixelFormatName(d3dDepthFormat[i]), depthFormatSupport[i]);
+ if (depthFormatSupport[i])
+ {
// prefer one with stencil buffer, follow by D3DFMT_D16_LOCKABLE,
- if (d3dDepthTable[i] >= minZDepth) {
- depthStencilFormat = (D3DFORMAT) d3dDepthFormat[i];
- break;
+ // printf("\n ZDepth %d, Stencil %d ",d3dDepthTable[i],d3dStencilDepthTable[i]);
+ if (d3dDepthTable[i] >= minZDepth && d3dStencilDepthTable[i] >= minZDepthStencil )
+ {
+ depthStencilFormat = (D3DFORMAT) d3dDepthFormat[i];
+ break;
}
- }
- }
+ }//if
+ }// for
+ // if none suitable found
+
}
diff --git a/src/native/d3d/D3dDeviceInfo.hpp b/src/native/d3d/D3dDeviceInfo.hpp
index ffb4587..1d63559 100644
--- a/src/native/d3d/D3dDeviceInfo.hpp
+++ b/src/native/d3d/D3dDeviceInfo.hpp
@@ -47,9 +47,13 @@ public:
// max z buffer depth support
UINT maxZBufferDepthSize;
+ // max stencil buffer depth support
+ UINT maxStencilDepthSize; // new on 1.4
+
// Max vertex count support for each primitive
DWORD maxVertexCount[GEO_TYPE_INDEXED_LINE_STRIP_SET+1];
+ BOOL supportStencil; // new on 1.4
BOOL supportShaders11;
BOOL isHardware;
BOOL isHardwareTnL;
@@ -87,7 +91,7 @@ public:
BOOL supportAntialiasing();
D3DMULTISAMPLE_TYPE getBestMultiSampleType();
int getTextureFeaturesMask();
- void findDepthStencilFormat(int minZDepth);
+ void findDepthStencilFormat(int minZDepth, int minZDepthStencil);
};
diff --git a/src/native/d3d/D3dDriverInfo.cpp b/src/native/d3d/D3dDriverInfo.cpp
index a2d848f..30f2cc8 100644
--- a/src/native/d3d/D3dDriverInfo.cpp
+++ b/src/native/d3d/D3dDriverInfo.cpp
@@ -32,21 +32,25 @@ OSVERSIONINFO osvi;
// When the index is greater than 65535, the nvidia driver will
// consider it to be N % 65535. However it works fine in
// hardware vertex processing mode.
+//@TODO check this with Cap Bits
UINT vertexBufferMaxVertexLimit = 65535;
// True to disable setting D3DRS_MULTISAMPLEANTIALIAS
// Rendering state.
BOOL implicitMultisample;
-D3DFORMAT d3dDepthFormat[D3DDEPTHFORMATSIZE] = {D3DFMT_D15S1,
- D3DFMT_D24S8,
- D3DFMT_D24X4S4,
- D3DFMT_D16_LOCKABLE,
- D3DFMT_D16,
- D3DFMT_D32};
+D3DFORMAT d3dDepthFormat[D3DDEPTHFORMATSIZE] = { D3DFMT_D15S1,
+ D3DFMT_D24S8,
+ D3DFMT_D24X4S4,
+ D3DFMT_D16_LOCKABLE,
+ D3DFMT_D16,
+ D3DFMT_D32
+ };
// This should match the depth bit in the above array
-int d3dDepthTable[D3DDEPTHFORMATSIZE] = {15, 24, 24, 16, 16, 32};
+int d3dDepthTable[D3DDEPTHFORMATSIZE] = {15, 24, 24, 16, 16, 32};
+int d3dStencilDepthTable[D3DDEPTHFORMATSIZE]={ 1, 8, 4, 0, 0, 0};
+
D3DLIGHT9 ambientLight;
D3dDriverInfo::D3dDriverInfo()
@@ -169,16 +173,19 @@ VOID buildDriverList(LPDIRECT3D9 pD3D)
pDevice->deviceType = deviceTypes[j];
pD3D->GetDeviceCaps(i, deviceTypes[j], &d3dCaps);
pDevice->setCaps(&d3dCaps);
+
pDevice->desktopCompatible =
SUCCEEDED(pD3D->CheckDeviceType(i, deviceTypes[j],
pDriver->desktopMode.Format,
pDriver->desktopMode.Format,
TRUE));
+
pDevice->fullscreenCompatible =
SUCCEEDED(pD3D->CheckDeviceType(i,deviceTypes[j],
pDriver->desktopMode.Format,
pDriver->desktopMode.Format,
FALSE));
+
pDevice->maxZBufferDepthSize = 0;
if (pDevice->isHardwareTnL) {
@@ -203,10 +210,21 @@ VOID buildDriverList(LPDIRECT3D9 pD3D)
pDriver->desktopMode.Format,
pDriver->desktopMode.Format,
d3dDepthFormat[k]));
- if (pDevice->depthFormatSupport[k]) {
- if (d3dDepthTable[k] > pDevice->maxZBufferDepthSize) {
- pDevice->maxZBufferDepthSize = d3dDepthTable[k];
- }
+ if (pDevice->depthFormatSupport[k])
+ {
+ if (d3dDepthTable[k] > pDevice->maxZBufferDepthSize)
+ {
+ pDevice->maxZBufferDepthSize = d3dDepthTable[k];
+ pDevice->maxStencilDepthSize = d3dStencilDepthTable[k];
+ if (d3dStencilDepthTable[k]>0)
+ {
+ pDevice->supportStencil = true;
+ }
+ else
+ {
+ pDevice->supportStencil = false;
+ }
+ }
}
}
diff --git a/src/native/d3d/D3dDriverInfo.hpp b/src/native/d3d/D3dDriverInfo.hpp
index 5c5f0ca..d6fbcc2 100644
--- a/src/native/d3d/D3dDriverInfo.hpp
+++ b/src/native/d3d/D3dDriverInfo.hpp
@@ -22,6 +22,7 @@
extern D3DFORMAT d3dDepthFormat[D3DDEPTHFORMATSIZE];
extern int d3dDepthTable[D3DDEPTHFORMATSIZE];
+extern int d3dStencilDepthTable[D3DDEPTHFORMATSIZE];
class D3dDriverInfo {
public:
diff --git a/src/native/d3d/D3dUtil.cpp b/src/native/d3d/D3dUtil.cpp
index 81d2182..71c4e1d 100644
--- a/src/native/d3d/D3dUtil.cpp
+++ b/src/native/d3d/D3dUtil.cpp
@@ -202,7 +202,7 @@ typedef struct _PIXELFORMAT {
DWORD dwRBitMask;
DWORD dwGBitMask;
DWORD dwBBitMask;
- DWORD dwRGBAlphaBitMask;
+ DWORD dwRGBAlphaBitMask;
BOOL noAlpha;
} PIXELFORMAT;
@@ -210,6 +210,8 @@ typedef struct _PIXELFORMAT {
typedef struct _DEPTHPIXELFORMAT {
DWORD dwZBufferBitDepth;
DWORD dwZBitMask;
+ DWORD dwStencilBitDepth;
+ DWORD dwStencilBitMask;
} DEPTHPIXELFORMAT;
@@ -246,6 +248,7 @@ char* getPixelFormatName(D3DFORMAT f)
// If there is a new D3DFORMAT, just add it here and
// our copy procedures can handle any format specific
// as bit mask.
+//@TODO add floating point pixelFormats
VOID computePixelFormat(PIXELFORMAT *ddpf, D3DFORMAT format)
{
switch (format) {
@@ -388,20 +391,38 @@ VOID computeDepthPixelFormat(DEPTHPIXELFORMAT *ddpf,
case D3DFMT_D16:
ddpf->dwZBufferBitDepth = 16;
ddpf->dwZBitMask = 0xffff;
+ ddpf->dwStencilBitDepth = 0;
+ ddpf->dwStencilBitMask = 0x0000;
break;
case D3DFMT_D15S1:
ddpf->dwZBufferBitDepth = 16;
ddpf->dwZBitMask = 0xfffe;
+ ddpf->dwStencilBitDepth = 1;
+ ddpf->dwStencilBitMask = 0x0001;
break;
case D3DFMT_D32:
ddpf->dwZBufferBitDepth = 32;
ddpf->dwZBitMask = 0xffffffff;
+ ddpf->dwStencilBitDepth = 0;
+ ddpf->dwStencilBitMask = 0x000000;
break;
case D3DFMT_D24S8:
+ ddpf->dwZBufferBitDepth = 32;
+ ddpf->dwZBitMask = 0xffffff00;
+ ddpf->dwStencilBitDepth = 8;
+ ddpf->dwStencilBitMask = 0x00000ff;
+ break;
case D3DFMT_D24X8:
+ ddpf->dwZBufferBitDepth = 32;
+ ddpf->dwZBitMask = 0xffffff00;
+ ddpf->dwStencilBitDepth = 0;
+ ddpf->dwStencilBitMask = 0x0000000;
+ break;
case D3DFMT_D24X4S4:
ddpf->dwZBufferBitDepth = 32;
ddpf->dwZBitMask = 0xffffff00;
+ ddpf->dwStencilBitDepth = 4;
+ ddpf->dwStencilBitMask = 0x000000f;
break;
default:
printf("Unknown depth buffer format %d\n", format);
diff --git a/src/native/d3d/GeometryArrayRetained.cpp b/src/native/d3d/GeometryArrayRetained.cpp
index 681395c..d4f8b7c 100644
--- a/src/native/d3d/GeometryArrayRetained.cpp
+++ b/src/native/d3d/GeometryArrayRetained.cpp
@@ -2362,7 +2362,9 @@ void renderGeometry(JNIEnv *env,
vb->isIndexPrimitive = true;
renderTypeSet = true;
// fall through
- } else { // line mode
+ }
+ else
+ { // line mode
// we don't want to see extra line appear in the
// diagonal of quads if it splits into two
// triangles. This is REALLY SLOW !!!
@@ -2978,40 +2980,46 @@ void renderIndexGeometry(JNIEnv *env,
vb->primitiveType = D3DPT_FORCE_DWORD;
- for (i = 0; i < (indexCount >> 2); i++) {
- if (d3dCtx->cullMode != D3DCULL_NONE) {
- // Do back face culling here
- idx0 = *idxPtr++;
- idx1 = *idxPtr++;
- idx2 = *idxPtr++;
- idx3 = *idxPtr++;
- if (strideData->fpositionPtr) {
- fspt = strideData->fpositionPtr + posStride*idx0;
- worldCoord[0].x = *fspt++;
- worldCoord[0].y = *fspt++;
- worldCoord[0].z = *fspt++;
- fspt = strideData->fpositionPtr + posStride*idx1;
- worldCoord[1].x = *fspt++;
- worldCoord[1].y = *fspt++;
- worldCoord[1].z = *fspt++;
- fspt = strideData->fpositionPtr + posStride*idx2;
- worldCoord[2].x = *fspt++;
- worldCoord[2].y = *fspt++;
- worldCoord[2].z = *fspt++;
- } else {
- dspt = strideData->dpositionPtr + posStride*idx0;
- worldCoord[0].x = *dspt++;
- worldCoord[0].y = *dspt++;
- worldCoord[0].z = *dspt++;
- dspt = strideData->dpositionPtr + posStride*idx1;
- worldCoord[1].x = *dspt++;
- worldCoord[1].y = *dspt++;
- worldCoord[1].z = *dspt++;
- dspt = strideData->dpositionPtr + posStride*idx2;
- worldCoord[2].x = *dspt++;
- worldCoord[2].y = *dspt++;
- worldCoord[2].z = *dspt++;
- }
+ for (i = 0; i < (indexCount >> 2); i++)
+ {
+ if (d3dCtx->cullMode != D3DCULL_NONE)
+ {
+ // Do back face culling here
+ idx0 = *idxPtr++;
+ idx1 = *idxPtr++;
+ idx2 = *idxPtr++;
+ idx3 = *idxPtr++;
+
+ if (strideData->fpositionPtr)
+ {
+ fspt = strideData->fpositionPtr + posStride*idx0;
+ worldCoord[0].x = *fspt++;
+ worldCoord[0].y = *fspt++;
+ worldCoord[0].z = *fspt++;
+ fspt = strideData->fpositionPtr + posStride*idx1;
+ worldCoord[1].x = *fspt++;
+ worldCoord[1].y = *fspt++;
+ worldCoord[1].z = *fspt++;
+ fspt = strideData->fpositionPtr + posStride*idx2;
+ worldCoord[2].x = *fspt++;
+ worldCoord[2].y = *fspt++;
+ worldCoord[2].z = *fspt++;
+ }
+ else
+ {
+ dspt = strideData->dpositionPtr + posStride*idx0;
+ worldCoord[0].x = *dspt++;
+ worldCoord[0].y = *dspt++;
+ worldCoord[0].z = *dspt++;
+ dspt = strideData->dpositionPtr + posStride*idx1;
+ worldCoord[1].x = *dspt++;
+ worldCoord[1].y = *dspt++;
+ worldCoord[1].z = *dspt++;
+ dspt = strideData->dpositionPtr + posStride*idx2;
+ worldCoord[2].x = *dspt++;
+ worldCoord[2].y = *dspt++;
+ worldCoord[2].z = *dspt++;
+ }
d3dCtx->transform(&worldCoord[0], &screenCoord[0]);
d3dCtx->transform(&worldCoord[1], &screenCoord[1]);
@@ -3020,46 +3028,56 @@ void renderIndexGeometry(JNIEnv *env,
screenCoord[0].sy -= screenCoord[1].sy;
screenCoord[2].sx -= screenCoord[1].sx;
screenCoord[2].sy -= screenCoord[1].sy;
- if (d3dCtx->cullMode == D3DCULL_CW) {
- if ((screenCoord[0].sx*screenCoord[2].sy -
- screenCoord[2].sx*screenCoord[0].sy) >= 0) {
- DrawIndexPolygonLine(d3dCtx,
- device,
- vertexFormat,
- strideData,
- idx0, idx1,
- idx2, idx3);
- }
- } else { // Clip front face
- if ((screenCoord[0].sx*screenCoord[2].sy -
- screenCoord[2].sx*screenCoord[0].sy) <= 0) {
- DrawIndexPolygonLine(d3dCtx,
- device,
- vertexFormat,
- strideData,
- idx0, idx1,
- idx2, idx3);
- }
+
+ if (d3dCtx->cullMode == D3DCULL_CW)
+ {
+ if ((screenCoord[0].sx*screenCoord[2].sy -
+ screenCoord[2].sx*screenCoord[0].sy) >= 0)
+ {
+ DrawIndexPolygonLine(d3dCtx,
+ device,
+ vertexFormat,
+ strideData,
+ idx0, idx1,
+ idx2, idx3);
+ }
+ }
+ else
+ { // Clip front face
+ if ((screenCoord[0].sx*screenCoord[2].sy -
+ screenCoord[2].sx*screenCoord[0].sy) <= 0)
+ {
+ DrawIndexPolygonLine(d3dCtx,
+ device,
+ vertexFormat,
+ strideData,
+ idx0, idx1,
+ idx2, idx3);
+ }
}
- } else {
- // cullMode == D3DCULL_NONE
- DrawIndexPolygonLine(d3dCtx,
- device,
- vertexFormat,
- strideData,
- idx0, idx1,
- idx2, idx3);
- }
- }
+ }
+ else
+ {
+ // cullMode == D3DCULL_NONE
+ DrawIndexPolygonLine(d3dCtx,
+ device,
+ vertexFormat,
+ strideData,
+ idx0, idx1,
+ idx2, idx3);
+ }
+ }//for
+
if (((vertexFormat & D3DFVF_DIFFUSE) == 0) &&
- (!d3dCtx->isLightEnable)) {
- d3dCtx->restoreDefaultLightMaterial();
+ (!d3dCtx->isLightEnable))
+ {
+ d3dCtx->restoreDefaultLightMaterial();
}
// Don't call vb->Renderer() at the end
return;
}
- //end Quad WireFrame
+ //end index Quad WireFrame
// fall through
case GEO_TYPE_INDEXED_TRI_SET:
@@ -4491,6 +4509,7 @@ void executeIndexedGeometryArray(JNIEnv *env,
env->ReleasePrimitiveArrayCritical(indexCoord,
strideData.indexPtr, NULL);
+
}
diff --git a/src/native/d3d/NativeConfigTemplate3D.cpp b/src/native/d3d/NativeConfigTemplate3D.cpp
index c18134b..db2dace 100644
--- a/src/native/d3d/NativeConfigTemplate3D.cpp
+++ b/src/native/d3d/NativeConfigTemplate3D.cpp
@@ -20,7 +20,7 @@ jboolean JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_isStereoAvailable(
jlong pFormatInfo,
jboolean offScreen)
{
- // DirectX 8.0 don't support stereo
+ // DirectX 9.0 don't support stereo
return false;
}
@@ -47,20 +47,24 @@ jboolean JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_isSceneAntialiasing
BOOL antialiasingSupport = false;
lock();
- if (d3dDriverList == NULL) {
+ if (d3dDriverList == NULL)
+ {
D3dDriverInfo::initialize(env);
}
- if (d3dDriverList != NULL) {
- D3dDriverInfo *driverInfo = d3dDriverList[screen];
- for (int i=0; i < numDeviceTypes; i++) {
+ if (d3dDriverList != NULL)
+ {
+ D3dDriverInfo *driverInfo = d3dDriverList[screen];
+ for (int i=0; i < numDeviceTypes; i++)
+ {
D3dDeviceInfo *pDeviceInfo = driverInfo->d3dDeviceList[i];
if (pDeviceInfo->desktopCompatible &&
- pDeviceInfo->supportAntialiasing()) {
- antialiasingSupport = true;
- break;
- }
- }
+ pDeviceInfo->supportAntialiasing())
+ {
+ antialiasingSupport = true;
+ break;
+ }
+ }
}
unlock();
return antialiasingSupport;
@@ -74,6 +78,8 @@ jboolean JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_isSceneAntialiasing
return JNI_FALSE;
}
+
+
extern "C" JNIEXPORT
jint JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_choosePixelFormat(
JNIEnv *env,
@@ -84,6 +90,7 @@ jint JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_choosePixelFormat(
jlongArray offScreenPFArray)
{
int depth, red, green, blue;
+ int stencilDepth;
int retValue = -1;
jint *mx_ptr = (jint *) env->GetPrimitiveArrayCritical(attrList, NULL);
@@ -91,43 +98,51 @@ jint JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_choosePixelFormat(
green = mx_ptr[GREEN_SIZE];
blue = mx_ptr[BLUE_SIZE];
depth = mx_ptr[DEPTH_SIZE];
+ stencilDepth = mx_ptr[STENCIL_SIZE];
env->ReleasePrimitiveArrayCritical(attrList, mx_ptr, 0);
- if (mx_ptr[STEREO] != REQUIRED) {
- lock();
-
- if (d3dDriverList == NULL) {
- D3dDriverInfo::initialize(env);
- }
+ if (mx_ptr[STEREO] != REQUIRED)
+ {
+ lock();
+ if (d3dDriverList == NULL)
+ {
+ D3dDriverInfo::initialize(env);
+ }
- if (d3dDriverList != NULL) {
+ if (d3dDriverList != NULL)
+ {
BOOL bFullScreen;
D3dDriverInfo *pDriver = d3dDriverList[screen];
- D3dDeviceInfo *deviceInfo =
- D3dCtx::setDeviceInfo(pDriver, &bFullScreen, depth);
-
- if (deviceInfo != NULL) {
- if ((depth <= deviceInfo->maxZBufferDepthSize) &&
- (red <= pDriver->redDepth) &&
- (green <= pDriver->greenDepth) &&
- (blue <= pDriver->blueDepth)) {
- retValue = depth;
- }
+ D3dDeviceInfo *deviceInfo = D3dCtx::setDeviceInfo(pDriver, &bFullScreen, depth, stencilDepth);
+
+ if (deviceInfo != NULL)
+ {
+ if ((depth <= deviceInfo->maxZBufferDepthSize) &&
+ (red <= pDriver->redDepth) &&
+ (green <= pDriver->greenDepth) &&
+ (blue <= pDriver->blueDepth)&&
+ (stencilDepth)<= deviceInfo->maxStencilDepthSize)
+ {
+ // first 0-7bits for depth,8-15 Stencil
+ retValue = depth |(stencilDepth <<8);
+ }
}
}
unlock();
}
- if (mx_ptr[ANTIALIASING] == REQUIRED) {
- if (Java_javax_media_j3d_NativeConfigTemplate3D_isSceneAntialiasingMultisampleAvailable(env, obj, 0, JNI_TRUE, screen) == JNI_TRUE)
+ if (mx_ptr[ANTIALIASING] == REQUIRED)
+ {
+ if (Java_javax_media_j3d_NativeConfigTemplate3D_isSceneAntialiasingMultisampleAvailable(env, obj, 0, JNI_TRUE, screen) == JNI_TRUE)
{
- retValue |= (1 << 31);
- } else {
- retValue = -1;
- }
+ retValue |= (1 << 31);
+ }
+ else
+ {
+ retValue = -1;
+ }
}
-
return retValue;
}
@@ -136,13 +151,22 @@ jint JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_choosePixelFormat(
/*
* Class: javax_media_j3d_NativeConfigTemplate3D
* Method: getStencilSize
- * Signature: (JZ)I
- * @TODO: FIX THIS !!!!!
+ * Signature: (JZ)I *
*/
JNIEXPORT jint JNICALL Java_javax_media_j3d_NativeConfigTemplate3D_getStencilSize
- (JNIEnv *, jobject, jlong, jboolean)
+ (JNIEnv *env, jobject obj, jlong pFormatInfo, jboolean offScreen)
{
- // dummy value
-
- return 8;
+ int stencilSize = (int)pFormatInfo;
+
+ stencilSize = (stencilSize >> 8) & 0xff;
+
+ /** // next version pFormatInfo will be a D3DFORMAT value or index for
+ D3DFORMAT fmt = d3dCtx->deviceInfo->depthStencilFormat;
+ if (fmt == D3DFMT_D15S1) stencilSize = 1;
+ else
+ if (fmt == D3DFMT_D24X4S4) stencilSize = 4;
+ else
+ if(fmt == D3DFMT_D24S8)stencilSize = 8;
+ */
+ return stencilSize;
}
diff --git a/src/native/d3d/StdAfx.h b/src/native/d3d/StdAfx.h
index d653594..4e86990 100644
--- a/src/native/d3d/StdAfx.h
+++ b/src/native/d3d/StdAfx.h
@@ -25,11 +25,20 @@
#pragma once
#endif // _MSC_VER > 1000
+#ifndef _MT
+#define _MT
+#endif
+
// Exclude rarely-used stuff from Windows headers
+#define VC_EXTRALEAN
#define WIN32_LEAN_AND_MEAN
+
+//#undef _AFXDLL
+//#undef _UNICODE
+
// Windows Header Files:
-#include <afx.h>
+#include <afx.h>
#include <winbase.h>
#include <windows.h>
#include <multimon.h>
@@ -46,6 +55,7 @@
#include <d3d9.h>
#include <dxerr9.h>
#include <d3dx9.h>
+#include <d3dx9tex.h>
#include <vector>
#include <algorithm>
using namespace std ;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-15 02:05:54 +0000