rohezal

Members
  • Content count

    4
  • Joined

  • Last visited

Community Reputation

107 Neutral

About rohezal

  • Rank
    Newbie
  1. Here is the solution, including the coordinate transformation from open gl to directx (which is tricky with 16x4 subimages in the texture, it is normaly flipped without the conversion) // (C)2006 S2 Games // mesh_shadowed.vsh modified by rohezal // // Default mesh vertex shader with shadowmap support //============================================================================= //============================================================================= // Headers //============================================================================= #include "../common/common.h" #include "../common/fog.h" //============================================================================= // Global variables //============================================================================= float4x4    mWorldViewProj;             // World * View * Projection transformation float4x4    mWorldView;                 // World * View float3x3    mWorldViewRotate;        // World rotation for normals float4        vSunPositionView; float3        vAmbient; float3        vSunColor; float3        vSunColorSpec; float        fGlossiness; #if (SHADOWS == 1)     #ifdef SHADOW_SPLIT_PROJECTION         float4x4    mLightWorldViewProjTexSplit[4];  // Light's World * View * Projection * Tex     #else         float4x4    mLightWorldViewProjTex;  // Light's World * View * Projection * Tex     #endif #endif float4        vColor; #if (NUM_BONES > 0)     float4x3        vBones[NUM_BONES]; #endif #ifdef CLOUDS     float4x4    mCloudProj; #endif #if (FOG_OF_WAR == 1)     float4x4    mFowProj; #endif //============================================================================= // Vertex shader output structure //============================================================================= #define OBJECT_SIZE 100 //ugly hack but hey S2upid at work #define OBJECT_HALFSIZE OBJECT_SIZE/2 //ugly hack but hey S2upid at work #define DEGREE_TO_RADIANS 0.017453f //constant for transforming degrees in radians #define NUMBER_OF_IMAGES 16.0f //number of images in texture, per row!!! #define DEGREE_SIZE_OF_IMAGE (360/NUMBER_OF_IMAGES) //if there a cirle of images, how many degrees of 360 has on single image. 16 images = 22.5 #define NUMBER_OF_ROWS 4.0f //if there a cirle of images, how many degrees of 360 has on single image. 16 images = 22.5 struct VS_OUTPUT {     float4 Position      : POSITION;     float4 Color0        : COLOR0;     float2 Texcoord0     : TEXCOORDX;         #include "../common/inc_texcoord.h" #if (LIGHTING_QUALITY == 0 || FALLOFF_QUALITY == 0)     float3 PositionView : TEXCOORDX;         #include "../common/inc_texcoord.h" #endif #if (LIGHTING_QUALITY == 0)     float3 Normal        : TEXCOORDX;         #include "../common/inc_texcoord.h"     float3 Tangent       : TEXCOORDX;         #include "../common/inc_texcoord.h"     float3 Binormal      : TEXCOORDX;         #include "../common/inc_texcoord.h" #elif (LIGHTING_QUALITY == 1)     float3 HalfAngle     : TEXCOORDX;         #include "../common/inc_texcoord.h"     float3 SunLight      : TEXCOORDX;         #include "../common/inc_texcoord.h" #elif (LIGHTING_QUALITY == 2)     float3 DiffLight  : TEXCOORDX;         #include "../common/inc_texcoord.h"     float3 SpecLight  : TEXCOORDX;         #include "../common/inc_texcoord.h" #elif (LIGHTING_QUALITY == 3)     float3 DiffLight  : TEXCOORDX;         #include "../common/inc_texcoord.h" #endif #if (SHADOWS == 1)     #ifdef SHADOW_SPLIT_PROJECTION         float4 TexcoordLight0 : TEXCOORDX;             #include "../common/inc_texcoord.h"         float4 TexcoordLight1 : TEXCOORDX;             #include "../common/inc_texcoord.h"         float4 TexcoordLight2 : TEXCOORDX;             #include "../common/inc_texcoord.h"         float4 TexcoordLight3 : TEXCOORDX;             #include "../common/inc_texcoord.h"     #else         float4 TexcoordLight : TEXCOORDX; // Texcoord in light texture space             #include "../common/inc_texcoord.h"     #endif #endif #ifdef CLOUDS     float4 TexcoordClouds : TEXCOORDX;             #include "../common/inc_texcoord.h" #endif #if ((FOG_QUALITY == 1 && FOG_TYPE != 0) || (FALLOFF_QUALITY == 1 && (FOG_TYPE != 0 || SHADOWS == 1)) || FOG_OF_WAR == 1)     float4 Last : TEXCOORDX;         #include "../common/inc_texcoord.h" #endif }; //============================================================================= // Vertex shader input structure //============================================================================= struct VS_INPUT {     float3 Position   : POSITION;     float3 Normal     : NORMAL;     float2 Texcoord0  : TEXCOORD0;     float3 Tangent    : TEXCOORD1; #if (NUM_BONES > 0)     int4 BoneIndex    : TEXCOORD_BONEINDEX;     float4 BoneWeight : TEXCOORD_BONEWEIGHT; #endif }; //============================================================================= // Vertex Shader //============================================================================= VS_OUTPUT VS( VS_INPUT In ) {     VS_OUTPUT Out;      #if ((FOG_QUALITY == 1 && FOG_TYPE != 0) || (FALLOFF_QUALITY == 1 && (FOG_TYPE != 0 || SHADOWS == 1)) || FOG_OF_WAR == 1)     Out.Last = 0; #endif          float3 vInNormal = (In.Normal / 255.0f) * 2.0f - 1.0f;     float3 vInTangent = (In.Tangent / 255.0f) * 2.0f - 1.0f;      #if (NUM_BONES > 0)     float3 vPosition = 0.0f;     float3 vNormal = 0.0f;     float3 vTangent = 0.0f;     //     // GPU Skinning     // Blend bone matrix transforms for this bone     //          int4 vBlendIndex = In.BoneIndex;     float4 vBoneWeight = In.BoneWeight / 255.0f;          float4x3    mBlend = 0.0f;     for (int i = 0; i < NUM_BONE_WEIGHTS; ++i)         mBlend += vBones[vBlendIndex[i]] * vBoneWeight[i];     float3x3    mAxis = float3x3(mBlend[0], mBlend[1], mBlend[2]);     float3        vPos = mBlend[3];          vPosition = mul(In.Position, mAxis) + vPos;     vNormal = mul(vInNormal, mAxis);     vTangent = mul(vInTangent, mAxis);          vNormal = normalize(vNormal);     vTangent = normalize(vTangent); #else     float3 vPosition = In.Position;     float3 vNormal = vInNormal;     float3 vTangent = vInTangent; #endif     float3 vPositionView = mul(float4(vPosition, 1.0f), mWorldView).xyz;          //own code          float3 objectNormal     = mul(vNormal, mWorldViewRotate);     float3 camVector    = float3(0.0f,0.0f,-1.0f);     float3 camVector2 = -normalize(vPositionView);               //get the INVERSE angel. calculate the angle between object and camera and go in the opposite angle     //cos and sin can only go from -1 to 1, so 180 = -180 and he can decide     float cosAngle = dot(objectNormal,camVector2);     //the sin is always positive, since it is the area of a parallelo gram. check if the quad face left or right from the cam (-1)     float sinAngle = sin(acos(cosAngle)) * (objectNormal.x / max(abs(objectNormal.x), 0.001f));          //float4x4 rotMatrixZ = float4x4(1.0f,0.0f,0.0f,0.0f, 0.0f,1.0f,0.0f,0.0f, 0.0f,0.0f,1.0f,0.0f, 0.0f,0.0f,0.0f,1.0f);     float4x4 rotMatrixZ = float4x4(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 );     rotMatrixZ[0][0] = 1.0f;     rotMatrixZ[1][1] = 1.0f;     rotMatrixZ[2][2] = 1.0f;     rotMatrixZ[3][3] = 1.0f;     rotMatrixZ[0][0] = -cosAngle;     rotMatrixZ[1][0] = -sinAngle;     rotMatrixZ[0][1] = sinAngle;     rotMatrixZ[1][1] = -cosAngle;              //Out.Position      = mul(mWorldViewProj,  mul(rotMatrixZ,float4(In.Position, 1.0f)));     Out.Position      = mul(mul(float4(In.Position, 1.0f),rotMatrixZ),mWorldViewProj);     //do it again for the texture     cosAngle = dot(objectNormal,camVector);     sinAngle = sin(acos(cosAngle)) * (objectNormal.x / max(abs(objectNormal.x), 0.001f));          //grid code     //cos - 1 ... ups builded a cirle from -180 to 180... wtf this was not by purpose lol. 0 -> -180 -> +180 ->0     //float angle = (cosAngle - 1) * 90 * (sinAngle/abs(sinAngle)) + min(0,sinAngle/abs(sinAngle)) * 180;     //transform the creative solution *LOOOL* to a normal angle from 0 to 360 degree.     //angle = -angle*(sinAngle/abs(sinAngle)) * max(sinAngle/abs(sinAngle),0) + 180 + abs(sinAngle)*180;     //    0 - 180                                //180 + i*180 where i = 0 to 1     //fucked up but works. for normal people: first line 0 - 90, second 90 - 180, third 180-270, fourth 270 - 360     //if sin > 0 and cos > 0 then first line, if sin > 0 and cos < 0 then second line + 90 and so on.          float angle = sinAngle * 90 * max(sinAngle/abs(sinAngle),0) * max(cosAngle/abs(cosAngle),0)  //sin pos cos pos     + min (cosAngle/abs(cosAngle),0) * (cosAngle/abs(cosAngle)) * max(0,sinAngle/abs(sinAngle)) * (90 + 90 * abs(cosAngle)) //cos neg sin pos     + min (cosAngle/abs(cosAngle),0) * (cosAngle/abs(cosAngle)) * min (sinAngle/abs(sinAngle),0)  * (sinAngle/abs(sinAngle)) * (180 + 90 * abs(sinAngle)) //cos neg sin neg     + max(0,cosAngle/abs(cosAngle)) * min (sinAngle/abs(sinAngle),0) * (sinAngle/abs(sinAngle)) * (270 + 90 * abs(cosAngle)); //cos neg sin pos               float v_vImageId = floor(angle * NUMBER_OF_ROWS / DEGREE_SIZE_OF_IMAGE);     //v_vImageId =  float ( mod( int(v_vImageId) , int(NUMBER_OF_IMAGES) ) );     //no mod this sux     v_vImageId =  v_vImageId - NUMBER_OF_IMAGES * floor(v_vImageId/NUMBER_OF_IMAGES);               //float v_vImageId = int(((angle  -  90 * floor(angle/90)) / DEGREE_SIZE_OF_IMAGE));     //no mod fuuuu MS          /*     float v_vImageId = int(angle  / DEGREE_SIZE_OF_IMAGE);     v_vImageId = v_vImageId  - NUMBER_OF_ROWS * floor(v_vImageId/NUMBER_OF_ROWS);     */     Out.Texcoord0    = In.Texcoord0;     float convert = In.Texcoord0.y - (1-In.Texcoord0.y);     Out.Texcoord0.y    = 1- In.Texcoord0.y;     //use min because the angle is negative     Out.Texcoord0.x = (Out.Texcoord0.x/NUMBER_OF_IMAGES) + max(0,(v_vImageId))/NUMBER_OF_IMAGES;     //Out.Texcoord0.x = (Out.Texcoord0.x/NUMBER_OF_IMAGES) + int(angle/DEGREE_SIZE_OF_IMAGE)/NUMBER_OF_IMAGES;     //Out.Texcoord0.x = (Out.Texcoord0.x/16.0f)+ v_vImageId/16.0f;          //Out.Texcoord0.y = 1-Out.Texcoord0.y;//translate from open gl to directx     Out.Texcoord0.y = (Out.Texcoord0.y / NUMBER_OF_ROWS) + (NUMBER_OF_ROWS-1)/NUMBER_OF_ROWS  - (1/NUMBER_OF_ROWS) * floor(angle*NUMBER_OF_ROWS/360);     //translate to directx coords         Out.Texcoord0.y = Out.Texcoord0.y+convert*1.0f/NUMBER_OF_ROWS;     //Out.Texcoord0.y = (Out.Texcoord0.y / 4) + testy;     //Out.Position[1]    = Out.Position[1] + Out.Position[1]*(angle/100);     //END OWN CODE          //Out.Position      = mul(float4(vPosition, 1.0f), mWorldViewProj);     Out.Color0        = vColor;     //Out.Texcoord0     = In.Texcoord0; #if (LIGHTING_QUALITY == 0 || FALLOFF_QUALITY == 0)     Out.PositionView  = vPositionView; #endif #if (FALLOFF_QUALITY == 1 && (FOG_TYPE != 0 || SHADOWS == 1))     Out.Last.z = length(vPositionView); #endif      #if (LIGHTING_QUALITY == 0)     Out.Normal        = mul(vNormal, mWorldViewRotate);     Out.Tangent       = mul(vTangent, mWorldViewRotate);     Out.Binormal      = cross(Out.Tangent, Out.Normal); #elif (LIGHTING_QUALITY == 1)     float3 vCamDirection = -normalize(vPositionView);     float3 vLight = vSunPositionView.xyz;     float3 vWVNormal = mul(vNormal, mWorldViewRotate);     float3 vWVTangent = mul(vTangent, mWorldViewRotate);     float3 vWVBinormal = cross(vWVTangent, vWVNormal);     float3x3 mRotate = transpose(float3x3(vWVTangent, vWVBinormal, vWVNormal));          Out.SunLight      = mul(vLight, mRotate);     Out.HalfAngle     = mul(normalize(vLight + vCamDirection), mRotate); #elif (LIGHTING_QUALITY == 2)     float3 vCamDirection = -normalize(vPositionView);     float3 vLight = vSunPositionView.xyz;             float3 vHalfAngle = normalize(vLight + vCamDirection);     float3 vWVNormal = mul(vNormal, mWorldViewRotate);     float fDiffuse = saturate(dot(vWVNormal, vLight));     float fSpecular = saturate(step(0.0f, fDiffuse) * (pow(dot(vWVNormal, vHalfAngle), fGlossiness)));     Out.DiffLight     = vSunColor * fDiffuse;     Out.SpecLight     = vSunColorSpec * fSpecular; #elif (LIGHTING_QUALITY == 3)     float3 vLight = vSunPositionView.xyz;             float3 vWVNormal = mul(vNormal, mWorldViewRotate);     float fDiffuse = saturate(dot(vWVNormal, vLight));     Out.DiffLight     =  vSunColor * fDiffuse; #endif #if (SHADOWS == 1)     #ifdef SHADOW_SPLIT_PROJECTION         Out.TexcoordLight0 = mul(float4(vPosition, 1.0f), mLightWorldViewProjTexSplit[0]);         Out.TexcoordLight1 = mul(float4(vPosition, 1.0f), mLightWorldViewProjTexSplit[1]);         Out.TexcoordLight2 = mul(float4(vPosition, 1.0f), mLightWorldViewProjTexSplit[2]);         Out.TexcoordLight3 = mul(float4(vPosition, 1.0f), mLightWorldViewProjTexSplit[3]);     #else         Out.TexcoordLight = mul(float4(vPosition, 1.0f), mLightWorldViewProjTex);     #endif #endif #ifdef CLOUDS     Out.TexcoordClouds = mul(float4(vPosition, 1.0f), mCloudProj); #endif #if (FOG_QUALITY == 1 && FOG_TYPE != 0)     Out.Last.w = Fog(vPositionView); #endif #if (FOG_OF_WAR == 1)     Out.Last.xy = mul(float4(vPosition, 1.0f), mFowProj).xy; #endif     return Out; //outsourced own code     /*     float test = (angle-2*floor(angle/90));     test = int(test/90);     test = test/2;     */     /*     float test = angle / 360*64;     test = float(int(test));     test = test -16*floor(test/16);     test = test/16;     */          /*     float test = max((angle - 91 *floor (angle/91)),0);          //test =  test * (max(0, test-5.6)/(test-5.6));     //test = int(int (test) / max(int(90/16),1) ) ;          test = int(floor(test / 5.625));     test = test/16;     */     /*     float test = float(int(angle));     test = max((test - 91 *floor (test/91)),0);     test = floor(test / 5.625);     test = floor(test*10 / 16);     test = test/10;     */     /*     float testy = angle;     testy = int(testy/181);     testy = testy/2;     */     /*     float test = min(angle,90.0f);     test = max(test,0.0f);     float adder = 0.0f;          if(test < 5.63f*8)     {         adder = 2.0f / 16.0f;     }          if(test > 5.63f*8)     {         adder = 8.0f/16.0f;     }     */          /*     if(test > 5.63f && test < 11.26f )     {         adder = (1.0f/16.0f);     }     if(test > 11.26f && test < 17.00f )     {         adder = (2.0f/16.0f);     }     */ }
  2. I have only shader access to not a functions for me. I am doing the math myself and it works in open gl: I have no good way to debug I just increase the Y axis with the angle to check it. It grows constantly so I don't think there is the problem . //fucked up but works. for normal people: first line 0 - 90, second 90 - 180, third 180-270, fourth 270 - 360 //if sin > 0 and cos > 0 then first line, if sin > 0 and cos < 0 then second line + 90 and so on. float angle = sinAngle * 90 * max(sinAngle/abs(sinAngle),0) * max(cosAngle/abs(cosAngle),0) //sin pos cos pos + min (cosAngle/abs(cosAngle),0) * (cosAngle/abs(cosAngle)) * max(0,sinAngle/abs(sinAngle)) * (90 + 90 * abs(cosAngle)) //cos neg sin pos + min (cosAngle/abs(cosAngle),0) * (cosAngle/abs(cosAngle)) * min (sinAngle/abs(sinAngle),0) * (sinAngle/abs(sinAngle)) * (180 + 90 * abs(sinAngle)) //cos neg sin neg + max(0,cosAngle/abs(cosAngle)) * min (sinAngle/abs(sinAngle),0) * (sinAngle/abs(sinAngle)) * (270 + 90 * abs(cosAngle)); //cos neg sin pos I want to get the index of the image (like an element from an 1D array int data[64];). There are 64 images. In 1D it would be: int imageId = int(angle /64);   In 2D the idea is ( the array is array[4][16]): int oneDimension = int(angle /64); //angles to image indexes int imageIdX = oneDimension % 16; //x coord or index of the image. int imageIdY = int(oneDimension/ 16); //y coord or index of the image. This works in open gl but not in direct x.   I realy just want to calculate the angle from a sinus and cosinus and the split it in X and Y indexes of a 2D array. Maybe you have a radiant way to do it, but I am bad in radiants.   Here is the working open gl code to make indexX und indexY  from the angle: #define NUMBER_OF_IMAGES 16.0f //number of images in texture, per row!!! #define DEGREE_SIZE_OF_IMAGE (360/NUMBER_OF_IMAGES) //if there a cirle of images, how many degrees of 360 has on single image. 16 images = 22.5 #define NUMBER_OF_ROWS 4.0f //if there a cirle of images, how many degrees of 360 has on single image. 16 images = 22.5 v_vImageId = floor(angle * NUMBER_OF_ROWS / DEGREE_SIZE_OF_IMAGE); v_vImageId = float ( mod( int(v_vImageId) , int(NUMBER_OF_IMAGES) ) ); gl_TexCoord[0] = gl_MultiTexCoord0; //use min because the angle is negative gl_TexCoord[0].x = (gl_TexCoord[0].x/NUMBER_OF_IMAGES) + max(0,(v_vImageId))/NUMBER_OF_IMAGES; gl_TexCoord[0].y = (gl_TexCoord[0].y / NUMBER_OF_ROWS) + (NUMBER_OF_ROWS-1)/NUMBER_OF_ROWS - (1/NUMBER_OF_ROWS) * floor(angle*NUMBER_OF_ROWS/360);
  3. Maybe the convertion betwen sin and cos to a 360 angle is problematic. Does someone know a good formular to calculate a 360 degree angle from a sin and cos?
  4. Hi guys,   I am doing a mod for a game. I can only change the shaders.   It is a billboard cloud (a quad which rotates with the camera and changes it's it texture depending on the viewing angle of the user). If you are at the front you see the dragon face front. If you are 90° degree to the left, the quad rotates and you see the dragonface fromt the left. I am doing this with one mega texture (8K*2K texel). It consists of 16*4 = 64  (512x512 pixel) images next to each other. It works ok .   It allready works in GL SL (open gl). I just move the UV coordinates to display a different part of texture (which is just one of the 512x512 images). When it just were 1x64 images the mapping would be easing 360° degree, so each the image to display would ucoord = ucoord/64 + (int)(angle/64) or something. Now I have 2D mapping and try to get from sin and cos the the degree. It works. Then map it a 16x4 image "array". It works.   But when I try to map it to direct x hlsl it fails. I don't know why. Maybe you have an idea.   If you want to try it:   Grid Shader (starts with  //own code it is a mod like I said): http://pastebin.de/35908   Rotation only Shader (works): http://pastebin.de/35909   The open gl gl sl shader (works): http://pastebin.de/35910